steep 1.4.0 → 1.5.0.pre.1

data/lib/steep/source.rb

@@ -1,15 +1,19 @@
 module Steep
   class Source
+    attr_reader :buffer
     attr_reader :path
     attr_reader :node
     attr_reader :mapping
+    attr_reader :comments
 
     extend NodeHelper
 
-    def initialize(path:, node:, mapping:)
+    def initialize(buffer:, path:, node:, mapping:, comments:)
+      @buffer = buffer
       @path = path
       @node = node
       @mapping = mapping
+      @comments = comments
     end
 
     class Builder < ::Parser::Builders::Default
@@ -24,7 +28,7 @@ module Steep
     end
 
     def self.new_parser
-      ::Parser::Ruby31.new(Builder.new).tap do |parser|
+      ::Parser::Ruby32.new(Builder.new).tap do |parser|
         parser.diagnostics.all_errors_are_fatal = true
         parser.diagnostics.ignore_warnings = true
       end
@@ -42,6 +46,10 @@ module Steep
       buffer = RBS::Buffer.new(name: path, content: source_code)
       annotation_parser = AnnotationParser.new(factory: factory)
 
+      comments = comments.sort_by do |comment|
+        comment.loc.expression.begin_pos
+      end
+
       comments.each do |comment|
         if comment.inline?
           content = comment.text.delete_prefix('#')
@@ -67,7 +75,7 @@ module Steep
         end
       end
 
-      map = {}
+      map = {} #: Hash[Parser::AST::Node, Array[AST::Annotation::t]]
       map.compare_by_identity
 
       if node
@@ -80,50 +88,62 @@ module Steep
         map[node] << annot
       end
 
-      new(path: path, node: node, mapping: map)
+      new(buffer: buffer, path: path, node: node, mapping: map, comments: comments)
     end
 
     def self.construct_mapping(node:, annotations:, mapping:, line_range: nil)
       case node.type
       when :if
+        cond_node, truthy_node, falsy_node, loc = deconstruct_if_node!(node)
+
         if node.loc.respond_to?(:question)
           # Skip ternary operator
+
           each_child_node node do |child|
             construct_mapping(node: child, annotations: annotations, mapping: mapping, line_range: nil)
           end
         else
-          if node.loc.expression.begin_pos == node.loc.keyword.begin_pos
-            construct_mapping(node: node.children[0],
-                              annotations: annotations,
-                              mapping: mapping,
-                              line_range: nil)
-
-            if node.children[1]
-              if node.loc.keyword.source == "if" || node.loc.keyword.source == "elsif"
-                then_start = node.loc.begin&.last_line || node.children[0].loc.last_line
-                then_end = node.children[2] ? node.loc.else.line : node.loc.last_line
+          if_loc = loc #: NodeHelper::condition_loc
+
+          if if_loc.expression.begin_pos == if_loc.keyword.begin_pos
+            construct_mapping(node: cond_node,annotations: annotations, mapping: mapping, line_range: nil)
+
+            if truthy_node
+              if if_loc.keyword.source == "if" || if_loc.keyword.source == "elsif"
+                # if foo
+                #   bar      <=
+                # end
+                then_start = if_loc.begin&.last_line || cond_node.loc.last_line
+                then_end = if_loc.else&.line || if_loc.last_line
               else
-                then_start = node.loc.else.last_line
-                then_end = node.loc.last_line
+                # unless foo
+                # else
+                #   bar      <=
+                # end
+                if_loc.else or raise
+                then_start = if_loc.else.last_line
+                then_end = loc.last_line
               end
-              construct_mapping(node: node.children[1],
-                                annotations: annotations,
-                                mapping: mapping,
-                                line_range: then_start...then_end)
+              construct_mapping(node: truthy_node, annotations: annotations, mapping: mapping, line_range: then_start...then_end)
             end
 
-            if node.children[2]
-              if node.loc.keyword.source == "if" || node.loc.keyword.source == "elsif"
-                else_start = node.loc.else.last_line
-                else_end = node.loc.last_line
+            if falsy_node
+              if if_loc.keyword.source == "if" || if_loc.keyword.source == "elsif"
+                # if foo
+                # else
+                #   bar      <=
+                # end
+                if_loc.else or raise
+                else_start = if_loc.else.last_line
+                else_end = if_loc.last_line
               else
-                else_start = node.loc.begin&.last_line || node.children[0].loc.last_line
-                else_end = node.children[1] ? node.loc.else.line : node.loc.last_line
+                # unless foo
+                #   bar      <=
+                # end
+                else_start = if_loc.begin&.last_line || cond_node.loc.last_line
+                else_end = if_loc.else&.line || if_loc.last_line
               end
-              construct_mapping(node: node.children[2],
-                                annotations: annotations,
-                                mapping: mapping,
-                                line_range: else_start...else_end)
+              construct_mapping(node: falsy_node, annotations: annotations, mapping: mapping, line_range: else_start...else_end)
             end
 
           else
@@ -135,22 +155,19 @@ module Steep
         end
 
       when :while, :until
-        if node.loc.expression.begin_pos == node.loc.keyword.begin_pos
-          construct_mapping(node: node.children[0],
-                            annotations: annotations,
-                            mapping: mapping,
-                            line_range: nil)
-
-          if node.children[1]
-            body_start = node.children[0].loc.last_line
-            body_end = node.loc.end.line
-
-            construct_mapping(node: node.children[1],
-                              annotations: annotations,
-                              mapping: mapping,
-                              line_range: body_start...body_end)
-          end
+        cond_node, body_node, loc = deconstruct_whileish_node!(node)
 
+        if loc.expression.begin_pos == loc.keyword.begin_pos
+          # prefix while
+          loc.end or raise
+          construct_mapping(node: cond_node, annotations: annotations, mapping: mapping, line_range: nil)
+
+          if body_node
+            body_start = cond_node.loc.last_line
+            body_end = loc.end.line
+
+            construct_mapping(node: body_node, annotations: annotations, mapping: mapping, line_range: body_start...body_end)
+          end
         else
           # postfix while
           each_child_node(node) do |child|
@@ -159,70 +176,63 @@ module Steep
         end
 
       when :while_post, :until_post
-        construct_mapping(node: node.children[0],
-                          annotations: annotations,
-                          mapping: mapping,
-                          line_range: nil)
-
-        if node.children[1]
-          body_start = node.loc.expression.line
-          body_end = node.loc.keyword.line
-
-          construct_mapping(node: node.children[1],
-                            annotations: annotations,
-                            mapping: mapping,
-                            line_range: body_start...body_end)
+        cond_node, body_node, loc = deconstruct_whileish_node!(node)
+
+        construct_mapping(node: cond_node, annotations: annotations, mapping: mapping, line_range: nil)
+
+        if body_node
+          body_start = loc.expression.line
+          body_end = loc.keyword.line
+          construct_mapping(node: body_node, annotations: annotations, mapping: mapping, line_range: body_start...body_end)
         end
 
       when :case
-        if node.children[0]
-          construct_mapping(node: node.children[0], annotations: annotations, mapping: mapping, line_range: nil)
+        cond_node, when_nodes, else_node, loc = deconstruct_case_node!(node)
+
+        if cond_node
+          construct_mapping(node: cond_node, annotations: annotations, mapping: mapping, line_range: nil)
         end
 
-        if node.children.last
-          else_node = node.children.last
-          else_start = node.loc.else.last_line
-          else_end = node.loc.end.line
+        if else_node
+          loc.else or raise
+          loc.end or raise
 
-          construct_mapping(node: else_node,
-                            annotations: annotations,
-                            mapping: mapping,
-                            line_range: else_start...else_end)
+          else_start = loc.else.last_line
+          else_end = loc.end.line
+
+          construct_mapping(node: else_node, annotations: annotations, mapping: mapping, line_range: else_start...else_end)
         end
 
-        node.children.drop(1).each do |child|
-          if child&.type == :when
+        when_nodes.each do |child|
+          if child.type == :when
             construct_mapping(node: child, annotations: annotations, mapping: mapping, line_range: nil)
           end
         end
 
       when :when
-        last_cond = node.children[-2]
-        body = node.children.last
+        operands, body, loc = deconstruct_when_node!(node)
+        last_cond = operands.last or raise
 
-        node.children.take(node.children.size-1).each do |child|
+        operands.each do |child|
           construct_mapping(node: child, annotations: annotations, mapping: mapping, line_range: nil)
         end
 
         if body
-          cond_end = last_cond.loc.last_line+1
+          cond_end = loc.begin&.last_line || last_cond.loc.last_line+1
           body_end = body.loc.last_line
-          construct_mapping(node: body,
-                            annotations: annotations,
-                            mapping: mapping,
-                            line_range: cond_end...body_end)
+          construct_mapping(node: body, annotations: annotations, mapping: mapping, line_range: cond_end...body_end)
         end
 
       when :rescue
-        if node.children.last
-          else_node = node.children.last
-          else_start = node.loc.else.last_line
-          else_end = node.loc.last_line
-
-          construct_mapping(node: else_node,
-                            annotations: annotations,
-                            mapping: mapping,
-                            line_range: else_start...else_end)
+        body, resbodies, else_node, loc = deconstruct_rescue_node!(node)
+
+        if else_node
+          loc.else or raise
+
+          else_start = loc.else.last_line
+          else_end = loc.last_line
+
+          construct_mapping(node: else_node, annotations: annotations, mapping: mapping, line_range: else_start...else_end)
         end
 
         each_child_node(node) do |child|
@@ -236,17 +246,13 @@ module Steep
       end
 
       associated_annotations, other_annotations = annotations.partition do |annot|
+        location = node.loc
+        annot.line or next
+
         case node.type
-        when :def, :module, :class, :block, :ensure, :defs
-          loc = node.loc
-          loc.line <= annot.line && annot.line < loc.last_line
-
-        when :resbody
-          if node.loc.keyword.begin_pos == node.loc.expression.begin_pos
-            # skip postfix rescue
-            loc = node.loc
-            loc.line <= annot.line && annot.line < loc.last_line
-          end
+        when :def, :module, :class, :block, :ensure, :defs, :resbody
+          location = node.loc
+          location.line <= annot.line && annot.line < location.last_line
         else
           if line_range
             line_range.begin <= annot.line && annot.line < line_range.end
@@ -307,7 +313,7 @@ module Steep
         case node.type
         when :dstr, :str
           if node.location.respond_to?(:heredoc_body)
-            yield [node, *parents]
+            yield [[node, *parents], _ = node.location]
           end
         end
 
@@ -322,10 +328,10 @@ module Steep
     end
 
     def find_heredoc_nodes(line, column, position)
-      each_heredoc_node() do |nodes|
+      each_heredoc_node() do |nodes, location|
         node = nodes[0]
 
-        range = node.location.heredoc_body&.yield_self do |r|
+        range = location.heredoc_body&.yield_self do |r|
           r.begin_pos..r.end_pos
         end
 
@@ -377,6 +383,20 @@ module Steep
       end
     end
 
+    def find_comment(line:, column:)
+      pos = buffer.loc_to_pos([line, column])
+
+      comment = comments.bsearch do |comment|
+        pos <= comment.loc.expression.end_pos
+      end
+
+      if comment
+        if comment.loc.expression.begin_pos < pos
+          comment
+        end
+      end
+    end
+
     def self.delete_defs(node, allow_list)
       case node.type
       when :def
@@ -417,7 +437,7 @@ module Steep
           mapping[node_] << annot
         end
 
-        Source.new(path: path, node: node_, mapping: mapping)
+        Source.new(buffer: buffer, path: path, node: node_, mapping: mapping, comments: comments)
       else
         self
       end
@@ -445,7 +465,8 @@ module Steep
           when :return, :break, :next
             # Skip
           when :begin
-            if node.loc.begin
+            location = node.loc #: Parser::Source::Map & Parser::AST::_Collection
+            if location.begin
               # paren
               child_assertions = comments.except(last_line)
               node = map_child_node(node) {|child| insert_type_node(child, child_assertions) }
@@ -468,7 +489,11 @@ module Steep
                 nil,
                 [
                   map_child_node(send) {|child| insert_type_node(child, child_assertions) },
-                  *children.map {|child| insert_type_node(child, child_assertions) }
+                  *children.map do |child|
+                    if child
+                      insert_type_node(child, child_assertions)
+                    end
+                  end
                 ]
               )
             when :numblock
@@ -490,9 +515,35 @@ module Steep
         end
       end
 
-      adjust_location(
-        map_child_node(node, nil) {|child| insert_type_node(child, comments) }
-      )
+      case node.type
+      when :class
+        class_name, super_class, class_body = node.children
+        adjust_location(
+          node.updated(
+            nil,
+            [
+              class_name,
+              super_class,
+              class_body ? insert_type_node(class_body, comments) : nil
+            ]
+          )
+        )
+      when :module
+        module_name, module_body = node.children
+        adjust_location(
+          node.updated(
+            nil,
+            [
+              module_name,
+              module_body ? insert_type_node(module_body, comments) : nil
+            ]
+          )
+        )
+      else
+        adjust_location(
+          map_child_node(node, nil) {|child| insert_type_node(child, comments) }
+        )
+      end
     end
 
     def self.sendish_node?(node)
@@ -509,8 +560,14 @@ module Steep
         end
 
       if send_node
-        if send_node.location.dot
-          send_node.location.selector.line
+        receiver_node, name, _, location = deconstruct_send_node!(send_node)
+
+        if receiver_node
+          if location.dot
+            location.selector.line
+          end
+        else
+          location.selector.line
         end
       end
     end

data/lib/steep/subtyping/check.rb

@@ -637,7 +637,7 @@ module Steep
 
         All(relation) do |result|
           method_pairs.each do |method_name, method_relation|
-            result.add(relation) do
+            result.add(method_relation) do
               check_method(method_name, method_relation)
             end
           end
@@ -808,7 +808,9 @@ module Steep
         All(relation) do |result|
           type_relation = Relation.new(sub_type: sub_type.type, super_type: super_type.type)
 
-          case ret = expand_block_given(name, Relation.new(sub_type: sub_type.block, super_type: super_type.block))
+          ret = expand_block_given(name, Relation.new(sub_type: sub_type.block, super_type: super_type.block))
+
+          case ret
           when true
             result.add(type_relation) { check_function(name, type_relation) }
           when Relation
@@ -822,7 +824,7 @@ module Steep
               end
             end
           when Result::Failure
-            result.add { ret }
+            result.add(ret.relation) { ret }
           end
         end
       end

data/lib/steep/subtyping/variable_variance.rb

@@ -63,6 +63,17 @@ module Steep
             covariants << type.name
             contravariants << type.name
           end
+        when AST::Types::Proc
+          type.type.params.each_type do |type|
+            add_type(type, variance: variance, covariants: contravariants, contravariants: covariants)
+          end
+          add_type(type.type.return_type, variance: variance, covariants: covariants, contravariants: contravariants)
+          if type.block
+            type.block.type.params.each_type do |type|
+              add_type(type, variance: variance, covariants: covariants, contravariants: contravariants)
+            end
+            add_type(type.type.return_type, variance: variance, covariants: contravariants, contravariants: covariants)
+          end
         when AST::Types::Union, AST::Types::Intersection, AST::Types::Tuple
           type.types.each do |ty|
             add_type(ty, variance: variance, covariants: covariants, contravariants: contravariants)

data/lib/steep/thread_waiter.rb

@@ -0,0 +1,35 @@
+module Steep
+  class ThreadWaiter
+    attr_reader :objects, :queue, :waiter_threads
+
+    def initialize(objects)
+      @objects = objects
+      @queue = Thread::Queue.new()
+      @waiter_threads = Set[].compare_by_identity
+
+      objects.each do |object|
+        thread = yield(object)
+
+        waiter_thread = Thread.new(thread) do |thread|
+          Thread.current.report_on_exception = false
+
+          begin
+            thread.join
+          ensure
+            queue << [object, thread]
+          end
+        end
+
+        waiter_threads << waiter_thread
+      end
+    end
+
+    def wait_one
+      unless waiter_threads.empty?
+        obj, th = queue.pop()
+        waiter_threads.delete(th)
+        obj
+      end
+    end
+  end
+end