steep 1.7.0.dev.2 → 1.7.0.dev.4

data/lib/steep/services/file_loader.rb

@@ -12,30 +12,25 @@ module Steep
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
 
           pats.each do |path|
-            absolute_path = base_dir + path
-
-            if absolute_path.file?
-              relative_path = absolute_path.relative_path_from(base_dir)
-              if pattern =~ relative_path
-                yield relative_path
-              end
-            else
-              files = if absolute_path.directory?
-                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                      else
-                        Pathname.glob(absolute_path.to_s)
-                      end
-
-              files.sort.each do |source_path|
-                if source_path.file?
-                  relative_path = source_path.relative_path_from(base_dir)
-                  unless pattern.ignore?(relative_path)
-                    yield relative_path
+            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+              if absolute_path.file?
+                relative_path = absolute_path.relative_path_from(base_dir)
+                if pattern =~ relative_path
+                  yield relative_path
+                end
+              else
+                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+
+                files.sort.each do |source_path|
+                  if source_path.file?
+                    relative_path = source_path.relative_path_from(base_dir)
+                    unless pattern.ignore?(relative_path)
+                      yield relative_path
+                    end
                   end
                 end
               end
             end
-
           end
         else
           enum_for :each_path_in_patterns, pattern, commandline_patterns

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
@@ -103,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

data/lib/steep/signature/validator.rb

@@ -134,7 +134,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)

data/lib/steep/subtyping/check.rb

@@ -410,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
@@ -530,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
@@ -862,8 +850,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|
@@ -918,16 +908,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/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