steep 1.4.0.dev.1 → 1.4.0.dev.3

data/sig/steep/type_inference/context.rbs

@@ -1,31 +1,45 @@
+use Steep::Interface::Function::Params, Steep::Interface::Block
+
 module Steep
   module TypeInference
+    # Type checking context
     class Context
+      # Information about the method which the body is being type checked
+      #
       class MethodContext
+        # Name of the method
         attr_reader name: Symbol?
 
+        # `nil` when RBS doesn't have the corresponding method definition
         attr_reader method: RBS::Definition::Method?
 
+        # `nil` when no method type is given
         attr_reader method_type: Interface::MethodType?
 
+        # Falls back to `untyped`
         attr_reader return_type: AST::Types::t
 
-        attr_reader constructor: bool
-
+        # The *super* method if identified
         attr_reader super_method: RBS::Definition::Method?
 
+        # The type of forwarding params when `...` is given
+        attr_reader forward_arg_type: [Params, Block?]?
+
         def initialize: (
           name: Symbol,
           method: RBS::Definition::Method?,
           method_type: Interface::MethodType?,
           return_type: AST::Types::t,
-          constructor: bool,
-          super_method: RBS::Definition::Method?
+          super_method: RBS::Definition::Method?,
+          forward_arg_type: [Params, Block?]?
         ) -> void
 
+        # Type of the block of the current method type
         def block_type: () -> Interface::Block?
       end
 
+      # Information about the block which the body is being type checked
+      #
       class BlockContext
         # The type of block itself
         #
@@ -38,6 +52,7 @@ module Steep
         def subst: (Interface::Substitution) -> BlockContext
       end
 
+      # Context about the `break` syntax
       class BreakContext
         # Type of arguments to `break` statement
         #
@@ -54,23 +69,40 @@ module Steep
         def subst: (Interface::Substitution) -> BreakContext
       end
 
+      # Information about the module which the body is being type checked
+      #
       class ModuleContext
+        # The type of an instance of current module
         attr_reader instance_type: AST::Types::t
 
+        # The type of singleton of current module
         attr_reader module_type: AST::Types::t
 
-        attr_reader defined_instance_methods: untyped
+        # The set of name of instance methods that is defined in the `module`/`class` statement
+        attr_reader defined_instance_methods: Set[Symbol]
 
-        attr_reader defined_module_methods: untyped
+        # The set of name of singleton methods that is defined in the `module`/`class` statement
+        attr_reader defined_module_methods: Set[Symbol]
 
+        # The nesting of current module
+        #
+        # Cannot be `nil`.
+        #
         attr_reader nesting: RBS::Resolver::context
 
-        attr_reader implement_name: untyped
+        # The name that is given to `@implements` annotation
+        #
+        # `nil` when no `@implements` annotation is given.
+        #
+        attr_reader implement_name: AST::Annotation::Implements::Module?
 
+        # The name of the class/module.
         attr_reader class_name: RBS::TypeName
 
+        # The definition of the instance of the module
         attr_reader instance_definition: RBS::Definition?
 
+        # The definition of the singleton of the module
         attr_reader module_definition: RBS::Definition?
 
         @class_variables: Hash[Symbol, RBS::Types::t]?
@@ -78,19 +110,20 @@ module Steep
         def initialize: (
           instance_type: AST::Types::t,
           module_type: AST::Types::t,
-          implement_name: untyped,
+          implement_name: AST::Annotation::Implements::Module?,
           class_name: RBS::TypeName,
           nesting: RBS::Resolver::context,
           ?instance_definition: RBS::Definition?,
           ?module_definition: RBS::Definition?
         ) -> void
 
-        def class_variables: () -> Hash[Symbol, RBS::Types::t]?
+        # Returns a hash from the name of a class variable to its type
+        %a{pure} def class_variables: () -> Hash[Symbol, RBS::Types::t]?
 
         def update: (
           ?instance_type: AST::Types::t,
           ?module_type: AST::Types::t,
-          ?implement_name: untyped,
+          ?implement_name: AST::Annotation::Implements::Module?,
           ?class_name: RBS::TypeName,
           ?instance_definition: RBS::Definition?,
           ?module_definition: RBS::Definition?,
@@ -98,6 +131,8 @@ module Steep
         ) -> ModuleContext
       end
 
+      # Information about the free type variables
+      #
       class TypeVariableContext
         attr_reader table: Hash[Symbol, Interface::TypeParam]
 
@@ -105,6 +140,7 @@ module Steep
 
         def initialize: (Array[Interface::TypeParam] type_params, ?parent_context: TypeVariableContext?) -> void
 
+        # Returns the upper bound of a type variable
         def []: (Symbol name) -> AST::Types::t?
 
         def upper_bounds: () -> Hash[Symbol, AST::Types::t]
@@ -112,9 +148,14 @@ module Steep
         def self.empty: () -> TypeVariableContext
       end
 
-      attr_reader call_context: untyped
+      # The caller where a method is called from
+      attr_reader call_context: MethodCall::context
 
-      attr_reader method_context: untyped
+      # MethodContext for current execution point
+      #
+      # `nil` when not in any method definition.
+      #
+      attr_reader method_context: MethodContext?
 
       # BlockContext for current execution point
       #
@@ -122,10 +163,17 @@ module Steep
       #
       attr_reader block_context: BlockContext?
 
+      # BreakContext for current execution point
+      #
+      # `nil` if `break` is not allowed.
+      #
       attr_reader break_context: BreakContext?
 
-      attr_reader module_context: ModuleContext?
+      # ModuleContext for current execution point
+      attr_reader module_context: ModuleContext
 
+      # The type of `self`
+      #
       attr_reader self_type: AST::Types::t
 
       attr_reader type_env: TypeEnv
@@ -133,25 +181,25 @@ module Steep
       attr_reader variable_context: TypeVariableContext
 
       def initialize: (
-        method_context: untyped,
+        method_context: MethodContext?,
         block_context: BlockContext?,
         break_context: BreakContext?,
-        module_context: ModuleContext?,
-        self_type: untyped,
+        module_context: ModuleContext,
+        self_type: AST::Types::t,
         type_env: TypeEnv,
-        call_context: untyped,
+        call_context: MethodCall::context,
         variable_context: TypeVariableContext
       ) -> void
 
       def with: (
-        ?method_context: untyped,
+        ?method_context: MethodContext?,
         ?block_context: BlockContext?,
         ?break_context: BreakContext?,
-        ?module_context: ModuleContext?,
-        ?self_type: untyped,
+        ?module_context: ModuleContext,
+        ?self_type: AST::Types::t,
         ?type_env: TypeEnv,
-        ?call_context: untyped,
-        ?variable_context: untyped
+        ?call_context: MethodCall::context,
+        ?variable_context: TypeVariableContext
       ) -> Context
 
       def factory: () -> AST::Types::Factory

data/sig/steep/type_inference/method_params.rbs

@@ -1,24 +1,31 @@
+use Parser::AST::Node, Steep::Interface::MethodType
+use Steep::Interface::Function::Params, Steep::Interface::Block
+
 module Steep
   module TypeInference
+    # A MethodParams object provides the information of parameters from MethodType and nodes
+    #
+    # It primarly provides a mapping from a local variable (method parameter) to its type.
+    #
     class MethodParams
       class BaseParameter
         attr_reader name: Symbol
 
-        attr_reader type: untyped
+        attr_reader type: AST::Types::t?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
-        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
 
         def optional?: () -> bool
 
-        def value: () -> Parser::AST::Node
+        def value: () -> Node?
 
         def var_type: () -> AST::Types::t
 
         def untyped?: () -> bool
 
-        def ==: (untyped other) -> untyped
+        def ==: (untyped other) -> bool
 
         alias eql? ==
 
@@ -34,27 +41,25 @@ module Steep
       class BaseRestParameter
         attr_reader name: Symbol
 
-        attr_reader type: untyped
+        attr_reader type: AST::Types::t?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
-        def initialize: (name: Symbol, type: untyped, node: Parser::AST::Node) -> void
+        def initialize: (name: Symbol, type: AST::Types::t?, node: Node) -> void
 
         def ==: (untyped other) -> bool
 
         alias eql? ==
 
         def hash: () -> Integer
-
-        def var_type: () -> AST::Types::t
       end
 
       class PositionalRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::t
+        def var_type: () -> AST::Types::Name::Instance
       end
 
       class KeywordRestParameter < BaseRestParameter
-        def var_type: () -> AST::Types::t
+        def var_type: () -> AST::Types::Name::Instance
       end
 
       class BlockParameter
@@ -62,11 +67,11 @@ module Steep
 
         attr_reader type: Interface::Function?
 
-        attr_reader node: Parser::AST::Node
+        attr_reader node: Node
 
         attr_reader self_type: AST::Types::t?
 
-        def initialize: (name: Symbol, type: Interface::Function?, node: Parser::AST::Node, optional: boolish, self_type: AST::Types::t?) -> void
+        def initialize: (name: Symbol, type: Interface::Function?, node: Node, optional: boolish, self_type: AST::Types::t?) -> void
 
         @optional: boolish
 
@@ -81,28 +86,42 @@ module Steep
         def hash: () -> Integer
       end
 
-      attr_reader args: untyped
+      type param = PositionalParameter | KeywordParameter | PositionalRestParameter | KeywordRestParameter | BlockParameter
+
+      # The children of `:args` node
+      attr_reader args: Array[Node]
+
+      attr_reader method_type: MethodType?
 
-      attr_reader method_type: untyped
+      # Mapping from the name of parameter to parameter object
+      attr_reader params: Hash[Symbol, param]
 
-      attr_reader params: untyped
+      attr_reader errors: Array[Diagnostic::Ruby::Base]
 
-      attr_reader errors: untyped
+      # The type of `...`
+      #
+      # `nil` if the node doesn't have it.
+      #
+      attr_reader forward_arg_type: [Params, Block?]?
 
-      def initialize: (args: untyped, method_type: untyped) -> void
+      def initialize: (args: Array[Node], method_type: MethodType?, forward_arg_type: [Params, Block?]?) -> void
 
-      def []: (untyped name) -> untyped
+      def []: (Symbol name) -> param
+
+      def param?: (Symbol) -> bool
 
       def size: () -> Integer
 
-      def each_param: () { (BaseParameter | BaseRestParameter | BlockParameter) -> void } -> void
-                    | () -> Enumerator[BaseParameter | BaseRestParameter | BlockParameter, void]
+      def each_param: () { (param) -> void } -> void
+                    | () -> Enumerator[param, void]
 
       def each: () { (Symbol, AST::Types::t) -> void } -> void
 
-      def self.empty: (node: Parser::AST::Node) -> MethodParams
+      def update: (?forward_arg_type: [Params, Block?]?) -> MethodParams
+
+      def self.empty: (node: Node) -> MethodParams
 
-      def self.build: (node: Parser::AST::Node, method_type: untyped) -> MethodParams
+      def self.build: (node: Node, method_type: MethodType) -> MethodParams
     end
   end
 end

data/sig/steep/type_inference/multiple_assignment.rbs

@@ -59,7 +59,7 @@ module Steep
       # Returns a type hint for multiple assignment right hand side
       #
       # It constructs a structure of tuple types, based on the assignment lhs, and variable types.
-      # 
+      #
       def hint_for_mlhs: (Parser::AST::Node mlhs, TypeEnv env) -> AST::Types::t?
 
       private

data/sig/steep/type_inference/send_args.rbs

@@ -68,7 +68,7 @@ module Steep
 
         def following_args: () -> Array[Parser::AST::Node]
 
-        def param: () -> Interface::Function::Params::PositionalParams::param?
+        %a{pure} def param: () -> Interface::Function::Params::PositionalParams::param?
 
         def update: (?index: Integer, ?positional_params: Interface::Function::Params::PositionalParams?, ?uniform: bool) -> PositionalArgs
 
@@ -198,6 +198,14 @@ module Steep
         def node_type: () -> AST::Types::t
       end
 
+      class ForwardedArgs
+        attr_reader node: Parser::AST::Node
+
+        attr_reader params: Interface::Function::Params
+
+        def initialize: (node: Parser::AST::Node, params: Interface::Function::Params) -> void
+      end
+
       attr_reader node: Parser::AST::Node
 
       attr_reader arguments: Array[Parser::AST::Node]
@@ -216,14 +224,16 @@ module Steep
 
       def kwargs_node: () -> Parser::AST::Node?
 
+      def forwarded_args_node: () -> Parser::AST::Node?
+
       def positional_arg: () -> PositionalArgs
 
       def keyword_args: () -> KeywordArgs
 
       def block_pass_arg: () -> BlockPassArg
 
-      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> Array[Diagnostic::Ruby::Base]
-              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, Array[Diagnostic::Ruby::Base]]
+      def each: () { (PositionalArgs::arg | KeywordArgs::arg) -> void } -> [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]
+              | () -> Enumerator[PositionalArgs::arg | KeywordArgs::arg, [ForwardedArgs?, Array[Diagnostic::Ruby::Base]]]
     end
   end
 end

data/sig/steep/typing.rbs

@@ -34,7 +34,7 @@ module Steep
 
     def add_error: (Diagnostic::Ruby::Base error) -> void
 
-    def add_typing: (Parser::AST::Node node, AST::Types::t `type`, TypeInference::Context _context) -> untyped
+    def add_typing: (Parser::AST::Node node, AST::Types::t `type`, top) -> untyped
 
     def add_call: (untyped node, untyped call) -> untyped
 
@@ -61,8 +61,13 @@ module Steep
     def new_child: [A] (Range[Integer] range) { (Typing) -> A } -> A
                  | (Range[Integer]) -> Typing
 
-    def each_typing: () { () -> untyped } -> untyped
+    def each_typing: () { (Parser::AST::Node, AST::Types::t) -> void } -> void
 
+    # Push the current changes to the `#parent` typing
+    #
+    # * Raises an error if `#parent` is `nil`
+    # * Raises an error if `#parent` is changed since `#new_child` call that instantiated `self`
+    #
     def save!: () -> void
   end
 end

data/smoke/diagnostics/test_expectations.yml

@@ -46,6 +46,7 @@
     message: |-
       Cannot pass a value of type `^(untyped, untyped, untyped) -> untyped` as a block-pass-argument of type `^(::Integer) -> void`
         ^(untyped, untyped, untyped) -> untyped <: ^(::Integer) -> void
+          (Params are incompatible)
     code: Ruby::BlockTypeMismatch
 - file: break_type_mismatch.rb
   diagnostics:

data/smoke/regexp/a.rb

@@ -1,7 +1,7 @@
 new_1 = Regexp.new("a")
 new_1.foo
 
-new_2 = Regexp.new("a", true)
+new_2 = Regexp.new("a", nil)
 new_2.foo
 
 new_3 = Regexp.new("a", Regexp::EXTENDED | Regexp::IGNORECASE)
@@ -13,7 +13,7 @@ new_4.foo
 compile_1 = Regexp.compile("a")
 compile_1.foo
 
-compile_2 = Regexp.compile("a", true)
+compile_2 = Regexp.compile("a", false)
 compile_2.foo
 
 compile_3 = Regexp.compile("a", Regexp::EXTENDED | Regexp::IGNORECASE)

data/steep.gemspec

@@ -42,5 +42,4 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "fileutils", ">= 1.1.0"
   spec.add_runtime_dependency "strscan", ">= 1.0.0"
   spec.add_runtime_dependency "csv", ">= 3.0.9"
-  spec.add_runtime_dependency "pathname", ">= 0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.4.0.dev.1
+  version: 1.4.0.dev.3
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-06 00:00:00.000000000 Z
+date: 2023-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -224,20 +224,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.9
-- !ruby/object:Gem::Dependency
-  name: pathname
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.1
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -268,6 +254,10 @@ files:
 - bin/steep
 - bin/steep-prof
 - exe/steep
+- guides/README.md
+- guides/src/gem-rbs-collection/gem-rbs-collection.md
+- guides/src/getting-started/getting-started.md
+- guides/src/nil-optional/nil-optional.md
 - lib/steep.rb
 - lib/steep/annotation_parser.rb
 - lib/steep/ast/annotation.rb
@@ -356,6 +346,7 @@ files:
 - lib/steep/services/signature_service.rb
 - lib/steep/services/stats_calculator.rb
 - lib/steep/services/type_check_service.rb
+- lib/steep/services/type_name_completion.rb
 - lib/steep/shims/filter_map.rb
 - lib/steep/shims/symbol_start_with.rb
 - lib/steep/signature/validator.rb
@@ -393,8 +384,10 @@ files:
 - sig/shims/parallel.rbs
 - sig/shims/parser.rbs
 - sig/shims/parser/comment.rbs
+- sig/shims/parser/nodes.rbs
 - sig/shims/parser/source/map.rbs
 - sig/shims/parser/source/range.rbs
+- sig/shims/string.rbs
 - sig/shims/tagged_logging.rbs
 - sig/steep.rbs
 - sig/steep/annotation_parser.rbs
@@ -484,6 +477,7 @@ files:
 - sig/steep/services/signature_service.rbs
 - sig/steep/services/stats_calculator.rbs
 - sig/steep/services/type_check_service.rbs
+- sig/steep/services/type_name_completion.rbs
 - sig/steep/signature/validator.rbs
 - sig/steep/source.rbs
 - sig/steep/subtyping/cache.rbs
@@ -782,7 +776,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Gradual Typing for Ruby