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: Set[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