steep 0.11.1 → 0.12.0

data/lib/steep/drivers/scaffold.rb

@@ -1,321 +0,0 @@
-module Steep
-  module Drivers
-    class Scaffold
-      attr_reader :source_paths
-      attr_reader :stdout
-      attr_reader :stderr
-      attr_reader :labeling
-
-      include Utils::EachSignature
-
-      def initialize(source_paths:, stdout:, stderr:)
-        @source_paths = source_paths
-        @stdout = stdout
-        @stderr = stderr
-      end
-
-      def run
-        source_paths.each do |path|
-          each_file_in_path(".rb", path) do |file_path|
-            file = Project::SourceFile.new(path: file_path, options: Project::Options.new)
-            file.content = file_path.read
-            file.parse
-            Generator.new(source: file.source, stderr: stderr).write(io: stdout)
-          end
-        end
-        0
-      end
-
-      class Generator
-        class Module
-          attr_reader :name
-          attr_reader :methods
-          attr_reader :singleton_methods
-          attr_reader :ivars
-          attr_reader :kind
-
-          def initialize(name:, kind:)
-            @kind = kind
-            @name = name
-            @ivars = {}
-            @methods = {}
-            @singleton_methods = {}
-          end
-
-          def class?
-            kind == :class
-          end
-
-          def module?
-            kind == :module
-          end
-
-          attr_accessor :has_subclass
-
-          def namespace_class?
-            has_subclass && methods.empty? && singleton_methods.empty?
-          end
-        end
-
-        attr_reader :source
-        attr_reader :modules
-        attr_reader :constants
-        attr_reader :stderr
-
-        def initialize(source:, stderr:)
-          @source = source
-          @stderr = stderr
-          @modules = []
-          @constants = {}
-        end
-
-        def write(io:)
-          generate(source.node, current_path: [])
-
-          modules.each do |mod|
-            unless mod.namespace_class?
-              io.puts "#{mod.kind} #{mod.name}"
-
-              mod.ivars.each do |name, type|
-                io.puts "  #{name}: #{type}"
-              end
-
-              mod.methods.each do |name, type|
-                io.puts "  def #{name}: #{type}"
-              end
-
-              mod.singleton_methods.each do |name, type|
-                io.puts "  def self.#{name}: #{type}"
-              end
-
-              io.puts "end"
-              io.puts
-            end
-          end
-
-          constants.each do |name, ty|
-            io.puts "#{name}: #{ty}"
-          end
-        end
-
-        def module_name(name)
-          if name.type == :const
-            prefix = name.children[0]
-            if prefix
-              "#{module_name(prefix)}::#{name.children[1]}"
-            else
-              name.children[1].to_s
-            end
-          else
-            stderr.puts "Unexpected node for class name: #{name}"
-            return "____"
-          end
-        end
-
-        def full_name(current_path, name)
-          (current_path + [name]).join("::")
-        end
-
-        def generate(node, current_path:, current_module: nil, is_instance_method: false)
-          case node.type
-          when :module
-            name = module_name(node.children[0])
-            mod = Module.new(name: full_name(current_path, name), kind: :module)
-            modules << mod
-
-            if node.children[1]
-              generate(node.children[1],
-                       current_path: current_path + [name],
-                       current_module: mod)
-            end
-
-            if current_module
-              current_module.has_subclass = true
-            end
-
-          when :class
-            name = module_name(node.children[0])
-            klass = Module.new(name: full_name(current_path, name), kind: :class)
-            modules << klass
-
-            if node.children[2]
-              generate(node.children[2],
-                       current_path: current_path + [name],
-                       current_module: klass)
-            end
-
-            if current_module
-              current_module.has_subclass = true
-            end
-
-          when :def
-            name, args, body = node.children
-
-            if current_module
-              current_module.methods[name] = "(#{arg_types(args)}) -> #{guess_type(body)}"
-            end
-
-            if body
-              generate(body,
-                       current_path: current_path,
-                       current_module: current_module,
-                       is_instance_method: true)
-            end
-
-          when :ivar, :ivasgn
-            name = node.children[0]
-
-            if current_module && is_instance_method
-              current_module.ivars[name] = guess_type(node.children[1])
-            end
-
-            each_child_node(node) do |child|
-              generate(child,
-                       current_path: current_path,
-                       current_module: current_module,
-                       is_instance_method: is_instance_method)
-            end
-
-          when :defs
-            if node.children[0].type == :self
-              _, name, args, body = node.children
-
-              if current_module
-                current_module.singleton_methods[name] = "(#{arg_types(args)}) -> #{guess_type(body)}"
-              end
-
-              if body
-                generate(body,
-                         current_path: current_path,
-                         current_module: current_module,
-                         is_instance_method: false)
-              end
-            end
-
-          when :casgn
-            if node.children[0]
-              stderr.puts "Unexpected casgn: #{node}, #{node.loc.line}"
-            end
-
-            constants[full_name(current_path, node.children[1])] = guess_type(node.children[2])
-
-            if node.children[2]
-              generate(node.children[2],
-                       current_path: current_path,
-                       current_module: current_module,
-                       is_instance_method: is_instance_method)
-            end
-
-          else
-            each_child_node(node) do |child|
-              generate(child, current_path: current_path, current_module: current_module, is_instance_method: is_instance_method)
-            end
-          end
-        end
-
-        def guess_type(node)
-          return "any" unless node
-          case node.type
-          when :false, :true
-            "bool"
-          when :int
-            "Integer"
-          when :float
-            "Float"
-          when :complex
-            "Complex"
-          when :rational
-            "Rational"
-          when :str, :dstr, :xstr
-            "String"
-          when :sym, :dsym
-            "Symbol"
-          when :regexp
-            "Regexp"
-          when :array
-            "Array<any>"
-          when :hash
-            "Hash<any, any>"
-          when :irange, :erange
-            "Range<any>"
-          when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
-            guess_type(node.children.last)
-          when :send
-            if node.children[1] == :[]=
-              guess_type(node.children.last)
-            else
-              "any"
-            end
-          when :begin
-            # should support shortcut return?
-            guess_type(node.children.last)
-          when :return
-            children = node.children
-            if children.size == 1
-              guess_type(node.children.last)
-            else
-              "Array<any>" # or Tuple or any?
-            end
-          when :if
-            children = node.children
-            if children[2]
-              ty1 = guess_type(children[1])
-              ty2 = guess_type(children[2])
-              if ty1 == ty2
-                ty1
-              else
-                "any"
-              end
-            else
-              "void" # assuming no-else if statement implies void
-            end
-          when :while, :until, :while_post, :until_post, :for
-            "void"
-          when :case
-            children = node.children
-            if children.last
-              ty = guess_type(children.last)
-              children[1..-2].each do |child|
-                return "any" if ty != guess_type(child.children.last)
-              end
-              ty
-            else
-              "any"
-            end
-          when :masgn
-            "void" # assuming masgn implies void
-          else
-            "any"
-          end
-        end
-
-        def each_child_node(node, &block)
-          node.children.each do |child|
-            if child.is_a?(::AST::Node)
-              yield child
-            end
-          end
-        end
-
-        def arg_types(args)
-          args.children.map do |arg|
-            case arg.type
-            when :arg
-              "any"
-            when :optarg
-              "?#{guess_type(arg.children[1])}"
-            when :restarg
-              "*any"
-            when :kwarg
-              "#{arg.children.first.name}: any"
-            when :kwoptarg
-              "?#{arg.children.first.name}: #{guess_type(arg.children[1])}"
-            when :kwrestarg
-              "**any"
-            end
-          end.compact.join(", ")
-        end
-      end
-    end
-  end
-end

data/lib/steep/drivers/utils/each_signature.rb

@@ -1,31 +0,0 @@
-module Steep
-  module Drivers
-    module Utils
-      module EachSignature
-        def each_file_in_path(suffix, path)
-          if path.file?
-            yield path
-          end
-
-          if path.directory?
-            each_file_in_dir(suffix, path) do |file|
-              yield file
-            end
-          end
-        end
-
-        def each_file_in_dir(suffix, path, &block)
-          path.children.each do |child|
-            if child.directory?
-              each_file_in_dir(suffix, child, &block)
-            end
-
-            if child.file? && suffix == child.extname
-              yield child
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/steep/interface/abstract.rb

@@ -1,68 +0,0 @@
-module Steep
-  module Interface
-    class Abstract
-      attr_reader :name
-      attr_reader :kind
-      attr_reader :params
-      attr_reader :methods
-      attr_reader :supers
-      attr_reader :ivar_chains
-
-      def initialize(name:, params:, methods:, supers:, ivar_chains:)
-        @name = name
-        @params = params
-        @methods = methods
-        @supers = supers
-        @ivar_chains = ivar_chains
-      end
-
-      def ivars
-        @ivars ||= ivar_chains.transform_values(&:type)
-      end
-
-      def ==(other)
-        other.is_a?(self.class) &&
-          other.name == name &&
-          other.params == params &&
-          other.methods == methods &&
-          other.supers == supers &&
-          other.ivars == ivars
-      end
-
-      def instantiate(type:, args:, instance_type:, module_type:)
-        Steep.logger.debug("type=#{type}, self=#{name}, args=#{args}, params=#{params}")
-        subst = Substitution.build(params, args, instance_type: instance_type, module_type: module_type, self_type: type)
-
-        Instantiated.new(
-          type: type,
-          methods: methods.transform_values {|method| method.subst(subst) },
-          ivar_chains: ivar_chains.transform_values {|chain| chain.subst(subst) }
-        )
-      end
-
-      def without_private(option)
-        if option
-          self.class.new(
-            name: name,
-            params: params,
-            methods: methods.reject {|_, method| method.private? },
-            supers: supers,
-            ivar_chains: ivar_chains
-          )
-        else
-          self
-        end
-      end
-
-      def without_initialize
-        self.class.new(
-          name: name,
-          params: params,
-          methods: methods.reject {|_, method| method.name == :initialize },
-          supers: supers,
-          ivar_chains: ivar_chains
-        )
-      end
-    end
-  end
-end

data/lib/steep/interface/builder.rb

@@ -1,637 +0,0 @@
-module Steep
-  module Interface
-    class Builder
-      class RecursiveDefinitionError < StandardError
-        attr_reader :chain
-
-        def initialize(type_name)
-          @chain = [type_name].compact
-          super "Recursive inheritance/mixin"
-        end
-
-        def to_s
-          super + " #{chain.join(" ~> ")}"
-        end
-      end
-
-      attr_reader :signatures
-      attr_reader :class_cache
-      attr_reader :module_cache
-      attr_reader :instance_cache
-      attr_reader :interface_cache
-
-      def initialize(signatures:)
-        @signatures = signatures
-        @class_cache = {}
-        @module_cache = {}
-        @instance_cache = {}
-        @interface_cache = {}
-      end
-
-      def absolute_type(type, current:)
-        case type
-        when AST::Types::Name::Instance
-          signature = signatures.find_class_or_module(type.name, current_module: current)
-          AST::Types::Name::Instance.new(
-            name: signature.name,
-            args: type.args.map {|arg| absolute_type(arg, current: current) },
-            location: type.location
-          )
-        when AST::Types::Name::Class
-          signature = signatures.find_class(type.name, current_module: current)
-          AST::Types::Name::Class.new(
-            name: signature.name,
-            constructor: type.constructor,
-            location: type.location
-          )
-        when AST::Types::Name::Module
-          signature = signatures.find_class_or_module(type.name, current_module: current)
-          AST::Types::Name::Module.new(
-            name: signature.name,
-            location: type.location
-          )
-        when AST::Types::Name::Interface
-          signature = signatures.find_interface(type.name, namespace: current)
-          AST::Types::Name::Interface.new(
-            name: signature.name,
-            args: type.args.map {|arg| absolute_type(arg, current: current) },
-            location: type.location
-          )
-        when AST::Types::Name::Alias
-          signature = signatures.find_alias(type.name, namespace: current)
-          AST::Types::Name::Alias.new(
-            name: signature.name,
-            args: type.args.map {|arg| absolute_type(arg, current: current) },
-            location: type.location
-          )
-        when AST::Types::Union
-          AST::Types::Union.build(
-            types: type.types.map {|ty| absolute_type(ty, current: current) },
-            location: type.location
-          )
-        when AST::Types::Intersection
-          AST::Types::Intersection.build(
-            types: type.types.map {|ty| absolute_type(ty, current: current) },
-            location: type.location
-          )
-        when AST::Types::Tuple
-          AST::Types::Tuple.new(
-            types: type.types.map {|ty| absolute_type(ty, current:current) },
-            location: type.location
-          )
-        when AST::Types::Proc
-          AST::Types::Proc.new(
-            params: type.params.map_type {|ty| absolute_type(ty, current: current) },
-            return_type: absolute_type(type.return_type, current: current),
-            location: type.location
-          )
-        when AST::Types::Record
-          AST::Types::Record.new(
-            elements: type.elements.transform_values {|ty| absolute_type(ty, current: current) },
-            location: type.location
-          )
-        else
-          type
-        end
-      end
-
-      def cache_interface(cache, key:, &block)
-        cached = cache[key]
-
-        case cached
-        when nil
-          cache[key] = key
-          cache[key] = yield
-        when key
-          raise RecursiveDefinitionError, key
-        else
-          cached
-        end
-      rescue RecursiveDefinitionError => exn
-        cache.delete key
-        raise exn
-      end
-
-      def assert_absolute_name!(name)
-        raise "Name should be absolute: #{name}" unless name.absolute?
-      end
-
-      def build_class(module_name, constructor:)
-        assert_absolute_name! module_name
-        signature = signatures.find_class(module_name, current_module: AST::Namespace.root)
-        cache_interface(class_cache, key: [signature.name, !!constructor]) do
-          class_to_interface(signature, constructor: constructor)
-        end
-      end
-
-      def build_module(module_name)
-        assert_absolute_name! module_name
-        signature = signatures.find_module(module_name, current_module: AST::Namespace.root)
-        cache_interface(module_cache, key: signature.name) do
-          module_to_interface(signature)
-        end
-      end
-
-      def build_instance(module_name)
-        assert_absolute_name! module_name
-        signature = signatures.find_class_or_module(module_name, current_module: AST::Namespace.root)
-        cache_interface(instance_cache, key: signature.name) do
-          instance_to_interface(signature)
-        end
-      end
-
-      def build_interface(interface_name)
-        signature = signatures.find_interface(interface_name)
-        cache_interface(interface_cache, key: [signature.name]) do
-          interface_to_interface(nil, signature)
-        end
-      end
-
-      def merge_mixin(interface, args, methods:, ivars:, supers:, current:)
-        supers.push(*interface.supers)
-
-        instantiated = interface.instantiate(
-          type: AST::Types::Self.new,
-          args: args,
-          instance_type: AST::Types::Instance.new,
-          module_type: AST::Types::Class.new
-        )
-
-        methods.merge!(instantiated.methods) do |_, super_method, new_method|
-          if super_method.include_in_chain?(new_method)
-            super_method
-          else
-            new_method.with_super(super_method)
-          end
-        end
-
-        merge_ivars ivars, instantiated.ivars
-      end
-
-      def add_method(type_name, method, methods:, extra_attributes: [], current:)
-        super_method = methods[method.name]
-        new_method = Method.new(
-          type_name: type_name,
-          name: method.name,
-          types: method.types.flat_map do |method_type|
-            case method_type
-            when AST::MethodType
-              [method_type_to_method_type(method_type, current: current)]
-            when AST::MethodType::Super
-              if super_method
-                super_method.types
-              else
-                Steep.logger.error "`super` specified in method type, but cannot find super method of `#{method.name}` in `#{type_name}` (#{method.location.name || "-"}:#{method.location})"
-                []
-              end
-            end
-          end,
-          super_method: super_method,
-          attributes: method.attributes + extra_attributes
-        )
-
-        methods[method.name] = if super_method&.include_in_chain?(new_method)
-                                 super_method
-                               else
-                                 new_method
-                               end
-      end
-
-      def class_to_interface(sig, constructor:)
-        module_name = sig.name
-        namespace = module_name.namespace.append(module_name.name)
-
-        supers = []
-        methods = {
-          new: Method.new(
-            type_name: Names::Module.parse(name: "__Builtin__"),
-            name: :new,
-            types: [
-              MethodType.new(type_params: [],
-                             params: Params.empty,
-                             block: nil,
-                             return_type: AST::Types::Instance.new,
-                             location: nil
-              )
-            ],
-            super_method: nil,
-            attributes: [:incompatible]
-          )
-        }
-
-        klass = build_instance(AST::Builtin::Class.module_name)
-        instantiated = klass.instantiate(
-          type: AST::Types::Self.new,
-          args: [],
-          instance_type: AST::Types::Instance.new,
-          module_type: AST::Types::Class.new
-        )
-        methods.merge!(instantiated.methods)
-
-        unless module_name == AST::Builtin::BasicObject.module_name
-          super_class_name = sig.super_class&.name&.yield_self {|name| signatures.find_class(name, current_module: namespace).name } || AST::Builtin::Object.module_name
-          class_interface = build_class(super_class_name, constructor: constructor)
-          merge_mixin(class_interface, [], methods: methods, ivars: {}, supers: supers, current: namespace)
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Include
-            member_name = signatures.find_module(member.name, current_module: namespace).name
-            build_module(member_name).yield_self do |module_interface|
-              merge_mixin(module_interface,
-                          [],
-                          methods: methods,
-                          supers: supers,
-                          ivars: {},
-                          current: namespace)
-            end
-          when AST::Signature::Members::Extend
-            member_name = signatures.find_module(member.name, current_module: namespace).name
-            build_instance(member_name).yield_self do |module_interface|
-              merge_mixin(module_interface,
-                          member.args.map {|type| absolute_type(type, current: namespace) },
-                          methods: methods,
-                          ivars: {},
-                          supers: supers,
-                          current: namespace)
-            end
-          end
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Method
-            case
-            when member.module_method?
-              add_method(module_name, member, methods: methods, current: namespace)
-            when member.instance_method? && member.name == :initialize
-              if constructor
-                methods[:new] = Method.new(
-                  type_name: module_name,
-                  name: :new,
-                  types: member.types.map do |method_type_sig|
-                    method_type = method_type_to_method_type(method_type_sig, current: namespace).with(return_type: AST::Types::Instance.new)
-                    args = (sig.params&.variables || []) + method_type.type_params
-
-                    method_type.with(
-                      type_params: args,
-                      return_type: AST::Types::Instance.new
-                    )
-                  end,
-                  super_method: nil,
-                  attributes: [:incompatible]
-                )
-              end
-            end
-          end
-        end
-
-        signatures.find_extensions(sig.name).each do |ext|
-          ext.members.each do |member|
-            case member
-            when AST::Signature::Members::Method
-              if member.module_method?
-                add_method(module_name, member, methods: methods, current: namespace)
-              end
-            end
-          end
-        end
-
-        if methods[:new]&.type_name == AST::Builtin::Class.module_name
-          new_types = [MethodType.new(type_params: [],
-                                      params: Params.empty,
-                                      block: nil,
-                                      return_type: AST::Types::Instance.new,
-                                      location: nil)]
-          methods[:new] = methods[:new].with_types(new_types)
-        end
-
-        unless constructor
-          methods.delete(:new)
-        end
-
-        Abstract.new(
-          name: module_name,
-          params: [],
-          methods: methods,
-          supers: supers,
-          ivar_chains: {}
-        )
-      end
-
-      def module_to_interface(sig)
-        module_name = sig.name
-        namespace = module_name.namespace.append(module_name.name)
-
-        supers = [sig.self_type].compact.map {|type| absolute_type(type, current: namespace) }
-        methods = {}
-        ivar_chains = {}
-
-        module_instance = build_instance(AST::Builtin::Module.module_name)
-        instantiated = module_instance.instantiate(
-          type: AST::Types::Self.new,
-          args: [],
-          instance_type: AST::Types::Instance.new,
-          module_type: AST::Types::Class.new
-        )
-        methods.merge!(instantiated.methods)
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Include
-            member_name = signatures.find_module(member.name, current_module: namespace).name
-            build_module(member_name).yield_self do |module_interface|
-              merge_mixin(module_interface,
-                          member.args.map {|type| absolute_type(type, current: namespace) },
-                          methods: methods,
-                          ivars: ivar_chains,
-                          supers: supers,
-                          current: namespace)
-            end
-          when AST::Signature::Members::Extend
-            member_name = signatures.find_module(member.name, current_module: namespace).name
-            build_instance(member_name).yield_self do |module_interface|
-              merge_mixin(module_interface,
-                          member.args.map {|type| absolute_type(type, current: namespace) },
-                          methods: methods,
-                          ivars: ivar_chains,
-                          supers: supers,
-                          current: namespace)
-
-            end
-          end
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Method
-            if member.module_method?
-              add_method(module_name, member, methods: methods, current: namespace)
-            end
-          when AST::Signature::Members::Ivar
-            merge_ivars(ivar_chains,
-                        { member.name => absolute_type(member.type, current: namespace) })
-          when AST::Signature::Members::Attr
-            merge_attribute(sig, ivar_chains, methods, module_name, member)
-          end
-        end
-
-        signatures.find_extensions(module_name).each do |ext|
-          ext.members.each do |member|
-            case member
-            when AST::Signature::Members::Method
-              if member.module_method?
-                add_method(module_name, member, methods: methods, current: namespace)
-              end
-            end
-          end
-        end
-
-        Abstract.new(
-          name: module_name,
-          params: [],
-          methods: methods,
-          supers: supers,
-          ivar_chains: ivar_chains
-        )
-      end
-
-      def instance_to_interface(sig)
-        module_name = sig.name
-        namespace = module_name.namespace.append(module_name.name)
-
-        params = sig.params&.variables || []
-        supers = []
-        methods = {}
-        ivar_chains = {}
-
-        if sig.is_a?(AST::Signature::Class)
-          unless sig.name == AST::Builtin::BasicObject.module_name
-            super_class_name = sig.super_class&.name || AST::Builtin::Object.module_name
-            if super_class_name.relative?
-              super_class_name = signatures.find_class(super_class_name, current_module: namespace).name
-            end
-            super_class_interface = build_instance(super_class_name)
-
-            supers.push(*super_class_interface.supers)
-            instantiated = super_class_interface.instantiate(
-              type: AST::Types::Self.new,
-              args: (sig.super_class&.args || []).map {|type| absolute_type(type, current: namespace) },
-              instance_type: AST::Types::Instance.new,
-              module_type: AST::Types::Class.new
-            )
-
-            methods.merge!(instantiated.methods)
-            merge_ivars(ivar_chains, instantiated.ivars)
-          end
-        end
-
-        if sig.is_a?(AST::Signature::Module)
-          if sig.self_type
-            supers << absolute_type(sig.self_type, current: namespace)
-          end
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Include
-            member_name = signatures.find_module(member.name, current_module: namespace).name
-            build_instance(member_name).yield_self do |module_interface|
-              merge_mixin(module_interface,
-                          member.args.map {|type| absolute_type(type, current: namespace) },
-                          methods: methods,
-                          ivars: ivar_chains,
-                          supers: supers,
-                          current: namespace)
-            end
-          end
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::Method
-            if member.instance_method?
-              extra_attrs = member.name == :initialize ? [:incompatible, :private] : []
-              add_method(module_name, member, methods: methods, extra_attributes: extra_attrs, current: namespace)
-            end
-          when AST::Signature::Members::Ivar
-            merge_ivars(ivar_chains,
-                        { member.name => absolute_type(member.type, current: namespace) })
-          when AST::Signature::Members::Attr
-            merge_attribute(sig, ivar_chains, methods, module_name, member, current: namespace)
-          end
-        end
-
-        sig.members.each do |member|
-          case member
-          when AST::Signature::Members::MethodAlias
-            method = methods[member.original_name]
-            if method
-              methods[member.new_name] =  Method.new(
-                type_name: module_name,
-                name: member.new_name,
-                types: method.types,
-                super_method: nil,
-                attributes: method.attributes
-              )
-            else
-              Steep.logger.error "Cannot alias find original method `#{member.original_name}` for `#{member.new_name}` in #{module_name} (#{member.location.name || '-'}:#{member.location})"
-            end
-          end
-        end
-
-        signatures.find_extensions(sig.name).each do |ext|
-          ext.members.each do |member|
-            case member
-            when AST::Signature::Members::Method
-              if member.instance_method?
-                add_method(module_name, member, methods: methods, current: namespace)
-              end
-            end
-          end
-        end
-
-        Abstract.new(
-          name: module_name,
-          params: params,
-          methods: methods,
-          supers: supers,
-          ivar_chains: ivar_chains
-        )
-      end
-
-      def merge_attribute(sig, ivar_chains, methods, type_name, member, current:)
-        if member.ivar != false
-          ivar_name = member.ivar || "@#{member.name}".to_sym
-          merge_ivars(ivar_chains,
-                      { ivar_name => absolute_type(member.type, current: current) })
-        end
-
-        reader_method = AST::Signature::Members::Method.new(
-          location: member.location,
-          name: member.name,
-          kind: :instance,
-          types: [
-            AST::MethodType.new(location: member.type.location,
-                                type_params: nil,
-                                params: nil,
-                                block: nil,
-                                return_type: member.type)
-          ],
-          attributes: []
-        )
-        add_method(type_name, reader_method, methods: methods, current: current)
-
-        if member.accessor?
-          writer_method = AST::Signature::Members::Method.new(
-            location: member.location,
-            name: "#{member.name}=".to_sym,
-            kind: :instance,
-            types: [
-              AST::MethodType.new(location: member.type.location,
-                                  type_params: nil,
-                                  params: AST::MethodType::Params::Required.new(
-                                    location: member.type.location,
-                                    type: member.type
-                                  ),
-                                  block: nil,
-                                  return_type: member.type)
-            ],
-            attributes: []
-          )
-          add_method(type_name, writer_method, methods: methods, current: current)
-        end
-      end
-
-      def merge_ivars(dest, new_vars)
-        new_vars.each do |name, new_type|
-          dest[name] = IvarChain.new(type: new_type, parent: dest[name])
-        end
-      end
-
-      def interface_to_interface(_, sig)
-        type_name = sig.name
-
-        variables = sig.params&.variables || []
-        methods = sig.methods.each.with_object({}) do |method, methods|
-          methods[method.name] = Method.new(
-            type_name: type_name,
-            name: method.name,
-            types: method.types.map do |method_type|
-              method_type_to_method_type(method_type, current: type_name.namespace)
-            end,
-            super_method: nil,
-            attributes: []
-          )
-        end
-
-        Abstract.new(
-          name: type_name,
-          params: variables,
-          methods: methods,
-          supers: [],
-          ivar_chains: {}
-        )
-      end
-
-      def method_type_to_method_type(method_type, current:)
-        type_params = method_type.type_params&.variables || []
-        params = params_to_params(method_type.params, current: current)
-        block = method_type.block && Block.new(
-          type: AST::Types::Proc.new(
-            params: params_to_params(method_type.block.params, current: current),
-            return_type: absolute_type(method_type.block.return_type, current: current),
-            location: method_type.block.location,
-            ),
-          optional: method_type.block.optional
-        )
-
-        MethodType.new(
-          type_params: type_params,
-          return_type: absolute_type(method_type.return_type, current: current),
-          block: block,
-          params: params,
-          location: method_type.location
-        )
-      end
-
-      def params_to_params(params, current:)
-        required = []
-        optional = []
-        rest = nil
-        required_keywords = {}
-        optional_keywords = {}
-        rest_keywords = nil
-
-        while params
-          case params
-          when AST::MethodType::Params::Required
-            required << absolute_type(params.type, current: current)
-          when AST::MethodType::Params::Optional
-            optional << absolute_type(params.type, current: current)
-          when AST::MethodType::Params::Rest
-            rest = absolute_type(params.type, current: current)
-          when AST::MethodType::Params::RequiredKeyword
-            required_keywords[params.name] = absolute_type(params.type, current: current)
-          when AST::MethodType::Params::OptionalKeyword
-            optional_keywords[params.name] = absolute_type(params.type, current: current)
-          when AST::MethodType::Params::RestKeyword
-            rest_keywords = absolute_type(params.type, current: current)
-            break
-          end
-          params = params.next_params
-        end
-
-        Params.new(
-          required: required,
-          optional: optional,
-          rest: rest,
-          required_keywords: required_keywords,
-          optional_keywords: optional_keywords,
-          rest_keywords: rest_keywords
-        )
-      end
-    end
-  end
-end