steep 1.1.1 → 1.2.0.pre.1

data/lib/steep.rb

@@ -60,7 +60,8 @@ require "steep/interface/function"
 require "steep/interface/block"
 require "steep/interface/method_type"
 require "steep/interface/substitution"
-require "steep/interface/interface"
+require "steep/interface/shape"
+require "steep/interface/builder"
 
 require "steep/subtyping/result"
 require "steep/subtyping/check"
@@ -126,6 +127,7 @@ require "steep/expectations"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/utils/jobs_count"
 require "steep/drivers/check"
+require "steep/drivers/checkfile"
 require "steep/drivers/stats"
 require "steep/drivers/validate"
 require "steep/drivers/annotations"
@@ -145,7 +147,7 @@ $stderr = STDERR
 
 module Steep
   def self.logger
-    @logger
+    @logger || raise
   end
 
   def self.new_logger(output, prev_level)
@@ -245,3 +247,70 @@ module Steep
     result
   end
 end
+
+klasses = [
+  # Steep::Interface::MethodType
+]
+
+klasses.each do |klass|
+  klass.instance_eval do
+    def self.new(*_, **__, &___)
+      super
+    end
+  end
+end
+
+module GCCounter
+  module_function
+
+  def count_objects(title, regexp = /^Steep/, skip: false)
+    if ENV["COUNT_GC_OBJECTS"] && !skip
+      unless GC.disable
+        GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+
+        begin
+          yield
+        ensure
+          Steep.logger.fatal "===== #{title} ==============================="
+
+          klasses = []
+
+          ObjectSpace.each_object(Class) do |klass|
+            if (klass.name || "") =~ regexp
+              klasses << klass
+            end
+          end
+
+          before = {}
+
+          klasses.each do |klass|
+            count = ObjectSpace.each_object(klass).count
+            before[klass] = count
+          end
+
+          GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+
+          gceds = []
+
+          klasses.each do |klass|
+            count = ObjectSpace.each_object(klass).count
+            gced = (before[klass] || 0) - count
+
+            gceds << [klass, gced] if gced > 0
+          end
+
+          gceds.sort_by! {|_, count| -count }
+          gceds.each do |klass, count|
+            Steep.logger.fatal { "#{klass.name} => #{count}"}
+          end
+
+          GC.enable
+        end
+      else
+        yield
+      end
+    else
+      yield
+    end
+  end
+end

data/rbs_collection.steep.lock.yaml

@@ -10,16 +10,12 @@ gems:
   version: '0'
   source:
     type: stdlib
-- name: rbs
-  version: 2.5.1
-  source:
-    type: rubygems
 - name: activesupport
   version: '6.0'
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: ast
@@ -27,7 +23,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: i18n
@@ -35,7 +31,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: listen
@@ -43,15 +39,19 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
+- name: minitest
+  version: '0'
+  source:
+    type: stdlib
 - name: parallel
   version: '1.20'
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rainbow
@@ -59,50 +59,38 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 933f7176968d8620224c0b22baefadbd7d77ef27
+    revision: dc7059ea0cdf67f486ca9cea2b01d53f04724652
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
-- name: logger
-  version: '0'
-  source:
-    type: stdlib
-- name: pathname
+- name: securerandom
   version: '0'
   source:
     type: stdlib
-- name: json
-  version: '0'
-  source:
-    type: stdlib
-- name: optparse
-  version: '0'
-  source:
-    type: stdlib
-- name: rubygems
+- name: monitor
   version: '0'
   source:
     type: stdlib
-- name: tsort
+- name: date
   version: '0'
   source:
     type: stdlib
-- name: monitor
+- name: singleton
   version: '0'
   source:
     type: stdlib
-- name: date
+- name: logger
   version: '0'
   source:
     type: stdlib
-- name: singleton
+- name: mutex_m
   version: '0'
   source:
     type: stdlib
-- name: mutex_m
+- name: time
   version: '0'
   source:
     type: stdlib
-- name: time
+- name: pathname
   version: '0'
   source:
     type: stdlib

data/rbs_collection.steep.yaml

@@ -15,5 +15,6 @@ gems:
     ignore: true
   - name: set
   - name: rbs
+    ignore: true
   - name: with_steep_types
     ignore: true

data/sig/shims/language-server_protocol.rbs

@@ -0,0 +1,20 @@
+module LanguageServer
+  module Protocol
+    module Transport
+      module Io
+        class Writer
+          def initialize: (IO) -> void
+
+          def write: (**untyped) -> void
+                   | (Hash[Symbol, untyped]) -> void
+        end
+
+        class Reader
+          def initialize: (IO) -> void
+
+          def read: () { (untyped) -> void } -> bot
+        end
+      end
+    end
+  end
+end

data/sig/shims/tagged_logging.rbs

@@ -0,0 +1,6 @@
+module ActiveSupport::TaggedLogging
+  def tagged: [A] (*String) { () -> A } -> A
+            | ...
+
+  def formatter: () -> Formatter
+end

data/sig/steep/ast/annotation/collection.rbs

@@ -40,17 +40,17 @@ module Steep
 
         def method_type: (untyped name) -> (untyped | nil)
 
-        def block_type: () -> untyped
+        %a{pure} def block_type: () -> Types::t?
 
-        def return_type: () -> untyped
+        %a{pure} def return_type: () -> Types::t?
 
-        def self_type: () -> untyped
+        %a{pure} def self_type: () -> Types::t?
 
-        def instance_type: () -> untyped
+        %a{pure} def instance_type: () -> Types::t?
 
-        def module_type: () -> untyped
+        %a{pure} def module_type: () -> Types::t?
 
-        def break_type: () -> untyped
+        %a{pure} def break_type: () -> Types::t?
 
         def lvar_types: () -> untyped
 

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

@@ -23,6 +23,9 @@ module Steep
         def level: () -> ::Array[0]
 
         def with_location: (untyped new_location) -> untyped
+
+        self.@instance: Class
+        def self.instance: () -> Class
       end
     end
   end

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

@@ -2,74 +2,80 @@ module Steep
   module AST
     module Types
       class Factory
-        attr_reader definition_builder: RBS::DefinitionBuilder
+        @env: RBS::Environment
+
+        @type_name_resolver: RBS::Resolver::TypeNameResolver
 
-        attr_reader type_name_cache: untyped
+        attr_reader definition_builder: RBS::DefinitionBuilder
 
-        attr_reader type_cache: untyped
+        attr_reader type_cache: Hash[RBS::Types::t, t]
 
         attr_reader type_interface_cache: untyped
 
+        @type_name_resolver: RBS::Resolver::TypeNameResolver?
+
         def inspect: () -> String
 
         def initialize: (builder: RBS::DefinitionBuilder) -> void
 
-        def type_name_resolver: () -> untyped
+        def type_name_resolver: () -> RBS::Resolver::TypeNameResolver
 
-        def type_opt: (untyped `type`) -> (untyped | nil)
+        def type: (RBS::Types::t `type`) -> t
 
-        def type: (RBS::Types::t `type`) -> AST::Types::t
+        def type_opt: (RBS::Types::t? `type`) -> t?
 
-        def type_1: (AST::Types::t `type`) -> RBS::Types::t
+        def type_1: (t `type`) -> RBS::Types::t
 
-        def function_1: (untyped func) -> untyped
+        def type_1_opt: (t?) -> RBS::Types::t?
 
-        def params: (untyped `type`) -> untyped
+        def function_1: (Interface::Function func) -> RBS::Types::Function
 
-        def type_param: (untyped type_param) -> untyped
+        def params: (RBS::Types::Function `type`) -> Interface::Function::Params
 
-        def type_param_1: (untyped type_param) -> untyped
+        def type_param: (RBS::AST::TypeParam type_param) -> Interface::TypeParam
 
-        def method_type: (RBS::MethodType method_type, self_type: AST::Types::t, method_decls: untyped, ?subst2: Interface::Substitution?) -> Interface::MethodType
-                       | [A] (RBS::MethodType method_type, self_type: AST::Types::t, method_decls: untyped, ?subst2: Interface::Substitution?) { (Interface::MethodType) -> A } -> A
+        def type_param_1: (Interface::TypeParam type_param) -> RBS::AST::TypeParam
 
-        def method_type_1: (untyped method_type, self_type: untyped) { (untyped) -> untyped } -> untyped
+        @method_type_cache: Hash[RBS::MethodType, Interface::MethodType]
 
-        class InterfaceCalculationError < StandardError
-          attr_reader type: untyped
+        def method_type: (RBS::MethodType method_type, method_decls: Set[TypeInference::MethodCall::MethodDecl]) -> Interface::MethodType
 
-          def initialize: (type: untyped, message: untyped) -> void
-        end
+        def method_type_1: (Interface::MethodType method_type) -> RBS::MethodType
 
         def unfold: (RBS::TypeName type_name, Array[t] args) -> t
 
+        # Unfold type alias one step, or returns itself
+        #
         def expand_alias: (t `type`) -> t
-                        | [A] (t) { (t) -> A } -> A
 
-        def deep_expand_alias: (t `type`, ?recursive: Set[t]) -> t
-                             | [A] (t `type`, ?recursive: Set[t]) { (t) -> A }-> A
+        # Unfold type alias until non alias type
+        #
+        # * Unions and intersections are expanded
+        # * Returns `nil` if it is recursive
+        #
+        def deep_expand_alias: (t `type`, ?recursive: Set[RBS::TypeName]) -> t?
 
-        def flatten_union: (untyped `type`, ?untyped acc) -> untyped
+        # Convert union types to array of types
+        #
+        def flatten_union: (t `type`, ?Array[t] acc) -> Array[t]
 
         def unwrap_optional: (Types::t `type`) -> [Types::t, Types::t]
 
-        NilClassName: untyped
-
-        def setup_primitives: (untyped method_name, untyped method_def, untyped method_type) -> untyped
+        def module_name?: (RBS::TypeName type_name) -> bool
 
-        def interface: (untyped `type`, private: untyped, ?self_type: untyped) -> untyped
-
-        def module_name?: (untyped type_name) -> untyped
-
-        def class_name?: (untyped type_name) -> untyped
+        def class_name?: (RBS::TypeName type_name) -> bool
 
         def env: () -> RBS::Environment
 
-        def absolute_type: (untyped `type`, context: untyped) -> untyped
+        def absolute_type: (t `type`, context: RBS::Resolver::context) -> t
 
-        def absolute_type_name: (untyped type_name, context: untyped) -> untyped
+        def absolute_type_name: (RBS::TypeName type_name, context: RBS::Resolver::context) -> RBS::TypeName?
 
         def instance_type: (RBS::TypeName type_name, ?args: Array[t]?, ?location: untyped?) -> t
+
+        def try_singleton_type: (t) -> t?
+
+        def try_instance_type: (t) -> t?
       end
     end
   end

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

@@ -23,6 +23,9 @@ module Steep
         def level: () -> ::Array[0]
 
         def with_location: (untyped new_location) -> untyped
+
+        self.@instance: Instance
+        def self.instance: () -> Instance
       end
     end
   end

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

@@ -8,7 +8,7 @@ module Steep
 
         def initialize: (types: untyped, ?location: untyped?) -> void
 
-        def self.build: (types: untyped, ?location: untyped?) -> untyped
+        def self.build: (types: Array[t], ?location: untyped?) -> t
 
         def ==: (untyped other) -> untyped
 

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

@@ -8,25 +8,25 @@ module Steep
 
         def initialize: (value: untyped, ?location: untyped?) -> void
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
-        def hash: () -> untyped
+        def hash: () -> Integer
 
         alias eql? ==
 
-        def subst: (untyped s) -> self
+        def subst: (Interface::Substitution s) -> self
 
-        def to_s: () -> untyped
+        def to_s: () -> String
 
         include Helper::NoFreeVariables
 
         include Helper::NoChild
 
-        def level: () -> ::Array[0]
+        def level: () -> Array[Integer]
 
-        def with_location: (untyped new_location) -> untyped
+        def with_location: (untyped new_location) -> self
 
-        def back_type: () -> untyped
+        def back_type: () -> AST::Types::Name::Instance
       end
     end
   end

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

@@ -5,37 +5,38 @@ module Steep
         class Base
           attr_reader location: untyped
 
-          attr_reader name: untyped
+          attr_reader name: RBS::TypeName
 
-          def initialize: (name: untyped, ?location: untyped?) -> void
+          def initialize: (name: RBS::TypeName, ?location: untyped?) -> void
 
           include Helper::NoFreeVariables
 
-          def subst: (untyped s) -> self
+          def subst: (Steep::Interface::Substitution s) -> self
 
           def level: () -> ::Array[0]
         end
 
         class Applying < Base
-          attr_reader args: untyped
+          attr_reader args: Array[t]
 
-          def initialize: (name: untyped, args: untyped, ?location: untyped?) -> void
+          def initialize: (name: RBS::TypeName, args: Array[t], ?location: untyped?) -> void
 
-          def ==: (untyped other) -> untyped
+          def ==: (untyped other) -> bool
 
           alias eql? ==
 
-          def hash: () -> untyped
+          def hash: () -> Integer
 
           def to_s: () -> ::String
 
           def with_location: (untyped new_location) -> untyped
 
-          def subst: (untyped s) -> (untyped | self)
+          def subst: (Steep::Interface::Substitution s) -> self
 
-          def free_variables: () -> untyped
+          def free_variables: () -> Set[Symbol]
 
-          def each_child: () ?{ () -> untyped } -> untyped
+          def each_child: () { (t) -> void } -> void
+                        | () -> Enumerator[t, void]
 
           include Helper::ChildrenLevel
 
@@ -43,11 +44,11 @@ module Steep
         end
 
         class Singleton < Base
-          def ==: (untyped other) -> untyped
+          def ==: (untyped other) -> bool
 
           alias eql? ==
 
-          def hash: () -> untyped
+          def hash: () -> Integer
 
           def to_s: () -> ::String
 
@@ -57,7 +58,7 @@ module Steep
         end
 
         class Instance < Applying
-          def to_module: () -> untyped
+          def to_module: () -> Singleton
         end
 
         class Interface < Applying

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

@@ -6,9 +6,11 @@ module Steep
 
         attr_reader type: Interface::Function
 
+        attr_reader self_type: AST::Types::t?
+
         attr_reader block: Interface::Block?
 
-        def initialize: (type: Interface::Function, block: Interface::Block?, ?location: untyped) -> void
+        def initialize: (type: Interface::Function, self_type: AST::Types::t?, block: Interface::Block?, ?location: untyped) -> void
 
         def ==: (untyped other) -> bool
 

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

@@ -23,6 +23,9 @@ module Steep
         def level: () -> ::Array[0]
 
         def with_location: (untyped new_location) -> untyped
+
+        self.@instance: Self
+        def self.instance: () -> Self
       end
     end
   end

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

@@ -16,7 +16,7 @@ module Steep
 
         def self.fresh_name: (untyped name) -> untyped
 
-        def self.fresh: (untyped name, ?location: untyped?) -> untyped
+        def self.fresh: (Symbol name, ?location: untyped?) -> Var
 
         def to_s: () -> untyped
 

data/sig/steep/diagnostic/ruby.rbs

@@ -44,53 +44,51 @@ module Steep
       end
 
       class UnexpectedPositionalArgument < Base
-        attr_reader node: untyped
-
-        attr_reader method_type: untyped
+        # Node of argument
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader method_name: untyped
+        attr_reader params: Interface::Function::Params
 
-        def initialize: (node: untyped, method_name: untyped, method_type: untyped) -> void
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
 
-        def header_line: () -> "Unexpected positional argument"
+        def header_line: () -> String
       end
 
       class InsufficientPositionalArguments < Base
-        attr_reader node: untyped
-
-        attr_reader method_name: untyped
+        # Send/csend node for method calls without blocks
+        # block/numblock node for method calls with blocks
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader method_type: untyped
+        attr_reader params: Interface::Function::Params
 
-        def initialize: (node: untyped, method_name: untyped, method_type: untyped) -> void
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
 
-        def header_line: () -> "More positional arguments are required"
+        def header_line: () -> String
       end
 
       class UnexpectedKeywordArgument < Base
-        attr_reader node: untyped
+        # pair/kwsplat node
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader method_name: untyped
-
-        attr_reader method_type: untyped
+        attr_reader params: Interface::Function::Params
 
-        def initialize: (node: untyped, method_name: untyped, method_type: untyped) -> void
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
 
-        def header_line: () -> "Unexpected keyword argument"
+        def header_line: () -> String
       end
 
       class InsufficientKeywordArguments < Base
-        attr_reader node: untyped
+        # Send/csend node for method calls without blocks
+        # block/numblock node for method calls with blocks
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader method_name: untyped
+        attr_reader params: Interface::Function::Params
 
-        attr_reader method_type: untyped
+        attr_reader missing_keywords: Array[Symbol]
 
-        attr_reader missing_keywords: untyped
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params, missing_keywords: Array[Symbol]) -> void
 
-        def initialize: (node: untyped, method_name: untyped, method_type: untyped, missing_keywords: untyped) -> void
-
-        def header_line: () -> ::String
+        def header_line: () -> String
       end
 
       class UnresolvedOverloading < Base
@@ -110,19 +108,17 @@ module Steep
       end
 
       class ArgumentTypeMismatch < Base
-        attr_reader node: untyped
-
-        attr_reader expected: untyped
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader actual: untyped
+        attr_reader expected: AST::Types::t
 
-        attr_reader receiver_type: untyped
+        attr_reader actual: AST::Types::t
 
-        attr_reader result: untyped
+        attr_reader result: Subtyping::Result::t
 
         include ResultPrinter
 
-        def initialize: (node: untyped, receiver_type: untyped, expected: untyped, actual: untyped, result: untyped) -> void
+        def initialize: (node: Parser::AST::Node, expected: AST::Types::t, actual: AST::Types::t, result: Subtyping::Result::t) -> void
 
         def header_line: () -> ::String
       end
@@ -302,9 +298,9 @@ module Steep
       end
 
       class UnexpectedSuper < Base
-        attr_reader method: untyped
+        attr_reader method: Symbol?
 
-        def initialize: (node: untyped, method: untyped) -> void
+        def initialize: (node: Parser::AST::Node, method: Symbol?) -> void
 
         def header_line: () -> ::String
       end