steep 1.0.0 → 1.1.0.pre.1

data/sig/steep/type_construction.rbs

@@ -0,0 +1,285 @@
+module Steep
+  class TypeConstruction
+    class Pair
+      attr_reader type: AST::Types::t
+
+      attr_reader constr: TypeConstruction
+
+      def initialize: (type: AST::Types::t, constr: TypeConstruction) -> void
+
+      def with: (?type: AST::Types::t, ?constr: TypeConstruction) -> Pair
+
+      def +: (Pair other) -> Pair
+
+      def context: () -> TypeInference::Context
+
+      def to_ary: () -> [AST::Types::t, TypeConstruction, TypeInference::Context]
+    end
+
+    include NodeHelper
+
+    attr_reader checker: Subtyping::Check
+
+    attr_reader source: Source
+
+    attr_reader annotations: AST::Annotation::Collection
+
+    attr_reader typing: Typing
+
+    attr_reader context: TypeInference::Context
+
+    def module_context: () -> TypeInference::Context::ModuleContext?
+
+    def method_context: () -> TypeInference::Context::MethodContext?
+
+    def block_context: () -> TypeInference::Context::BlockContext?
+
+    def break_context: () -> TypeInference::Context::BreakContext?
+
+    def self_type: () -> untyped
+
+    def variable_context: () -> TypeInference::Context::TypeVariableContext
+
+    def initialize: (checker: untyped, source: untyped, annotations: untyped, typing: untyped, context: untyped) -> void
+
+    def with_new_typing: (Typing typing) -> TypeConstruction
+
+    def with_updated_context: (?type_env: TypeInference::TypeEnv) -> TypeConstruction
+
+    def with: (?annotations: untyped, ?context: TypeInference::Context, ?typing: untyped) -> TypeConstruction
+
+    def update_context: () { (TypeInference::Context) -> TypeInference::Context } -> TypeConstruction
+
+    def update_type_env: () { (TypeInference::TypeEnv) -> TypeInference::TypeEnv } -> TypeConstruction
+
+    def check_relation: (sub_type: AST::Types::t, super_type: AST::Types::t, ?constraints: Subtyping::Constraints) -> Subtyping::Result::Base
+
+    # This is a variation of `#check_relation` method.
+    # It checks if given subtyping relation `sub_type <: super_type` holds or not, and returns truthy when *doesn't* hold.
+    #
+    # * Returns `nil` if holds
+    # * Returns subclass of `Result::Base` if the subtyping doesn't hold
+    #
+    # This allow you writing a subtyping check as:
+    #
+    # ```ruby
+    # if relation = no_subtyping?(sub_type: type1, super_type: type2)
+    #   # Implement error reporting
+    # end
+    # ```
+    #
+    def no_subtyping?: (sub_type: AST::Types::t, super_type: AST::Types::t, ?constraints: Subtyping::Constraints) -> Subtyping::Result::Base?
+
+    def for_new_method: (Symbol method_name, Parser::AST::Node node, args: Array[Parser::AST::Node], self_type: untyped, definition: RBS::Definition?) -> TypeConstruction
+
+    def with_method_constr: (untyped method_name, untyped node, args: untyped, self_type: untyped, definition: untyped) { (untyped) -> untyped } -> untyped
+
+    def implement_module: (module_name: untyped, annotations: untyped, ?super_name: untyped?) -> untyped
+
+    def default_module_context: (untyped implement_module_name, nesting: untyped) -> untyped
+
+    def for_module: (untyped node, untyped new_module_name) -> untyped
+
+    def with_module_constr: (untyped node, untyped module_name) { (untyped) -> untyped } -> untyped
+
+    def for_class: (untyped node, untyped new_class_name, untyped super_class_name) -> untyped
+
+    def with_class_constr: (untyped node, untyped new_class_name, untyped super_class_name) { (untyped) -> untyped } -> untyped
+
+    def with_sclass_constr: [A] (Parser::AST::Node node, AST::Types::t `type`) { (TypeConstruction?) -> A } -> A
+
+    def for_sclass: (Parser::AST::Node node, AST::Types::t `type`) -> TypeConstruction?
+
+    def for_branch: (Parser::AST::Node node, ?break_context: TypeInference::Context::BreakContext?) -> untyped
+
+    def add_typing: (Parser::AST::Node node, type: AST::Types::t, ?constr: TypeConstruction) -> Pair
+
+    def add_call: (untyped call) -> untyped
+
+    def synthesize: (Parser::AST::Node node, ?hint: AST::Types::t?, ?condition: bool) -> Pair
+
+    def check: (Parser::AST::Node node, AST::Types::t `type`, ?constraints: Subtyping::Constraints) { (AST::Types::t, AST::Types::t, Subtyping::Result::Base) -> void } -> Pair
+
+    def masgn_lhs?: (untyped lhs) -> untyped
+
+    def lvasgn: (Parser::AST::Node node, AST::Types::t) -> Pair
+
+    def ivasgn: (Parser::AST::Node node, AST::Types::t rhs_type) -> Pair
+
+    def type_masgn: (Parser::AST::Node node) -> Pair
+
+    def type_masgn_type: (Parser::AST::Node mlhs_node, AST::Types::t? rhs_type, masgn: TypeInference::MultipleAssignment, optional: bool) -> TypeConstruction?
+
+    def constant_typename: (Parser::AST::Node parent, Symbol name) -> RBS::TypeName?
+
+    def synthesize_constant: (Parser::AST::Node node, Parser::AST::Node? parent_node, Symbol constant_name) { () -> void } -> [AST::Types::t, TypeConstruction, RBS::TypeName?]
+
+    def optional_proc?: (untyped `type`) -> (untyped | nil | nil | nil | nil)
+
+    def type_lambda: (Parser::AST::Node node, params_node: Parser::AST::Node, body_node: Parser::AST::Node, type_hint: AST::Types::t?) -> Pair
+
+    def synthesize_children: (Parser::AST::Node node, ?skips: Array[Parser::AST::Node]) -> TypeConstruction
+
+    def type_send_interface: (Parser::AST::Node node, interface: Interface::Interface, 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
+
+    def type_send: (untyped node, send_node: untyped, block_params: untyped, block_body: untyped, ?unwrap: bool) -> untyped
+
+    def calculate_interface: (untyped `type`, private: untyped, ?self_type: untyped) -> untyped
+
+    def expand_self: (untyped `type`) -> untyped
+
+    SPECIAL_METHOD_NAMES: { array_compact: untyped, hash_compact: untyped }
+
+    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::Interface::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: (range: untyped) { (untyped) -> untyped } -> untyped
+
+    # Bypass :splat and :kwsplat
+    def bypass_splat: (untyped node) { (untyped) -> untyped } -> untyped
+
+    # Solve a constraint in the block and return a substitution if succeeds.
+    #
+    # * When the constraint has a solution, `#apply_solution` returns a tuple of substituted `MethodType`, `true`, and the substitution.
+    # * When the constraint doesn't have a solution, `#apply_solution` returns a tuple of the original `MethodType`, `false`, and empty substitution.
+    #
+    def apply_solution: (
+        Array[Diagnostic::Ruby::Base] errors,
+        node: Parser::AST::Node,
+        method_type: Interface::MethodType
+      ) {
+        () -> Interface::Substitution
+      } -> [Interface::MethodType, bool, Interface::Substitution]
+
+    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_argument: (Parser::AST::Node node, receiver_type: AST::Types::t, type: AST::Types::t, constraints: Subtyping::Constraints, errors: Array[Diagnostic::Ruby::Base], ?report_node: Parser::AST::Node) -> Pair
+
+    def type_block_without_hint: (node: untyped, block_annotations: untyped, block_params: untyped, block_body: untyped) { () -> untyped } -> untyped
+
+    # Returns a Pair of
+    #
+    # * TypeConstruction to type check the block, and
+    # * Set of local variable names to unpin after type checking the block
+    #
+    def for_block: (
+        Parser::AST::Node? body_node,
+        block_params: TypeInference::BlockParams,
+        block_param_hint: TypeInference::MethodParams?,
+        block_type_hint: AST::Types::t?,
+        block_block_hint: Interface::Block?,
+        block_annotations: AST::Annotation::Collection,
+        node_type_hint: AST::Types::t?
+      ) -> TypeConstruction
+
+    # Synthesize the block body and returns the type of the body
+    #
+    # The constructor can be discarded because it cannot change anything outer than block.
+    #
+    def synthesize_block: (node: Parser::AST::Node, block_type_hint: AST::Types::t?, block_body: Parser::AST::Node?) -> AST::Types::t
+
+    def nesting: () -> RBS::Resolver::context
+
+    def absolute_name: (untyped name) -> untyped
+
+    def union_type: (*AST::Types::t types) -> AST::Types::t
+
+    def validate_method_definitions: (untyped node, untyped module_name) -> (nil | untyped)
+
+    def fallback_to_any: (Parser::AST::Node node) ?{ () -> Diagnostic::Ruby::Base } -> Pair
+
+    def self_class?: (untyped node) -> untyped
+
+    def namespace_module?: (untyped node) -> (false | untyped)
+
+    def type_any_rec: (Parser::AST::Node node) -> Pair
+
+    def unwrap: (untyped `type`) -> untyped
+
+    def deep_expand_alias: (AST::Types::t `type`) -> AST::Types::t
+                         | [A] (AST::Types::t) { (AST::Types::t) -> A } -> A
+
+    def flatten_union: (untyped `type`) -> untyped
+
+    def select_flatten_types: (untyped `type`) { () -> untyped } -> untyped
+
+    def partition_flatten_types: (AST::Types::t `type`) { (AST::Types::t) -> boolish } -> [Array[AST::Types::t], Array[AST::Types::t]]
+
+    def flatten_array_elements: (untyped `type`) -> untyped
+
+    def expand_alias: (AST::Types::t `type`) -> AST::Types::t
+                    | [A] (AST::Types::t) { (AST::Types::t) -> A } -> A
+
+    def test_literal_type: (untyped literal, untyped hint) -> (untyped | nil)
+
+    def to_instance_type: (untyped `type`, ?args: untyped?) -> untyped
+
+    def try_tuple_type!: (Parser::AST::Node node, ?hint: AST::Types::t?) -> Pair
+
+    def try_tuple_type: (Parser::AST::Node node, AST::Types::Tuple? hint) -> (nil | untyped)
+
+    # Try to convert a object of `type` with zero-arity method `method`.
+    #
+    # Returns `nil` when
+    #
+    # 1. The `type` cannot be converted to an interface, or
+    # 2. There is no that `conversion` method defined
+    #
+    # ```ruby
+    # try_convert(`::Object`, :to_s)        # Returns `::String`
+    # try_convert(`::String`, :to_ary)      # Returns nil
+    # ```
+    #
+    def try_convert: (AST::Types::t `type`, Symbol method) -> AST::Types::t?
+
+    def try_array_type: (untyped node, untyped hint) -> untyped
+
+    # Returns a record type if `hash_node` can have a record type.
+    #
+    # You can give a hint through `record_type` by passing a `AST::Types::Record` object.
+    # If you pass `nil`, then we know the type is expected to be a record, but the detail is not given.
+    #
+    # Returns `nil` when the `hash_node` cannot have a record type.
+    #
+    def type_hash_record: (Parser::AST::Node hash_node, AST::Types::Record? record_type) -> Pair?
+
+    # Give hash_node a type based on hint.
+    #
+    # * When hint is Record type, it may have record type.
+    # * When hint is union type, it tries recursively with the union cases.
+    # * Otherwise, it tries to be a hash instance.
+    #
+    def type_hash: (untyped hash_node, hint: untyped) -> untyped
+
+    # Returns the first one from elements of `types` that returns a type `t` where `t <: hint`.
+    #
+    def pick_one_of: (Array[AST::Types::t] types, range: untyped) { (AST::Types::t hint, TypeConstruction) -> Pair? } -> Pair?
+
+    def save_typing: () -> untyped
+
+    # Returns `true` if a method call can be identified as _pure_.
+    #
+    # * The `node` is not a call with call
+    # * It always calls _pure_ method
+    # * The `receiver` is _pure_
+    # * All of the arguments are _pure_
+    #
+    def pure_send?: (TypeInference::MethodCall::Typed call, Parser::AST::Node receiver, Array[Parser::AST::Node] arguments) -> bool
+  end
+end

data/sig/steep/type_inference/block_params.rbs

@@ -0,0 +1,52 @@
+module Steep
+  module TypeInference
+    class BlockParams
+      class Param
+        attr_reader var: Symbol
+
+        attr_reader type: AST::Types::t
+
+        attr_reader value: untyped
+
+        attr_reader node: Parser::AST::Node
+
+        def initialize: (var: Symbol, type: AST::Types::t, value: untyped, node: Parser::AST::Node) -> void
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+      end
+
+      attr_reader leading_params: untyped
+
+      attr_reader optional_params: untyped
+
+      attr_reader rest_param: untyped
+
+      attr_reader trailing_params: untyped
+
+      attr_reader block_param: untyped
+
+      def initialize: (leading_params: untyped, optional_params: untyped, rest_param: untyped, trailing_params: untyped, block_param: untyped) -> void
+
+      def params: () -> untyped
+
+      def self.from_node: (untyped node, annotations: untyped) -> (nil | untyped)
+
+      def params_type: (?hint: untyped?) -> untyped
+
+      def params_type0: (hint: untyped) -> (nil | untyped)
+
+      def zip: (untyped params_type, untyped block) -> untyped
+
+      def expandable_params?: (untyped params_type) -> (untyped | nil)
+
+      def expandable?: () -> untyped
+
+      def each: () { (Param) -> void } -> void
+              | () -> Enumerator[Param, void]
+    end
+  end
+end

data/sig/steep/type_inference/constant_env.rbs

@@ -0,0 +1,27 @@
+module Steep
+  module TypeInference
+    class ConstantEnv
+      type constant_tuple = [untyped, RBS::TypeName, RBS::Constant::constant_entry]
+
+      attr_reader context: RBS::Resolver::context
+
+      attr_reader factory: AST::Types::Factory
+
+      attr_reader resolver: RBS::Resolver::ConstantResolver
+
+      def initialize: (factory: AST::Types::Factory, context: RBS::Resolver::context, resolver: RBS::Resolver::ConstantResolver) -> void
+
+      def resolve: (Symbol name) -> constant_tuple?
+
+      def toplevel: (Symbol name) -> constant_tuple?
+
+      def constants: () -> Hash[Symbol, constant_tuple]
+
+      def resolve_child: (RBS::TypeName module_name, Symbol constant_name) -> constant_tuple?
+
+      def children: (RBS::TypeName module_name) -> Hash[Symbol, constant_tuple]
+
+      def decompose_constant: (RBS::Constant? constant) -> constant_tuple?
+    end
+  end
+end

data/sig/steep/type_inference/context.rbs

@@ -0,0 +1,137 @@
+module Steep
+  module TypeInference
+    class Context
+      class MethodContext
+        attr_reader name: untyped
+
+        attr_reader method: untyped
+
+        attr_reader method_type: untyped
+
+        attr_reader return_type: untyped
+
+        attr_reader constructor: untyped
+
+        attr_reader super_method: untyped
+
+        def initialize: (name: untyped, method: untyped, method_type: untyped, return_type: untyped, constructor: untyped, super_method: untyped) -> void
+
+        def block_type: () -> untyped
+      end
+
+      class BlockContext
+        # The type of block itself
+        #
+        # Returns `nil` if no type is specified.
+        #
+        attr_reader body_type: AST::Types::t?
+
+        def initialize: (body_type: AST::Types::t?) -> void
+
+        def subst: (Interface::Substitution) -> BlockContext
+      end
+
+      class BreakContext
+        # Type of arguments to `break` statement
+        #
+        attr_reader break_type: AST::Types::t
+
+        # Type of arguments to `next` statement
+        #
+        # `nil` means the passed value will be ignored.
+        #
+        attr_reader next_type: AST::Types::t?
+
+        def initialize: (break_type: AST::Types::t, next_type: AST::Types::t?) -> void
+
+        def subst: (Interface::Substitution) -> BreakContext
+      end
+
+      class ModuleContext
+        attr_reader instance_type: AST::Types::t
+
+        attr_reader module_type: AST::Types::t
+
+        attr_reader defined_instance_methods: untyped
+
+        attr_reader defined_module_methods: untyped
+
+        attr_reader nesting: RBS::Resolver::context
+
+        attr_reader implement_name: untyped
+
+        attr_reader class_name: RBS::TypeName
+
+        attr_reader instance_definition: RBS::Definition
+
+        attr_reader module_definition: RBS::Definition
+
+        def initialize: (instance_type: untyped, module_type: untyped, implement_name: untyped, class_name: untyped, nesting: untyped, ?instance_definition: untyped?, ?module_definition: untyped?) -> void
+
+        def class_variables: () -> (untyped | nil)
+
+        def update: (?instance_type: untyped, ?module_type: untyped, ?implement_name: untyped, ?class_name: untyped, ?instance_definition: untyped, ?module_definition: untyped, ?nesting: untyped) -> untyped
+      end
+
+      class TypeVariableContext
+        attr_reader table: Hash[Symbol, Interface::TypeParam]
+
+        attr_reader type_params: Array[Interface::TypeParam]
+
+        def initialize: (Array[Interface::TypeParam] type_params, ?parent_context: TypeVariableContext?) -> void
+
+        def []: (Symbol name) -> AST::Types::t?
+
+        def upper_bounds: () -> Hash[Symbol, AST::Types::t]
+
+        def self.empty: () -> TypeVariableContext
+      end
+
+      attr_reader call_context: untyped
+
+      attr_reader method_context: untyped
+
+      # BlockContext for current execution point
+      #
+      # `nil` when not in iterator block.
+      #
+      attr_reader block_context: BlockContext?
+
+      attr_reader break_context: BreakContext?
+
+      attr_reader module_context: untyped
+
+      attr_reader self_type: AST::Types::t
+
+      attr_reader type_env: TypeEnv
+
+      attr_reader variable_context: TypeVariableContext
+
+      def initialize: (
+        method_context: untyped,
+        block_context: BlockContext?,
+        break_context: BreakContext?,
+        module_context: untyped,
+        self_type: untyped,
+        type_env: TypeEnv,
+        call_context: untyped,
+        variable_context: TypeVariableContext
+      ) -> void
+
+      def with: (
+        ?method_context: untyped,
+        ?block_context: BlockContext?,
+        ?break_context: BreakContext?,
+        ?module_context: untyped,
+        ?self_type: untyped,
+        ?type_env: TypeEnv,
+        ?call_context: untyped,
+        ?variable_context: untyped
+      ) -> Context
+
+      def factory: () -> AST::Types::Factory
+
+      def env: () -> RBS::Environment
+    end
+  end
+end

data/sig/steep/type_inference/logic_type_interpreter.rbs

@@ -0,0 +1,72 @@
+module Steep
+  module TypeInference
+    class LogicTypeInterpreter
+      attr_reader subtyping: Subtyping::Check
+
+      attr_reader typing: Typing
+
+      attr_reader factory (): AST::Types::Factory
+
+      def initialize: (subtyping: Subtyping::Check, typing: Typing) -> void
+
+      def eval: (env: TypeEnv, node: Parser::AST::Node) -> [TypeEnv, TypeEnv, Set[Symbol | Parser::AST::Node], AST::Types::t, AST::Types::t]
+
+      def evaluate_node: (env: TypeEnv, node: Parser::AST::Node, refined_objects: Set[Symbol | Parser::AST::Node]) -> [AST::Types::t, AST::Types::t, TypeEnv, TypeEnv]
+
+      def evaluate_method_call: (env: TypeEnv, type: AST::Types::Logic::Base, receiver: Parser::AST::Node?, arguments: Array[Parser::AST::Node], refined_objects: Set[Symbol | Parser::AST::Node]) -> [TypeEnv, TypeEnv]?
+
+      # Apply type refinement to `node` as `truthy_type` and `falsy_type`.
+      #
+      # This is done by top-down manner.
+      #
+      # Assignes given two types to the node when:
+      #
+      # * `node` is a `lvar`
+      # * `node` is a `lvasgn`
+      # * `node` is a _pure_ method call
+      #
+      def refine_node_type: (env: TypeEnv, node: Parser::AST::Node, truthy_type: AST::Types::t, falsy_type: AST::Types::t, refined_objects: Set[Symbol | Parser::AST::Node]) -> [TypeEnv, TypeEnv]
+
+      # Returns a pair of a node and set of local variable names.
+      #
+      # * The returned node is called _value node_ that is a node the value of given `node` can be taken from
+      # * The local variable names are local variables that have the same value of the _value node_.
+      #
+      # ```ruby
+      # a = 123   # `123` is the _value node_
+      #           # :a is included in the set because `a` has the same value of _value node_
+      #
+      # c = b = a  # `a` is the _value node_, a set of { :b, :c } will be returned
+      # ```
+      #
+      def decompose_value: (Parser::AST::Node node) -> [Parser::AST::Node, Set[Symbol]]
+
+      private
+
+      def evaluate_assignment: (Parser::AST::Node node, TypeEnv env, AST::Types::t rhs_type, refined_objects: Set[Symbol | Parser::AST::Node]) -> TypeEnv
+
+      def guess_type_from_method: (Parser::AST::Node node) -> (AST::Types::Logic::ReceiverIsArg | AST::Types::Logic::ReceiverIsNil | AST::Types::Logic::Not | AST::Types::Logic::ArgIsReceiver | nil)
+
+      # Decompose to given type to truthy and falsy types.
+      #
+      # This directly corresponds to case-when syntax with literals:
+      #
+      # ```ruby
+      # case x
+      # when nil       # value_node == {nil}, arg_type = type_of({x})
+      #   ...
+      # when 123       # value_node == {nil}, arg_type = type_of({x})
+      #   ...
+      # end
+      # ```
+      #
+      def literal_var_type_case_select: (Parser::AST::Node value_node, AST::Types::t arg_type) -> [Array[AST::Types::t], Array[AST::Types::t]]?
+
+      def type_case_select: (AST::Types::t `type`, RBS::TypeName klass) -> [AST::Types::t, AST::Types::t]
+
+      def type_case_select0: (AST::Types::t `type`, RBS::TypeName klass) -> [Array[AST::Types::t], Array[AST::Types::t]]
+
+      def try_convert: (AST::Types::t, Symbol) -> AST::Types::t?
+    end
+  end
+end

data/sig/steep/type_inference/method_call.rbs

@@ -0,0 +1,124 @@
+module Steep
+  module TypeInference
+    class MethodCall
+      class MethodDecl
+        attr_reader method_name: method_name
+
+        attr_reader method_def: RBS::Definition::Method::TypeDef
+
+        def initialize: (method_name: method_name, method_def: RBS::Definition::Method::TypeDef) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def method_type: () -> RBS::MethodType
+      end
+
+      class MethodContext
+        attr_reader method_name: method_name
+
+        def initialize: (method_name: method_name) -> void
+
+        def to_s: () -> String
+      end
+
+      class ModuleContext
+        attr_reader type_name: RBS::TypeName
+
+        def initialize: (type_name: RBS::TypeName) -> void
+
+        def to_s: () -> String
+      end
+
+      class TopLevelContext
+        def to_s: () -> String
+      end
+
+      class UnknownContext
+        def to_s: () -> String
+      end
+
+      type context = MethodContext | ModuleContext | TopLevelContext | UnknownContext
+
+      class Base
+        attr_reader node: Parser::AST::Node
+
+        attr_reader context: context
+
+        attr_reader method_name: Symbol
+
+        attr_reader return_type: AST::Types::t
+
+        attr_reader receiver_type: AST::Types::t
+
+        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol, receiver_type: AST::Types::t, return_type: AST::Types::t) -> void
+
+        def with_return_type: (AST::Types::t new_type) -> self
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+      end
+
+      type t = Typed | Special | Untyped | NoMethodError | Error
+
+      class Typed < Base
+        attr_reader actual_method_type: Interface::MethodType
+
+        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 update: (?node: Parser::AST::Node, ?return_type: AST::Types::t) -> self
+
+        def pure?: () -> bool
+
+        def ==: (untyped other) -> bool
+
+        alias eql? ==
+
+        def hash: () -> Integer
+      end
+
+      class Special < Typed
+      end
+
+      class Untyped < Base
+        def initialize: (node: Parser::AST::Node, context: context, method_name: Symbol) -> void
+      end
+
+      class NoMethodError < Base
+        attr_reader error: Diagnostic::Ruby::NoMethod
+
+        def initialize: (
+          node: Parser::AST::Node,
+          context: context,
+          method_name: Symbol,
+          receiver_type: AST::Types::t,
+          error: Diagnostic::Ruby::NoMethod
+        ) -> void
+      end
+
+      class Error < Base
+        attr_reader errors: Array[Diagnostic::Ruby::Base]
+
+        attr_reader method_decls: Set[MethodDecl]
+
+        def initialize: (
+          node: Parser::AST::Node,
+          context: context,
+          method_name: Symbol,
+          receiver_type: AST::Types::t,
+          errors: Array[Diagnostic::Ruby::Base],
+          ?method_decls: Set[MethodDecl],
+          ?return_type: AST::Types::t
+        ) -> void
+      end
+    end
+  end
+end