steep 1.7.0.dev.1 → 1.7.0.dev.3

data/lib/steep/type_construction.rb

@@ -878,6 +878,7 @@ module Steep
             if self_type && method_context!.method
               if super_def = method_context!.super_method
                 super_method = Interface::Shape::Entry.new(
+                  private_method: true,
                   method_types: super_def.defs.map {|type_def|
                     decl = TypeInference::MethodCall::MethodDecl.new(
                       method_name: InstanceMethodName.new(
@@ -1812,7 +1813,7 @@ module Steep
                 .for_branch(right_node)
                 .synthesize(right_node, hint: left_truthy.type, condition: true).to_ary
 
-            right_truthy, right_falsy = interpreter.eval(env: left_falsy.env, node: right_node)
+            right_truthy, right_falsy = interpreter.eval(env: right_context.type_env, node: right_node)
 
             case
             when left_falsy.unreachable
@@ -2611,6 +2612,7 @@ module Steep
           end
         end
       rescue RBS::BaseError => exn
+        Steep.logger.warn("hello")
         Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
         exn.backtrace&.each {|loc| Steep.logger.warn "  #{loc}" }
         typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
@@ -3431,16 +3433,16 @@ module Steep
         self_type: self_type,
         class_type: module_context.module_type,
         instance_type: module_context.instance_type,
-        variable_bounds: variable_context.upper_bounds
+        variable_bounds: context.variable_context.upper_bounds
       )
     end
 
     def calculate_interface(type, method_name = nil, private:)
-      shape = checker.builder.shape(
-        type,
-        public_only: !private,
-        config: builder_config
-      )
+      shape = checker.builder.shape(type, builder_config)
+
+      unless private
+        shape = shape&.public_shape
+      end
 
       if method_name
         if shape
@@ -3622,10 +3624,6 @@ module Steep
       end
     end
 
-    def inspect
-      "#<#{self.class}>"
-    end
-
     def with_child_typing(range:)
       constr = with_new_typing(typing.new_child(range))
 
@@ -4353,7 +4351,7 @@ module Steep
     def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:, block_self_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint, factory: checker.factory)
 
-      # @type var param_types_hash: Hash[Symbol, AST::Types::t]
+      # @type var param_types_hash: Hash[Symbol?, AST::Types::t]
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
@@ -4388,10 +4386,12 @@ module Steep
         end
       end
 
-      param_types_hash.delete_if {|name, _| SPECIAL_LVAR_NAMES.include?(name) }
+      param_types_hash.delete_if {|name, _| name && SPECIAL_LVAR_NAMES.include?(name) }
 
       param_types = param_types_hash.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
         name, type = pair
+        # skip unamed arguments `*`, `**` and `&`
+        next if name.nil?
         hash[name] = [type, nil]
       end
 

data/lib/steep/type_inference/block_params.rb

@@ -57,8 +57,9 @@ module Steep
 
         def variable_types
           each_param.with_object({}) do |param, hash|
+            var_name = param.var || next
             # @type var hash: Hash[Symbol, AST::Types::t?]
-            hash[param.var] = param.type
+            hash[var_name] = param.type
           end
         end
 
@@ -133,10 +134,17 @@ module Steep
           else
             var = arg.children[0]
             type = annotations.var_type(lvar: var)
-
             case arg.type
-            when :arg, :procarg0
+            when :arg
               default_params << Param.new(var: var, type: type, value: nil, node: arg)
+            when :procarg0
+              var = arg.children[0]
+              if var.is_a?(Symbol)
+                default_params << Param.new(var: var, type: type, value: nil, node: arg)
+              else
+                var = var.children[0]
+                default_params << Param.new(var: var, type: type, value: nil, node: arg)
+              end
             when :optarg
               default_params = trailing_params
               optional_params << Param.new(var: var, type: type, value: arg.children.last, node: arg)

data/lib/steep/type_inference/context.rb

@@ -125,7 +125,7 @@ module Steep
         end
 
         def upper_bounds
-          table.each_value.with_object({}) do |type_param, bounds|
+          @upper_bounds ||= table.each_value.with_object({}) do |type_param, bounds|
             if type_param.upper_bound
               bounds[type_param.name] = type_param.upper_bound
             end

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -593,7 +593,7 @@ module Steep
       end
 
       def try_convert(type, method)
-        if shape = subtyping.builder.shape(type, public_only: true, config: config)
+        if shape = subtyping.builder.shape(type, config)
           if entry = shape.methods[method]
             method_type = entry.method_types.find do |method_type|
               method_type.type.params.optional?

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.7.0.dev.1"
+  VERSION = "1.7.0.dev.3"
 end

data/lib/steep.rb

@@ -186,15 +186,19 @@ module Steep
   @ui_logger = nil
   self.log_output = STDERR
 
-  def self.measure(message, level: :warn)
+  def self.measure(message, level: :warn, threshold: 0.0)
     start = Time.now
-    yield
-  ensure
-    time = Time.now - start
-    if level.is_a?(Symbol)
-      level = Logger.const_get(level.to_s.upcase)
+    begin
+      yield
+    ensure
+      time = Time.now - start
+      if level.is_a?(Symbol)
+        level = Logger.const_get(level.to_s.upcase)
+      end
+      if time > threshold
+        self.logger.log(level) { "#{message} took #{time} seconds" }
+      end
     end
-    self.logger.log(level) { "#{message} took #{time} seconds" }
   end
 
   def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")

data/sig/steep/ast/types/helper.rbs

@@ -15,6 +15,8 @@ module Steep
         module NoChild
           def each_child: () { (t) -> void } -> void
                         | () -> Enumerator[t, void]
+
+          def map_type: () { (t) -> t } -> self
         end
       end
     end

data/sig/steep/ast/types/intersection.rbs

@@ -29,6 +29,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> t
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Intersection

data/sig/steep/ast/types/name.rbs

@@ -51,6 +51,7 @@ module Steep
           def map_type: () { (t) -> t } -> self
         end
 
+        # Singleton of a class/module
         class Singleton < Base
           def ==: (untyped other) -> bool
 
@@ -65,13 +66,16 @@ module Steep
           include Helper::NoChild
         end
 
+        # An instance of a class/module
         class Instance < Applying
           def to_module: () -> Singleton
         end
 
+        # An interface type
         class Interface < Applying
         end
 
+        # Type alias
         class Alias < Applying
         end
       end

data/sig/steep/ast/types/record.rbs

@@ -28,6 +28,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> Record
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Record

data/sig/steep/ast/types/tuple.rbs

@@ -26,6 +26,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> Tuple
+
         def level: () -> Array[Integer]
 
         def with_location: (untyped new_location) -> Tuple

data/sig/steep/ast/types/union.rbs

@@ -27,6 +27,8 @@ module Steep
         def each_child: () { (t) -> void } -> void
                       | () -> Enumerator[t, void]
 
+        def map_type: () { (t) -> t } -> t
+
         include Helper::ChildrenLevel
 
         def level: () -> Array[Integer]

data/sig/steep/expectations.rbs

@@ -19,7 +19,7 @@ module Steep
 
       def initialize: (start_position: position, end_position: position, severity: Steep::Diagnostic::LSPFormatter::severity, message: String, code: String) -> void
 
-      def self.from_hash: (untyped) -> instance
+      def self.from_hash: (untyped) -> Diagnostic
 
       def self.from_lsp: (untyped) -> Diagnostic
 

data/sig/steep/interface/block.rbs

@@ -25,9 +25,9 @@ module Steep
 
       def subst: (Substitution s) -> Block
 
-      @fvs: Set[Symbol]
+      @fvs: Set[AST::Types::variable]
 
-      def free_variables: () -> Set[Symbol]
+      def free_variables: () -> Set[AST::Types::variable]
 
       def to_s: () -> ::String
 

data/sig/steep/interface/builder.rbs

@@ -6,161 +6,147 @@ module Steep
       class Config
         # Type of `self` type included immediately in the type expression
         #
-        attr_reader self_type: AST::Types::t
+        attr_reader self_type: AST::Types::t?
 
         # Type of `class` type included immediately in the type expression
         #
-        attr_reader class_type: AST::Types::t | nil
+        attr_reader class_type: AST::Types::t?
 
         # Type of `instance` type included immediately in the type expression
         #
-        attr_reader instance_type: AST::Types::t | nil
+        attr_reader instance_type: AST::Types::t?
 
-        # Resolves `self` types included in shape members
-        #
-        # * `false` only when the type expression is `self`
-        #
-        attr_reader resolve_self: bool
+        # Upper bounds of type variables
+        attr_reader variable_bounds: Hash[Symbol, AST::Types::t?]
 
-        # Resolves `class` types included in shape members
-        #
-        # * `false` only when the type expression is `class`
-        #
-        attr_reader resolve_class: bool
+        def initialize: (self_type: AST::Types::t?, variable_bounds: Hash[Symbol, AST::Types::t?]) -> void
+                      | (self_type: AST::Types::t?, class_type: AST::Types::t, instance_type: AST::Types::t, variable_bounds: Hash[Symbol, AST::Types::t?]) -> void
 
-        # Resolves `instance` types included in shape members
-        #
-        # * `false` only when the type expression is `instance`
-        #
-        attr_reader resolve_instance: bool
+        def subst: () -> Substitution?
 
-        attr_reader variable_bounds: Hash[Symbol, AST::Types::t?]
+        def self.empty: () -> Config
 
-        def initialize: (
-          self_type: AST::Types::t,
-          class_type: AST::Types::t | nil,
-          instance_type: AST::Types::t | nil,
-          ?resolve_self: bool,
-          ?resolve_class: bool,
-          ?resolve_instance: bool,
-          variable_bounds: Hash[Symbol, AST::Types::t?]
-        ) -> void
+        def upper_bound: (Symbol) -> AST::Types::t?
 
-        def update: (
-          ?self_type: AST::Types::t,
-          ?class_type: AST::Types::t | nil,
-          ?instance_type: AST::Types::t | nil,
-          ?resolve_self: bool,
-          ?resolve_class: bool,
-          ?resolve_instance: bool,
-          ?variable_bounds: Hash[Symbol, AST::Types::t?]
-        ) -> self
+        private
 
-        @no_resolve: self?
-        def no_resolve: () -> self
+        def validate: () -> self
 
-        def resolve?: () -> bool
+        def validate_fvs: (Symbol name, AST::Types::t?) -> void
+      end
 
-        def ==: (untyped) -> bool
+      attr_reader factory: AST::Types::Factory
 
-        alias eql? ==
+      # # No type application (if generic), no self-instance-module resolution
+      attr_reader object_shape_cache: Hash[TypeName, Shape?]
 
-        def hash: () -> Integer
+      attr_reader union_shape_cache: Hash[AST::Types::Union, Shape?]
 
-        @subst: Substitution
+      attr_reader singleton_shape_cache: Hash[TypeName, Shape?]
 
-        # Substitution for immediate type expressions
-        def subst: () -> Substitution
+      def initialize: (AST::Types::Factory) -> void
 
-        # Returns `self_type`, or `nil` when it is `Types::Self`
-        #
-        def self_type?: () -> AST::Types::t?
+      def fetch_cache: [KEY] (Hash[KEY, Shape?], KEY) { () -> Shape? } -> Shape?
 
-        # Returns `class_type`, or `nil` when it is `Types::Class`
-        #
-        def class_type?: () -> AST::Types::t?
+      # Returns a shape of given type with respect to Config
+      #
+      # * If `self` occurs in the given type, it returns types with `self`
+      # * If `self` doesn't occur in the given type, it returns type withohut `self`, that is resolved to `config.self_type`
+      #
+      def shape: (AST::Types::t, Config) -> Shape?
 
-        # Returns `instanc_type`, or `nil` when it is `Types::Instance`
-        #
-        def instance_type?: () -> AST::Types::t?
-      end
+      # Returns a shape of given type with respect to Config
+      #
+      # The `self` types included in the returned Shape is the `self` type in the top level
+      #
+      # * `raw_shape(<self>)`        -> may return a shape with `self`
+      # * `raw_shape(<Array[self]>)  -> returns a shape that returns `self` from `#first` method
+      #
+      def raw_shape: (AST::Types::t, Config) -> Shape?
 
-      attr_reader factory: AST::Types::Factory
+      def self_shape: (AST::Types::t, Config) -> Shape?
 
-      type cache_key = [
-        AST::Types::t,                 # type
-        bool,                          # public_only
-        AST::Types::t | nil,           # self_type
-        AST::Types::t | nil,           # class_type
-        AST::Types::t | nil,           # instance_type
-        bool, bool, bool,              # resolve_self, resolve_class, resolve_instance
-        Hash[Symbol, AST::Types::t?]?  # variable_bounds
-      ]
-      attr_reader cache: Hash[cache_key, Shape?]
+      private
 
-      # No type application (if generic), no self-instance-module resolution
-      attr_reader raw_instance_object_shape_cache: Hash[[TypeName, bool], Shape]
+      def object_shape: (RBS::TypeName) -> Shape
 
-      attr_reader raw_singleton_object_shape_cache: Hash[[TypeName, bool], Shape]
+      def singleton_shape: (RBS::TypeName) -> Shape
 
-      attr_reader raw_interface_object_shape_cache: Hash[[TypeName, bool], Shape]
+      def union_shape: (AST::Types::t, Array[Shape]) -> Shape?
 
-      def initialize: (AST::Types::Factory) -> void
+      def intersection_shape: (AST::Types::t, Array[Shape]) -> Shape?
 
-      # Calculates the shape of given class, based on `public_only` and Config
-      #
-      # Returns `nil` if a type that cannot calculate Shape is given.
-      #
-      # * `public_only`: If false, returns a shape with private methods.
+      def proc_shape: (AST::Types::Proc, Shape) -> Shape
+
+      def tuple_shape: (AST::Types::Tuple) { (AST::Types::Name::Instance) -> Shape? } -> Shape?
+
+      def record_shape: (AST::Types::Record) { (AST::Types::Name::Instance) -> Shape? } -> Shape?
+
+      # Substitution for `self`/`instance`/`class` types, built from the name of given type
       #
-      def shape: (AST::Types::t, public_only: bool, config: Config) -> Shape?
+      def class_subst: (AST::Types::Name::Instance | AST::Types::Name::Singleton) -> Substitution
 
-      private
+      def interface_subst: (AST::Types::Name::Interface) -> Substitution
+
+      # Substitution for type application of class instance, type alias, or interface types
+      def app_subst: (AST::Types::Name::Instance | AST::Types::Name::Alias | AST::Types::Name::Interface) -> Substitution
+
+      def method_name_for: (RBS::Definition::Method::TypeDef, Symbol name) -> method_name
+
+      def replace_primitive_method: (method_name, RBS::Definition::Method::TypeDef, MethodType) -> MethodType
+
+      # # Calculates the shape of given class, based on `public_only` and Config
+      # #
+      # # Returns `nil` if a type that cannot calculate Shape is given.
+      # #
+      # # * `public_only`: If false, returns a shape with private methods.
+      # #
+      # def shape: (AST::Types::t, public_only: bool, config: Config) -> Shape?
+
+      # private
 
       @subtyping: Subtyping::Check?
 
       def subtyping: () -> Subtyping::Check
 
-      # Fetch and update cache
-      #
-      # Cache if given type is cacheable:
-      #
-      # * `self`, `instance`, `class` is not cacheable
-      # * Type variables are not cacheable
-      #
-      def fetch_cache: (AST::Types::t, bool public_only, Config) { () -> Shape? } -> Shape?
+      # # Fetch and update cache
+      # #
+      # # Cache if given type is cacheable:
+      # #
+      # # * `self`, `instance`, `class` is not cacheable
+      # # * Type variables are not cacheable
+      # #
+      # def fetch_cache: (AST::Types::t, bool public_only, Config) { () -> Shape? } -> Shape?
 
-      def include_self?: (AST::Types::t) -> bool
+      # def include_self?: (AST::Types::t) -> bool
 
-      def definition_builder: () -> RBS::DefinitionBuilder
+      # def definition_builder: () -> RBS::DefinitionBuilder
 
-      def object_shape: (
-        AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
-        bool public_only,
-        boolish keep_self,
-        boolish keep_instance,
-        boolish keep_singleton
-      ) -> Shape
+      # def object_shape: (
+      #   AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
+      #   bool public_only,
+      #   boolish keep_self,
+      #   boolish keep_instance,
+      #   boolish keep_singleton
+      # ) -> Shape
 
-      def raw_object_shape: (
-        AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
-        bool public_only,
-        Substitution subst
-      ) -> Shape
+      # def raw_object_shape: (
+      #   AST::Types::Name::Instance | AST::Types::Name::Singleton | AST::Types::Name::Interface,
+      #   bool public_only,
+      #   Substitution subst
+      # ) -> Shape
 
-      def union_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+      # def union_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
 
-      def intersection_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
+      # def intersection_shape: (AST::Types::t, Array[Shape], bool public_only) -> Shape
 
-      def tuple_shape: (AST::Types::Tuple, bool public_only, Config) -> Shape
+      # def tuple_shape: (AST::Types::Tuple, bool public_only, Config) -> Shape
 
-      def record_shape: (AST::Types::Record, bool public_only, Config) -> Shape?
+      # def record_shape: (AST::Types::Record, bool public_only, Config) -> Shape?
 
-      def proc_shape: (AST::Types::Proc, bool public_only, Config) -> Shape?
+      # def proc_shape: (AST::Types::Proc, bool public_only, Config) -> Shape?
 
-      def replace_primitive_method: (method_name, RBS::Definition::Method::TypeDef, MethodType) -> MethodType
 
-      def method_name_for: (RBS::Definition::Method::TypeDef, Symbol name) -> method_name
     end
   end
 end