steep 1.2.1 → 1.3.0.pre.2

data/sig/steep/services/signature_service.rbs

@@ -16,9 +16,13 @@ module Steep
 
         @rbs_index: Index::RBSIndex?
 
+        @constant_resolver: RBS::Resolver::ConstantResolver?
+
         def initialize: (files: Hash[Pathname, FileStatus], changed_paths: Set[Pathname], diagnostics: Array[Diagnostic::Signature::Base], last_builder: RBS::DefinitionBuilder) -> void
 
         def rbs_index: () -> Index::RBSIndex
+
+        def constant_resolver: () -> RBS::Resolver::ConstantResolver
       end
 
       class AncestorErrorStatus
@@ -32,9 +36,13 @@ module Steep
 
         @rbs_index: Index::RBSIndex?
 
+        @constant_resolver: RBS::Resolver::ConstantResolver?
+
         def initialize: (files: Hash[Pathname, FileStatus], changed_paths: Set[Pathname], diagnostics: Array[Diagnostic::Signature::Base], last_builder: RBS::DefinitionBuilder) -> void
 
         def rbs_index: () -> Index::RBSIndex
+
+        def constant_resolver: () -> RBS::Resolver::ConstantResolver
       end
 
       class LoadedStatus
@@ -46,11 +54,15 @@ module Steep
 
         @subtyping: Subtyping::Check?
 
+        @constant_resolver: RBS::Resolver::ConstantResolver?
+
         def initialize: (files: Hash[Pathname, FileStatus], builder: RBS::DefinitionBuilder) -> void
 
         def subtyping: () -> Subtyping::Check
 
         def rbs_index: () -> Index::RBSIndex
+
+        def constant_resolver: () -> RBS::Resolver::ConstantResolver
       end
 
       class FileStatus
@@ -88,6 +100,8 @@ module Steep
 
       def latest_rbs_index: () -> Index::RBSIndex
 
+      def latest_constant_resolver: () -> RBS::Resolver::ConstantResolver
+
       def current_subtyping: () -> Subtyping::Check?
 
       def apply_changes: (Hash[Pathname, FileStatus] files, Server::ChangeBuffer::changes changes) -> Hash[Pathname, FileStatus]

data/sig/steep/services/type_check_service.rbs

@@ -91,9 +91,9 @@ module Steep
 
       def update_sources: (changes: Server::ChangeBuffer::changes, requests: Hash[Project::Target, TargetRequest]) -> void
 
-      def type_check_file: (target: Project::Target, subtyping: Subtyping::Check, path: Pathname, text: String) -> SourceFile
+      def type_check_file: (target: Project::Target, subtyping: Subtyping::Check, path: Pathname, text: String) { () -> RBS::Resolver::ConstantResolver } -> SourceFile
 
-      def self.type_check: (source: Source, subtyping: Subtyping::Check) -> Typing
+      def self.type_check: (source: Source, subtyping: Subtyping::Check, constant_resolver: RBS::Resolver::ConstantResolver) -> Typing
 
       def source_file?: (Pathname path) -> Project::Target?
 

data/sig/steep/signature/validator.rbs

@@ -0,0 +1,76 @@
+module Steep
+  module Signature
+    class Validator
+      Location: singleton(RBS::Location)
+
+      Declarations: singleton(RBS::AST::Declarations)
+
+      attr_reader checker: Subtyping::Check
+
+      @errors: Array[Diagnostic::Signature::Base]
+
+      @type_name_resolver: RBS::TypeNameResolver?
+
+      @validator: RBS::Validator?
+
+      def initialize: (checker: Subtyping::Check) -> void
+
+      def has_error?: () -> bool
+
+      def no_error?: () -> bool
+
+      def each_error: () { (Diagnostic::Signature::Base) -> void } -> void
+                    | () -> Enumerator[Diagnostic::Signature::Base, void]
+
+      def env: () -> RBS::Environment
+
+      def builder: () -> RBS::DefinitionBuilder
+
+      def type_name_resolver: () -> RBS::TypeNameResolver
+
+      def validator: () -> RBS::Validator
+
+      def factory: () -> AST::Types::Factory
+
+      def validate: () -> void
+
+      def validate_type_application_constraints: (RBS::TypeName type_name, Array[RBS::AST::TypeParam] type_params, Array[RBS::Types::t] type_args, location: RBS::Location[untyped, untyped]?) -> void
+
+      def validate_type_application: (RBS::Types::t) -> void
+
+      def validate_type: (RBS::Types::t `type`) -> untyped
+
+      def ancestor_to_type: (RBS::Definition::Ancestor::t ancestor) -> (AST::Types::Name::Interface | AST::Types::Name::Instance)
+
+      def mixin_constraints: (RBS::Definition definition, Array[RBS::Definition::Ancestor::Instance] mixin_ancestors, immediate_self_types: Array[RBS::Definition::Ancestor::t]?) -> Array[[Subtyping::Relation[AST::Types::t], RBS::Definition::Ancestor::Instance]]
+
+      def each_method_type: (RBS::Definition) { (RBS::MethodType) -> void } -> void
+
+      def each_variable_type: (RBS::Definition) { (RBS::Types::t) -> void } -> void
+
+      def validate_definition_type: (RBS::Definition) -> void
+
+      def validate_one_class: (RBS::TypeName) -> void
+
+      def validate_ancestor_application: (RBS::TypeName, RBS::Definition::Ancestor::Instance ancestor) -> void
+
+      def validate_one_interface: (RBS::TypeName) -> void
+
+      def validate_decl: () -> void
+
+      def validate_const: () -> void
+
+      def validate_one_constant: (RBS::TypeName name, RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Constant] entry) -> void
+
+      def validate_global: () -> void
+
+      def validate_one_global: (Symbol name, RBS::Environment::SingleEntry[Symbol, RBS::AST::Declarations::Global]) -> void
+
+      def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::SingleEntry[RBS::TypeName, RBS::AST::Declarations::Alias] entry) -> void
+
+      def validate_alias: () -> void
+
+      def rescue_validation_errors: (?RBS::TypeName? type_name) { () -> void } -> void
+    end
+  end
+end

data/sig/steep/source.rbs

@@ -1,55 +1,79 @@
 module Steep
   class Source
-    class LocatedAnnotation
-      attr_reader line: untyped
+    extend NodeHelper
 
-      attr_reader annotation: untyped
+    attr_reader path: Pathname
 
-      attr_reader source: untyped
+    attr_reader node: Parser::AST::Node?
 
-      def initialize: (line: untyped, source: untyped, annotation: untyped) -> void
+    attr_reader mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]]
 
-      def ==: (untyped other) -> untyped
-    end
-
-    attr_reader path: untyped
-
-    attr_reader node: untyped
-
-    attr_reader mapping: untyped
-
-    def initialize: (path: untyped, node: untyped, mapping: untyped) -> void
+    def initialize: (path: Pathname, node: Parser::AST::Node?, mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]]) -> void
 
-    class Builder
+    class Builder < ::Parser::Builders::Default
       def string_value: (untyped token) -> untyped
     end
 
-    def self.new_parser: () -> untyped
+    def self.new_parser: () -> Parser::Ruby31
 
-    def self.parse: (untyped source_code, path: untyped, factory: untyped) -> untyped
+    def self.parse: (String source_code, path: Pathname, factory: AST::Types::Factory) -> Source
 
-    def self.construct_mapping: (node: untyped, annotations: untyped, mapping: untyped, ?line_range: untyped?) -> untyped
+    def self.construct_mapping: (
+      node: Parser::AST::Node,
+      annotations: Array[AST::Annotation::t],
+      mapping: Hash[Parser::AST::Node, Array[AST::Annotation::t]],
+      ?line_range: Range[Integer]?
+    ) -> void
 
-    def self.each_child_node: (untyped node) { (untyped) -> untyped } -> untyped
-
-    def self.map_child_nodes: (untyped node) { (untyped) -> untyped } -> untyped
+    def self.map_child_node: (Parser::AST::Node node, ?Symbol? type, ?skip: Set[Parser::AST::Node]?) { (Parser::AST::Node) -> Parser::AST::Node } -> Parser::AST::Node
 
     def annotations: (block: Parser::AST::Node, factory: AST::Types::Factory, context: RBS::Resolver::context) -> AST::Annotation::Collection
 
-    def each_annotation: () { (untyped, untyped) -> untyped } -> untyped
+    def each_annotation: () { ([Parser::AST::Node, Array[AST::Annotation::t]]) -> void } -> void
+                       | () -> Enumerator[[Parser::AST::Node, Array[AST::Annotation::t]], void]
+
+    # Yields all heredoc node and its parents under `node` (or `self.node`)
+    #
+    # Yields arrays, inner node first, outer node last -- `[heredoc_node, *outer_node, node]`.
+    #
+    def each_heredoc_node: (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) { (Array[Parser::AST::Node]) -> void } -> void
+                         | (?Parser::AST::Node? node, ?Array[Parser::AST::Node] parents) -> Enumerator[Array[Parser::AST::Node], void]
+
+    # Returns array of nodes that is located inside heredoc
+    #
+    # ```ruby
+    # content = <<TEXT
+    # #{this or this}
+    # TEXT
+    # ```
+    #
+    # Returns arrays, inner node first, outer node last -- `[*nodes, heredoc_node]`.
+    #
+    def find_heredoc_nodes: (Integer line, Integer column, Integer position) -> Array[Parser::AST::Node]?
+
+    # Returns a node and it's outer nodes
+    #
+    def find_nodes_loc: (Parser::AST::Node node, Integer position, Array[Parser::AST::Node] parents) -> Array[Parser::AST::Node]?
+
+    # Returns a node and it's outer nodes
+    def find_nodes: (line: Integer, column: Integer) -> ::Array[Parser::AST::Node]?
+
+    def self.delete_defs: (Parser::AST::Node node, Set[Parser::AST::Node] allow_list) -> Parser::AST::Node
 
-    def each_heredoc_node: (?untyped node, ?untyped parents) { (untyped) -> untyped } -> untyped
+    def without_unrelated_defs: (line: Integer, column: Integer) -> Source
 
-    def find_heredoc_nodes: (untyped line, untyped column, untyped position) -> (untyped | nil)
+    type type_comment = AST::Node::TypeAssertion | AST::Node::TypeApplication
 
-    def find_nodes_loc: (untyped node, untyped position, untyped parents) -> untyped
+    def self.insert_type_node: (Parser::AST::Node node, Hash[Integer, type_comment]) -> Parser::AST::Node
 
-    def find_nodes: (line: Integer, column: Integer) -> ::Array[Parser::AST::Node]?
+    def self.adjust_location: (Parser::AST::Node) -> Parser::AST::Node
 
-    def self.delete_defs: (untyped node, untyped allow_list) -> untyped
+    def self.assertion_node: (Parser::AST::Node, AST::Node::TypeAssertion) -> Parser::AST::Node
 
-    def without_unrelated_defs: (line: untyped, column: untyped) -> (untyped | self)
+    def self.type_application_node: (Parser::AST::Node, AST::Node::TypeApplication) -> Parser::AST::Node
 
-    def compact_siblings: (untyped node) -> untyped
+    # Returns a line of `selector` of `send` node, that can be used to look up a TypeApplication comment
+    #
+    def self.sendish_node?: (Parser::AST::Node) -> Integer?
   end
 end

data/sig/steep/type_construction.rbs

@@ -32,8 +32,12 @@ module Steep
 
     %a{pure} def module_context: () -> TypeInference::Context::ModuleContext?
 
+    def module_context!: () -> TypeInference::Context::ModuleContext
+
     %a{pure} def method_context: () -> TypeInference::Context::MethodContext?
 
+    def method_context!: () -> TypeInference::Context::MethodContext
+
     %a{pure} def block_context: () -> TypeInference::Context::BlockContext?
 
     %a{pure} def break_context: () -> TypeInference::Context::BreakContext?
@@ -130,16 +134,94 @@ module Steep
 
     def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node]) -> TypeConstruction
 
-    def type_send_interface: (Parser::AST::Node node, interface: Interface::Shape, receiver: Parser::AST::Node, receiver_type: AST::Types::t, method_name: Symbol, arguments: Array[Parser::AST::Node], block_params: Parser::AST::Node?, block_body: Parser::AST::Node?) -> Pair
+    # Synthesize `:send`, `:csend`, `:block`, and `:numblock` node
+    #
+    def synthesize_sendish: (Parser::AST::Node sendish, hint: AST::Types::t?, tapp: AST::Node::TypeApplication?) -> Pair
+
+    # The entrypoint to type check method calls, which may be with blocks
+    #
+    # * `send_node` can be `:send`, `:super`, or `:zsuper`
+    # * `node` can be `:send`, `:block`, `:super`, or `:zsuper`
+    # * Specify `unwrap` keyword `true` to type check safe-navigation-operator, that unwraps the type of reeiver automatically and make the return type optional
+    #
+    def type_send: (
+      Parser::AST::Node node,
+      send_node: Parser::AST::Node,
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?,
+      ?unwrap: bool,
+      tapp: AST::Node::TypeApplication?
+    ) -> Pair
+
+    # The second step to type check method calls, which handles type refinements on *pure* calls
+    #
+    # * It receives `interface` keyword, that is the shape of the receiver type
+    # * It receives `arguments` keyword, that is an array of argument nodes
+    #
+    def type_send_interface: (
+      Parser::AST::Node node,
+      interface: Interface::Shape,
+      receiver: Parser::AST::Node?,
+      receiver_type: AST::Types::t,
+      method_name: Symbol,
+      arguments: Array[Parser::AST::Node],
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?,
+      tapp: AST::Node::TypeApplication?
+    ) -> Pair
+
+    # The third step to type check method calls, which tries all of the overlods defined for the method
+    #
+    # * It receives the `Shape::Entry` object that represents an method entry of a shape
+    # * Returns `nil` when it cannot find suitable one from more than one overloads
+    #   * It means the type checker can report only *no suitable overlod detected for this args* 😫
+    #
+    def type_method_call: (
+      Parser::AST::Node node,
+      method_name: Symbol,
+      receiver_type: AST::Types::t,
+      method: Interface::Shape::Entry,
+      arguments: Array[Parser::AST::Node],
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?,
+      tapp: AST::Node::TypeApplication?
+    ) -> [TypeInference::MethodCall::t, TypeConstruction]?
+
+    # The core to type check method calls, which implements type checking arguments including blocks and type inference
+    #
+    # * `receiver_type` and `method_name` are only used for error reporting
+    #
+    def try_method_type: (
+      Parser::AST::Node node,
+      receiver_type: AST::Types::t,
+      method_name: Symbol,
+      method_type: Interface::MethodType,
+      arguments: Array[Parser::AST::Node],
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?,
+      tapp: AST::Node::TypeApplication?
+    ) -> [TypeInference::MethodCall::t, TypeConstruction]
 
-    def type_send: (untyped node, send_node: untyped, block_params: untyped, block_body: untyped, ?unwrap: bool) -> untyped
+    # Extra step to type check method calls, which implements custom typing rules based on the methods
+    #
+    # * Returns `nil` if the `method_type` object is not associated to a method with custom typing rules
+    #
+    def try_special_method: (
+      Parser::AST::Node node,
+      receiver_type: AST::Types::t,
+      method_name: Symbol,
+      method_type: Interface::MethodType,
+      arguments: Array[Parser::AST::Node],
+      block_params: Parser::AST::Node?,
+      block_body: Parser::AST::Node?
+    ) -> [TypeInference::MethodCall::t, TypeConstruction]?
 
     def builder_config: () -> Interface::Builder::Config
 
     # Calculates the shape (interface) of an type
     #
     # * Returns `nil` if the type cannot be translated to a shape
-    # * Returns Shape::Entry instead of Shape, if `method_name` is given
+    # * Returns Shape::Entry instead of Shape when `method_name` is given
     #
     def calculate_interface: (AST::Types::t `type`, private: bool) -> Interface::Shape?
                            | (AST::Types::t `type`, Symbol method_name, private: bool) -> Interface::Shape::Entry?
@@ -150,19 +232,6 @@ module Steep
 
     KNOWN_PURE_METHODS: Set[method_name]
 
-    def try_special_method: (untyped node, receiver_type: untyped, method_name: untyped, method_type: untyped, arguments: untyped, block_params: untyped, block_body: untyped) -> (::Array[untyped] | nil)
-
-    def type_method_call: (
-      Parser::AST::Node node,
-      method_name: Symbol,
-      receiver_type: AST::Types::t,
-      method: Interface::Shape::Entry,
-      arguments: Array[Parser::AST::Node],
-      block_params: Parser::AST::Node?,
-      block_body: Parser::AST::Node?,
-      topdown_hint: untyped
-    ) -> [TypeInference::MethodCall::t, TypeConstruction]?
-
     def inspect: () -> ::String
 
     def with_child_typing: [A] (range: Range[Integer]) { (TypeConstruction) -> A } -> A
@@ -186,17 +255,6 @@ module Steep
 
     def eliminate_vars: (untyped `type`, untyped variables, ?to: untyped) -> untyped
 
-    def try_method_type: (
-      Parser::AST::Node node,
-      receiver_type: AST::Types::t,
-      method_name: Symbol,
-      method_type: Interface::MethodType,
-      arguments: Array[Parser::AST::Node],
-      block_params: Parser::AST::Node?,
-      block_body: Parser::AST::Node?,
-      topdown_hint: untyped
-    ) -> [TypeInference::MethodCall::t, TypeConstruction]
-
     def type_check_args: (
       TypeInference::SendArgs,
       Subtyping::Constraints,

data/sig/steep/type_inference/method_call.rbs

@@ -72,7 +72,7 @@ module Steep
 
         attr_reader method_decls: Set[MethodDecl]
 
-        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol, receiver_type: AST::Types::t, actual_method_type: Interface::MethodType, method_decls: Array[MethodDecl], return_type: AST::Types::t) -> void
+        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol, receiver_type: AST::Types::t, actual_method_type: Interface::MethodType, method_decls: Set[MethodDecl], return_type: AST::Types::t) -> void
 
         def update: (?node: Parser::AST::Node, ?return_type: AST::Types::t) -> self
 

data/sig/steep.rbs

@@ -1,4 +1,6 @@
 module Steep
+  VERSION: String
+
   def self.logger: () -> (Logger & ActiveSupport::TaggedLogging)
 
   def self.new_logger: (untyped output, untyped prev_level) -> untyped

data/smoke/diagnostics-rbs/inherit-module.rbs

@@ -0,0 +1,2 @@
+class InheritModule < Kernel
+end

data/smoke/diagnostics-rbs/test_expectations.yml

@@ -46,6 +46,18 @@
     severity: ERROR
     message: Different generic parameters are specified across definitions of `::GenericParameterMismatchError::Foo`
     code: RBS::GenericParameterMismatch
+- file: inherit-module.rbs
+  diagnostics:
+  - range:
+      start:
+        line: 1
+        character: 22
+      end:
+        line: 1
+        character: -1
+    severity: ERROR
+    message: Cannot inherit from a module `::Kernel`
+    code: RBS::InheritModuleError
 - file: invalid-method-overload.rbs
   diagnostics:
   - range:

data/steep.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", ">= 3.15", "< 4.0"
-  spec.add_runtime_dependency "rbs", ">= 2.7.0"
+  spec.add_runtime_dependency "rbs", ">= 2.8.0.pre"
   spec.add_runtime_dependency "parallel", ">= 1.0.0"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
   spec.add_runtime_dependency "securerandom", ">= 0.1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0.pre.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-22 00:00:00.000000000 Z
+date: 2022-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -98,14 +98,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: 2.8.0.pre
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0
+        version: 2.8.0.pre
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -258,6 +258,8 @@ files:
 - lib/steep/ast/annotation.rb
 - lib/steep/ast/annotation/collection.rb
 - lib/steep/ast/builtin.rb
+- lib/steep/ast/node/type_application.rb
+- lib/steep/ast/node/type_assertion.rb
 - lib/steep/ast/type_params.rb
 - lib/steep/ast/types.rb
 - lib/steep/ast/types/any.rb
@@ -372,16 +374,21 @@ files:
 - sample/lib/length.rb
 - sample/sig/conference.rbs
 - sample/sig/length.rbs
+- sig/shims/exception.rbs
 - sig/shims/language-server_protocol.rbs
 - sig/shims/parallel.rbs
 - sig/shims/parser.rbs
+- sig/shims/parser/comment.rbs
 - sig/shims/parser/source/map.rbs
 - sig/shims/parser/source/range.rbs
 - sig/shims/tagged_logging.rbs
 - sig/steep.rbs
+- sig/steep/annotation_parser.rbs
 - sig/steep/ast/annotation.rbs
 - sig/steep/ast/annotation/collection.rbs
 - sig/steep/ast/builtin.rbs
+- sig/steep/ast/node/type_application.rbs
+- sig/steep/ast/node/type_assertion.rbs
 - sig/steep/ast/type_params.rbs
 - sig/steep/ast/types.rbs
 - sig/steep/ast/types/any.rbs
@@ -444,6 +451,7 @@ files:
 - sig/steep/project/options.rbs
 - sig/steep/project/pattern.rbs
 - sig/steep/project/target.rbs
+- sig/steep/range_extension.rbs
 - sig/steep/server/base_worker.rbs
 - sig/steep/server/change_buffer.rbs
 - sig/steep/server/interaction_worker.rbs
@@ -462,6 +470,7 @@ files:
 - sig/steep/services/signature_service.rbs
 - sig/steep/services/stats_calculator.rbs
 - sig/steep/services/type_check_service.rbs
+- sig/steep/signature/validator.rbs
 - sig/steep/source.rbs
 - sig/steep/subtyping/cache.rbs
 - sig/steep/subtyping/check.rbs
@@ -537,6 +546,7 @@ files:
 - smoke/diagnostics-rbs/Steepfile
 - smoke/diagnostics-rbs/duplicated-method-definition.rbs
 - smoke/diagnostics-rbs/generic-parameter-mismatch.rbs
+- smoke/diagnostics-rbs/inherit-module.rbs
 - smoke/diagnostics-rbs/invalid-method-overload.rbs
 - smoke/diagnostics-rbs/invalid-type-application.rbs
 - smoke/diagnostics-rbs/invalid_variance_annotation.rbs
@@ -754,9 +764,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key: