steep 1.6.0 → 1.7.1

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
@@ -404,14 +410,8 @@ module Steep
               relation.map {|type|
                 builder.shape(
                   type,
-                  public_only: true,
-                  config: Interface::Builder::Config.new(
-                    self_type: type,
-                    instance_type: instance_type,
-                    class_type: class_type,
-                    variable_bounds: variable_upper_bounds
-                  )
-                ) or return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
+                  Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+                )&.public_shape() or return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
               }
             )
           end
@@ -524,14 +524,8 @@ module Steep
               relation.map {|type|
                 builder.shape(
                   type,
-                  public_only: true,
-                  config: Interface::Builder::Config.new(
-                    self_type: type,
-                    instance_type: instance_type,
-                    class_type: class_type,
-                    variable_bounds: variable_upper_bounds
-                  )
-                ) or raise
+                  Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+                )&.public_shape or raise
               }
             )
           end
@@ -804,33 +798,37 @@ module Steep
       end
 
       def check_method_type(name, relation)
-        relation.method!
+        Steep.logger.tagged "#{name} : #{relation.sub_type} <: #{relation.super_type}" do
+          relation.method!
 
-        sub_type, super_type = relation
+          sub_type, super_type = relation
 
-        sub_type.type_params.empty? or raise "Expected monomorphic method type: #{sub_type}"
-        super_type.type_params.empty? or raise "Expected monomorphic method type: #{super_type}"
+          sub_type.type_params.empty? or raise "Expected monomorphic method type: #{sub_type}"
+          super_type.type_params.empty? or raise "Expected monomorphic method type: #{super_type}"
 
-        All(relation) do |result|
-          type_relation = Relation.new(sub_type: sub_type.type, super_type: super_type.type)
-
-          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
-            result.add(type_relation) { check_function(name, type_relation) }
-            result.add(ret) do
-              All(ret) do |result|
-                result.add_result(check_self_type_binding(ret, ret.super_type.self_type, ret.sub_type.self_type))
-                result.add(Relation(ret.super_type.type, ret.sub_type.type)) do |block_relation|
-                  check_function(name, block_relation)
+          All(relation) do |result|
+            type_relation = Relation.new(sub_type: sub_type.type, super_type: super_type.type)
+
+            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
+              result.add(type_relation) { check_function(name, type_relation) }
+              result.add(ret) do
+                All(ret) do |result|
+                  result.add_result(check_self_type_binding(ret, ret.super_type.self_type, ret.sub_type.self_type))
+                  result.add(Relation(ret.super_type.type, ret.sub_type.type)) do |block_relation|
+                    check_function(name, block_relation)
+                  end
                 end
               end
+            when Result::Failure
+              result.add(ret.relation) { ret }
+            end.tap do |ret|
+              Steep.logger.debug "result=#{ret.class}"
             end
-          when Result::Failure
-            result.add(ret.relation) { ret }
           end
         end
       end
@@ -856,8 +854,10 @@ module Steep
         relation.function!
 
         All(relation) do |result|
-          result.add(relation.map {|fun| fun.params }) do |rel|
-            check_method_params(name, rel)
+          if relation.sub_type.params && relation.super_type.params
+            result.add(relation.map {|fun| _ = fun.params }) do |rel|
+              check_method_params(name, rel)
+            end
           end
 
           result.add(relation.map {|fun| fun.return_type }) do |rel|
@@ -912,16 +912,23 @@ module Steep
       end
 
       def match_method_type_fails?(name, type1, type2)
-        match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
-          return param_pairs unless param_pairs.is_a?(Array)
+        if type1.type.params && type2.type.params
+          match_params(name, Relation(type1.type.params, type2.type.params)).tap do |param_pairs|
+            return param_pairs unless param_pairs.is_a?(Array)
+          end
         end
 
         case result = expand_block_given(name, Relation(type1.block, type2.block))
         when Result::Base
           return result
         when Relation
-          match_params(name, result.map {|m| m.type.params }).tap do |param_pairs|
-            return param_pairs unless param_pairs.is_a?(Array)
+          type1.block or raise
+          type2.block or raise
+
+          if type1.block.type.params && type2.block.type.params
+            match_params(name, result.map {|m| _ = m.type.params }).tap do |param_pairs|
+              return param_pairs unless param_pairs.is_a?(Array)
+            end
           end
         end
 

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/subtyping/variable_variance.rb

@@ -46,7 +46,7 @@ module Steep
       end
 
       def self.add_params(params, block:, covariants:, contravariants:)
-        params.each_type do |type|
+        params&.each_type do |type|
           add_type(type, variance: block ? :contravariant : :covariant, covariants: covariants, contravariants: contravariants)
         end
       end
@@ -64,12 +64,12 @@ module Steep
             contravariants << type.name
           end
         when AST::Types::Proc
-          type.type.params.each_type do |type|
+          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|
+            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)

data/lib/steep/test.rb

@@ -0,0 +1,9 @@
+Steep.logger.warn(true)
+
+# class Steep::Subtyping::Result::All
+#   def add(*relations)
+#     rel = relations[0]  # Relation[T] < Relation::_Subject
+#     yield rel           # Relation[T] < Relation[_Subject]
+#     true
+#   end
+# end