steep 0.11.1 → 0.12.0

data/vendor/ruby-signature/lib/ruby/signature/prototype/rb.rb

@@ -0,0 +1,441 @@
+module Ruby
+  module Signature
+    module Prototype
+      class RB
+        attr_reader :source_decls
+        attr_reader :toplevel_members
+
+        def initialize
+          @source_decls = []
+          @toplevel_members = []
+        end
+
+        def decls
+          decls = []
+
+          decls.push(*source_decls)
+
+          unless toplevel_members.empty?
+            top = AST::Declarations::Extension.new(
+              name: TypeName.new(name: :Object, namespace: Namespace.empty),
+              extension_name: :Toplevel,
+              members: toplevel_members,
+              annotations: [],
+              comment: nil,
+              location: nil,
+              type_params: AST::Declarations::ModuleTypeParams.empty
+            )
+            decls << top
+          end
+
+          decls
+        end
+
+        def parse(string)
+          comments = Ripper.lex(string).yield_self do |tokens|
+            tokens.each.with_object({}) do |token, hash|
+              if token[1] == :on_comment
+                line = token[0][0]
+                body = token[2][2..]
+
+                body = "\n" if body.empty?
+
+                comment = AST::Comment.new(string: body, location: nil)
+                if (prev_comment = hash[line - 1])
+                  hash[line - 1] = nil
+                  hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                                location: nil)
+                else
+                  hash[line] = comment
+                end
+              end
+            end
+          end
+
+          process RubyVM::AbstractSyntaxTree.parse(string), namespace: Namespace.empty, current_module: nil, comments: comments, singleton: false
+        end
+
+        def nested_name(name)
+          (current_namespace + const_to_name(name).to_namespace).to_type_name.relative!
+        end
+
+        def process(node, namespace:, current_module:, comments:, singleton:)
+          case node.type
+          when :CLASS
+            class_name, super_class, *class_body = node.children
+            kls = AST::Declarations::Class.new(
+              name: const_to_name(class_name).with_prefix(namespace).relative!,
+              super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+              type_params: AST::Declarations::ModuleTypeParams.empty,
+              members: [],
+              annotations: [],
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+
+            source_decls.push kls
+
+            each_node class_body do |child|
+              process child, namespace: kls.name.to_namespace, current_module: kls, comments: comments, singleton: false
+            end
+          when :MODULE
+            module_name, *module_body = node.children
+
+            mod = AST::Declarations::Module.new(
+              name: const_to_name(module_name).with_prefix(namespace).relative!,
+              type_params: AST::Declarations::ModuleTypeParams.empty,
+              self_type: nil,
+              members: [],
+              annotations: [],
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+
+            source_decls.push mod
+
+            each_node module_body do |child|
+              process child, namespace: mod.name.to_namespace, current_module: mod, comments: comments, singleton: false
+            end
+          when :SCLASS
+            this = node.children[0]
+            if this.type != :SELF
+              Signature.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
+            end
+
+            body = node.children[1]
+            each_child(body) do |child|
+              process child, namespace: namespace, current_module: current_module, comments: comments, singleton: true
+            end
+          when :DEFN, :DEFS
+              if node.type == :DEFN
+                def_name, def_body = node.children
+                kind = singleton ? :singleton : :instance
+              else
+                _, def_name, def_body = node.children
+                kind = :singleton
+              end
+
+              types = [
+                MethodType.new(
+                  type_params: [],
+                  type: function_type_from_body(def_body),
+                  block: block_from_body(def_body),
+                  location: nil
+                )
+              ]
+
+              member = AST::Members::MethodDefinition.new(
+                name: def_name,
+                location: nil,
+                annotations: [],
+                types: types,
+                kind: kind,
+                comment: comments[node.first_lineno - 1],
+                attributes: []
+              )
+
+              if current_module
+                current_module.members.push member
+              else
+                toplevel_members.push member
+              end
+          when :FCALL
+            if current_module
+              # Inside method definition cannot reach here.
+              args = node.children[1]&.children || []
+
+              case node.children[0]
+              when :include
+                args.each do |arg|
+                  if (name = const_to_name(arg))
+                    current_module.members << AST::Members::Include.new(
+                      name: name,
+                      args: [],
+                      annotations: [],
+                      location: nil,
+                      comment: comments[node.first_lineno - 1]
+                    )
+                  end
+                end
+              when :extend
+                args.each do |arg|
+                  if (name = const_to_name(arg))
+                    current_module.members << AST::Members::Extend.new(
+                      name: name,
+                      args: [],
+                      annotations: [],
+                      location: nil,
+                      comment: comments[node.first_lineno - 1]
+                    )
+                  end
+                end
+              when :attr_reader
+                args.each do |arg|
+                  if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                    current_module.members << AST::Members::AttrReader.new(
+                      name: arg.children[0],
+                      ivar_name: nil,
+                      type: Types::Bases::Any.new(location: nil),
+                      location: nil,
+                      comment: comments[node.first_lineno - 1],
+                      annotations: []
+                    )
+                  end
+                end
+              when :attr_accessor
+                args.each do |arg|
+                  if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                    current_module.members << AST::Members::AttrAccessor.new(
+                      name: arg.children[0],
+                      ivar_name: nil,
+                      type: Types::Bases::Any.new(location: nil),
+                      location: nil,
+                      comment: comments[node.first_lineno - 1],
+                      annotations: []
+                    )
+                  end
+                end
+              when :attr_writer
+                args.each do |arg|
+                  if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+                    current_module.members << AST::Members::AttrWriter.new(
+                      name: arg.children[0],
+                      ivar_name: nil,
+                      type: Types::Bases::Any.new(location: nil),
+                      location: nil,
+                      comment: comments[node.first_lineno - 1],
+                      annotations: []
+                    )
+                  end
+                end
+              end
+            end
+
+          when :CDECL
+            type_name = case
+                        when node.children[0].is_a?(Symbol)
+                          ns = if current_module
+                                 current_module.name.to_namespace
+                               else
+                                 Namespace.empty
+                               end
+                          TypeName.new(name: node.children[0], namespace: ns)
+                        else
+                          name = const_to_name(node.children[0])
+                          if current_module
+                            name.with_prefix current_module.name.to_namespace
+                          else
+                            name
+                          end.relative!
+                        end
+
+            source_decls << AST::Declarations::Constant.new(
+              name: type_name,
+              type: node_type(node.children.last),
+              location: nil,
+              comment: comments[node.first_lineno - 1]
+            )
+          else
+            each_child node do |child|
+              process child, namespace: namespace, current_module: current_module, comments: comments, singleton: singleton
+            end
+          end
+        end
+
+        def const_to_name(node)
+          case node&.type
+          when :CONST
+            TypeName.new(name: node.children[0], namespace: Namespace.empty)
+          when :COLON2
+            if node.children[0]
+              namespace = const_to_name(node.children[0]).to_namespace
+            else
+              namespace = Namespace.empty
+            end
+
+            TypeName.new(name: node.children[1], namespace: namespace)
+          when :COLON3
+            TypeName.new(name: node.children[0], namespace: Namespace.root)
+          end
+        end
+
+        def each_node(nodes)
+          nodes.each do |child|
+            if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+              yield child
+            end
+          end
+        end
+
+        def each_child(node, &block)
+          each_node node.children, &block
+        end
+
+        def function_type_from_body(node)
+          table_node, args_node, *_ = node.children
+
+          pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_node.children
+
+          untyped = Types::Bases::Any.new(location: nil)
+
+          fun = Types::Function.empty(untyped)
+
+          table_node.take(pre_num).each do |name|
+            fun.required_positionals << Types::Function::Param.new(name: name, type: untyped)
+          end
+
+          while opt&.type == :OPT_ARG
+            lvasgn, opt = opt.children
+            name = lvasgn.children[0]
+            fun.optional_positionals << Types::Function::Param.new(
+              name: name,
+              type: node_type(lvasgn.children[1])
+            )
+          end
+
+          if rest
+            fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest, type: untyped))
+          end
+
+          table_node.drop(fun.required_positionals.size + fun.optional_positionals.size + (fun.rest_positionals ? 1 : 0)).take(post_num).each do |name|
+            fun.trailing_positionals << Types::Function::Param.new(name: name, type: untyped)
+          end
+
+          while kw
+            lvasgn, kw = kw.children
+            name, value = lvasgn.children
+
+            case value
+            when nil, :NODE_SPECIAL_REQUIRED_KEYWORD
+              fun.required_keywords[name] = Types::Function::Param.new(name: name, type: untyped)
+            when RubyVM::AbstractSyntaxTree::Node
+              fun.optional_keywords[name] = Types::Function::Param.new(name: name, type: node_type(value))
+            else
+              raise "Unexpected keyword arg value: #{value}"
+            end
+          end
+
+          if kwrest && kwrest.children.any?
+            fun = fun.update(rest_keywords: Types::Function::Param.new(name: kwrest.children[0], type: untyped))
+          end
+
+          fun
+        end
+
+        def block_from_body(node)
+          _, args_node, body_node = node.children
+
+          _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_node.children
+
+          untyped = Types::Bases::Any.new(location: nil)
+
+          method_block = nil
+
+          if block
+            method_block = MethodType::Block.new(
+              required: true,
+              type: Types::Function.empty(untyped)
+            )
+          end
+
+          if body_node
+            if (yields = any_node?(body_node) {|n| n.type == :YIELD })
+              method_block = MethodType::Block.new(
+                required: true,
+                type: Types::Function.empty(untyped)
+              )
+
+              yields.each do |yield_node|
+                array_content = yield_node.children[0]&.children&.compact || []
+
+                positionals, keywords = if keyword_hash?(array_content.last)
+                                          [array_content.take(array_content.size - 1), array_content.last]
+                                        else
+                                          [array_content, nil]
+                                        end
+
+                if (diff = positionals.size - method_block.type.required_positionals.size) > 0
+                  diff.times do
+                    method_block.type.required_positionals << Types::Function::Param.new(
+                      type: untyped,
+                      name: nil
+                    )
+                  end
+                end
+
+                if keywords
+                  keywords.children[0].children.each_slice(2) do |key_node, value_node|
+                    if key_node
+                      key = key_node.children[0]
+                      method_block.type.required_keywords[key] ||=
+                        Types::Function::Param.new(
+                          type: untyped,
+                          name: nil
+                        )
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          method_block
+        end
+
+        def keyword_hash?(node)
+          if node
+            if node.type == :HASH
+              node.children[0].children.compact.each_slice(2).all? {|key, _|
+                key.type == :LIT && key.children[0].is_a?(Symbol)
+              }
+            end
+          end
+        end
+
+        def any_node?(node, nodes: [], &block)
+          if yield(node)
+            nodes << node
+          end
+
+          each_child node do |child|
+            any_node? child, nodes: nodes, &block
+          end
+
+          nodes.empty? ? nil : nodes
+        end
+
+        def node_type(node, default: Types::Bases::Any.new(location: nil))
+          case node.type
+          when :LIT
+            case node.children[0]
+            when Symbol
+              BuiltinNames::Symbol.instance_type
+            when Integer
+              BuiltinNames::Integer.instance_type
+            when Float
+              BuiltinNames::Float.instance_type
+            else
+              default
+            end
+          when :STR, :DSTR
+            BuiltinNames::String.instance_type
+          when :NIL
+            # This type is technical non-sense, but may help practically.
+            Types::Optional.new(
+              type: Types::Bases::Any.new(location: nil),
+              location: nil
+            )
+          when :TRUE, :FALSE
+            Types::Bases::Bool.new(location: nil)
+          when :ARRAY, :LIST
+            BuiltinNames::Array.instance_type(default)
+          when :HASH
+            BuiltinNames::Hash.instance_type(default, default)
+          else
+            default
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature/prototype/rbi.rb

@@ -0,0 +1,579 @@
+module Ruby
+  module Signature
+    module Prototype
+      class RBI
+        attr_reader :decls
+        attr_reader :modules
+        attr_reader :last_sig
+
+        def initialize
+          @decls = []
+
+          @modules = []
+        end
+
+        def parse(string)
+          comments = Ripper.lex(string).yield_self do |tokens|
+            tokens.each.with_object({}) do |token, hash|
+              if token[1] == :on_comment
+                line = token[0][0]
+                body = token[2][2..]
+
+                body = "\n" if body.empty?
+
+                comment = AST::Comment.new(string: body, location: nil)
+                if (prev_comment = hash[line - 1])
+                  hash[line - 1] = nil
+                  hash[line] = AST::Comment.new(string: prev_comment.string + comment.string,
+                                                location: nil)
+                else
+                  hash[line] = comment
+                end
+              end
+            end
+          end
+          process RubyVM::AbstractSyntaxTree.parse(string), comments: comments
+        end
+
+        def nested_name(name)
+          (current_namespace + const_to_name(name).to_namespace).to_type_name.relative!
+        end
+
+        def current_namespace
+          modules.inject(Namespace.empty) do |parent, mod|
+            parent + mod.name.to_namespace
+          end
+        end
+
+        def push_class(name, super_class, comment:)
+          modules.push AST::Declarations::Class.new(
+            name: nested_name(name),
+            super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: comment
+          )
+
+          decls << modules.last
+
+          yield
+        ensure
+          modules.pop
+        end
+
+        def push_module(name, comment:)
+          modules.push AST::Declarations::Module.new(
+            name: nested_name(name),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            members: [],
+            annotations: [],
+            location: nil,
+            self_type: nil,
+            comment: comment
+          )
+
+          decls << modules.last
+
+          yield
+        ensure
+          modules.pop
+        end
+
+        def current_module
+          modules.last
+        end
+
+        def push_sig(node)
+          @last_sig ||= []
+          @last_sig << node
+        end
+
+        def pop_sig
+          @last_sig.tap do
+            @last_sig = nil
+          end
+        end
+
+        def join_comments(nodes, comments)
+          cs = nodes.map {|node| comments[node.first_lineno - 1] }.compact
+          AST::Comment.new(string: cs.map(&:string).join("\n"), location: nil)
+        end
+
+        def process(node, outer: [], comments:)
+          case node.type
+          when :CLASS
+            comment = comments[node.first_lineno - 1]
+            push_class node.children[0], node.children[1], comment: comment do
+              process node.children[2], outer: outer + [node], comments: comments
+            end
+          when :MODULE
+            comment = comments[node.first_lineno - 1]
+            push_module node.children[0], comment: comment do
+              process node.children[1], outer: outer + [node], comments: comments
+            end
+          when :FCALL
+            case node.children[0]
+            when :include
+              each_arg node.children[1] do |arg|
+                if arg.type == :CONST || arg.type == :COLON2 || arg.type == :COLON3
+                  name = const_to_name(arg)
+                  include_member = AST::Members::Include.new(
+                    name: name,
+                    args: [],
+                    annotations: [],
+                    location: nil,
+                    comment: nil
+                  )
+                  current_module.members << include_member
+                end
+              end
+            when :extend
+              each_arg node.children[1] do |arg|
+                if arg.type == :CONST || arg.type == :COLON2
+                  name = const_to_name(arg)
+                  unless name.to_s == "T::Generic" || name.to_s == "T::Sig"
+                    member = AST::Members::Extend.new(
+                      name: name,
+                      args: [],
+                      annotations: [],
+                      location: nil,
+                      comment: nil
+                    )
+                    current_module.members << member
+                  end
+                end
+              end
+            when :sig
+              push_sig outer.last.children.last.children.last
+            when :alias_method
+              new, old = each_arg(node.children[1]).map {|x| x.children[0] }
+              current_module.members << AST::Members::Alias.new(
+                new_name: new,
+                old_name: old,
+                location: nil,
+                annotations: [],
+                kind: :instance,
+                comment: nil
+              )
+            end
+          when :DEFS
+            sigs = pop_sig
+
+            if sigs
+              comment = join_comments(sigs, comments)
+
+              args = node.children[2]
+              types = sigs.map {|sig| method_type(args, sig, variables: current_module.type_params) }
+
+              current_module.members << AST::Members::MethodDefinition.new(
+                name: node.children[1],
+                location: nil,
+                annotations: [],
+                types: types,
+                kind: :singleton,
+                comment: comment,
+                attributes: []
+              )
+            end
+
+          when :DEFN
+            sigs = pop_sig
+
+            if sigs
+              comment = join_comments(sigs, comments)
+
+              args = node.children[1]
+              types = sigs.map {|sig| method_type(args, sig, variables: current_module.type_params) }
+
+              current_module.members << AST::Members::MethodDefinition.new(
+                name: node.children[0],
+                location: nil,
+                annotations: [],
+                types: types,
+                kind: :instance,
+                comment: comment,
+                attributes: []
+              )
+            end
+
+          when :CDECL
+            if (send = node.children.last) && send.type == :FCALL && send.children[0] == :type_member
+              unless each_arg(send.children[1]).any? {|node|
+                node.type == :HASH &&
+                  each_arg(node.children[0]).each_slice(2).any? {|a, _| a.type == :LIT && a.children[0] == :fixed }
+              }
+                if (a0 = each_arg(send.children[1]).to_a[0])&.type == :LIT
+                  variance = case a0.children[0]
+                             when :out
+                               :covariant
+                             when :in
+                               :contravariant
+                             end
+                end
+
+                current_module.type_params.add(
+                  AST::Declarations::ModuleTypeParams::TypeParam.new(name: node.children[0],
+                                                                     variance: variance || :invariant,
+                                                                     skip_validation: false))
+              end
+            else
+              name = node.children[0].yield_self do |n|
+                if n.is_a?(Symbol)
+                  TypeName.new(namespace: current_namespace, name: n)
+                else
+                  const_to_name(n)
+                end
+              end
+              value_node = node.children.last
+              type = if value_node.type == :CALL && value_node.children[1] == :let
+                       type_node = each_arg(value_node.children[2]).to_a[1]
+                       type_of type_node, variables: current_module&.type_params || []
+                     else
+                       Types::Bases::Any.new(location: nil)
+                     end
+              decls << AST::Declarations::Constant.new(
+                name: name,
+                type: type,
+                location: nil,
+                comment: nil
+              )
+            end
+          when :ALIAS
+            current_module.members << AST::Members::Alias.new(
+              new_name: node.children[0].children[0],
+              old_name: node.children[1].children[0],
+              location: nil,
+              annotations: [],
+              kind: :instance,
+              comment: nil
+            )
+          else
+            each_child node do |child|
+              process child, outer: outer + [node], comments: comments
+            end
+          end
+        end
+
+        def method_type(args_node, type_node, variables:)
+          if type_node
+            if type_node.type == :CALL
+              method_type = method_type(args_node, type_node.children[0], variables: variables)
+            else
+              method_type = MethodType.new(
+                type: Types::Function.empty(Types::Bases::Any.new(location: nil)),
+                block: nil,
+                location: nil,
+                type_params: []
+              )
+            end
+
+            name, args = case type_node.type
+                         when :CALL
+                           [
+                             type_node.children[1],
+                             type_node.children[2]
+                           ]
+                         when :FCALL, :VCALL
+                           [
+                             type_node.children[0],
+                             type_node.children[1]
+                           ]
+                         end
+
+            case name
+            when :returns
+              return_type = each_arg(args).to_a[0]
+              method_type.update(type: method_type.type.with_return_type(type_of(return_type, variables: variables)))
+            when :params
+              if args_node
+                parse_params(args_node, args, method_type, variables: variables)
+              else
+                vars = (node_to_hash(each_arg(args).to_a[0]) || {}).transform_values {|value| type_of(value, variables: variables) }
+
+                required_positionals = vars.map do |name, type|
+                  Types::Function::Param.new(name: name, type: type)
+                end
+
+                method_type.update(type: method_type.type.update(required_positionals: required_positionals))
+              end
+            when :type_parameters
+              type_params = []
+
+              each_arg args do |node|
+                if node.type == :LIT
+                  type_params << node.children[0]
+                end
+              end
+
+              method_type.update(type_params: type_params)
+            when :void
+              method_type.update(type: method_type.type.with_return_type(Types::Bases::Void.new(location: nil)))
+            when :proc
+              method_type
+            else
+              method_type
+            end
+          end
+        end
+
+        def parse_params(args_node, args, method_type, variables:)
+          vars = (node_to_hash(each_arg(args).to_a[0]) || {}).transform_values {|value| type_of(value, variables: variables) }
+
+          required_positionals = []
+          optional_positionals = []
+          rest_positionals = nil
+          trailing_positionals = []
+          required_keywords = {}
+          optional_keywords = {}
+          rest_keywords = nil
+
+          var_names = args_node.children[0]
+          pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, block = args_node.children[1].children
+
+          pre_num.times.each do |i|
+            name = var_names[i]
+            type = vars[name] || Types::Bases::Any.new(location: nil)
+            required_positionals << Types::Function::Param.new(type: type, name: name)
+          end
+
+          index = pre_num
+          while opt
+            name = var_names[index]
+            if (type = vars[name])
+              optional_positionals << Types::Function::Param.new(type: type, name: name)
+            end
+            index += 1
+            opt = opt.children[1]
+          end
+
+          if rest
+            name = var_names[index]
+            if (type = vars[name])
+              rest_positionals = Types::Function::Param.new(type: type, name: name)
+            end
+            index += 1
+          end
+
+          post_num.times do |i|
+            name = var_names[i+index]
+            if (type = vars[name])
+              trailing_positionals << Types::Function::Param.new(type: type, name: name)
+            end
+            index += 1
+          end
+
+          while kw
+            name, value = kw.children[0].children
+            if (type = vars[name])
+              if value
+                optional_keywords[name] = Types::Function::Param.new(type: type, name: name)
+              else
+                required_keywords[name] = Types::Function::Param.new(type: type, name: name)
+              end
+            end
+
+            kw = kw.children[1]
+          end
+
+          if kwrest
+            name = kwrest.children[0]
+            if (type = vars[name])
+              rest_keywords = Types::Function::Param.new(type: type, name: name)
+            end
+          end
+
+          method_block = nil
+          if block
+            if (type = vars[block])
+              if type.is_a?(Types::Proc)
+                method_block = MethodType::Block.new(required: true, type: type.type)
+              else
+                STDERR.puts "Unexpected block type: #{type}"
+                PP.pp args_node, STDERR
+                method_block = MethodType::Block.new(
+                  required: true,
+                  type: Types::Function.empty(Types::Bases::Any.new(location: nil))
+                )
+              end
+            end
+          end
+
+          method_type.update(
+            type: method_type.type.update(
+              required_positionals: required_positionals,
+              optional_positionals: optional_positionals,
+              rest_positionals: rest_positionals,
+              trailing_positionals: trailing_positionals,
+              required_keywords: required_keywords,
+              optional_keywords: optional_keywords,
+              rest_keywords: rest_keywords
+            ),
+            block: method_block
+          )
+        end
+
+        def type_of(type_node, variables:)
+          type = type_of0(type_node, variables: variables)
+
+          case
+          when type.is_a?(Types::ClassInstance) && type.name.name == BuiltinNames::BasicObject.name.name
+            Types::Bases::Any.new(location: nil)
+          when type.is_a?(Types::ClassInstance) && type.name.to_s == "T::Boolean"
+            Types::Bases::Bool.new(location: nil)
+          else
+            type
+          end
+        end
+
+        def type_of0(type_node, variables:)
+          case
+          when type_node.type == :CONST
+            if variables.each.include?(type_node.children[0])
+              Types::Variable.new(name: type_node.children[0], location: nil)
+            else
+              Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
+            end
+          when type_node.type == :COLON2
+            Types::ClassInstance.new(name: const_to_name(type_node), args: [], location: nil)
+          when call_node?(type_node, name: :[], receiver: -> (_) { true })
+            type = type_of(type_node.children[0], variables: variables)
+            each_arg(type_node.children[2]) do |arg|
+              type.args << type_of(arg, variables: variables)
+            end
+
+            type
+          when call_node?(type_node, name: :type_parameter)
+            name = each_arg(type_node.children[2]).to_a[0].children[0]
+            Types::Variable.new(name: name, location: nil)
+          when call_node?(type_node, name: :any)
+            types = each_arg(type_node.children[2]).to_a.map {|node| type_of(node, variables: variables) }
+            Types::Union.new(types: types, location: nil)
+          when call_node?(type_node, name: :all)
+            types = each_arg(type_node.children[2]).to_a.map {|node| type_of(node, variables: variables) }
+            Types::Intersection.new(types: types, location: nil)
+          when call_node?(type_node, name: :untyped)
+            Types::Bases::Any.new(location: nil)
+          when call_node?(type_node, name: :nilable)
+            type = type_of each_arg(type_node.children[2]).to_a[0], variables: variables
+            Types::Optional.new(type: type, location: nil)
+          when call_node?(type_node, name: :self_type)
+            Types::Bases::Self.new(location: nil)
+          when call_node?(type_node, name: :noreturn)
+            Types::Bases::Bottom.new(location: nil)
+          when call_node?(type_node, name: :class_of)
+            type = type_of each_arg(type_node.children[2]).to_a[0], variables: variables
+            case type
+            when Types::ClassInstance
+              Types::ClassSingleton.new(name: type.name, location: nil)
+            else
+              STDERR.puts "Unexpected type for `class_of`: #{type}"
+              Types::Bases::Any.new(location: nil)
+            end
+          when type_node.type == :ARRAY, type_node.type == :LIST
+            types = each_arg(type_node).map {|node| type_of(node, variables: variables) }
+            Types::Tuple.new(types: types, location: nil)
+          else
+            if proc_type?(type_node)
+              Types::Proc.new(type: method_type(nil, type_node, variables: variables).type, location: nil)
+            else
+              STDERR.puts "Unexpected type_node:"
+              PP.pp type_node, STDERR
+              Types::Bases::Any.new(location: nil)
+            end
+          end
+        end
+
+        def proc_type?(type_node)
+          if call_node?(type_node, name: :proc)
+            true
+          else
+            type_node.type == :CALL && proc_type?(type_node.children[0])
+          end
+
+        end
+
+        def call_node?(node, name:, receiver: -> (node) { node.type == :CONST && node.children[0] == :T }, args: -> (node) { true })
+          node.type == :CALL && receiver[node.children[0]] && name == node.children[1] && args[node.children[2]]
+        end
+
+        def const_to_name(node)
+          case node.type
+          when :CONST
+            TypeName.new(name: node.children[0], namespace: Namespace.empty)
+          when :COLON2
+            if node.children[0]
+              if node.children[0].type == :COLON3
+                namespace = Namespace.root
+              else
+                namespace = const_to_name(node.children[0]).to_namespace
+              end
+            else
+              namespace = Namespace.empty
+            end
+
+            type_name = TypeName.new(name: node.children[1], namespace: namespace)
+
+            case type_name.to_s
+            when "T::Array"
+              BuiltinNames::Array.name
+            when "T::Hash"
+              BuiltinNames::Hash.name
+            when "T::Range"
+              BuiltinNames::Range.name
+            when "T::Enumerator"
+              BuiltinNames::Enumerator.name
+            when "T::Enumerable"
+              BuiltinNames::Enumerable.name
+            when "T::Set"
+              BuiltinNames::Set.name
+            else
+              type_name
+            end
+          when :COLON3
+            TypeName.new(name: node.children[0], namespace: Namespace.root)
+          else
+            raise "Unexpected node type: #{node.type}"
+          end
+        end
+
+        def each_arg(array, &block)
+          if block_given?
+            if array&.type == :ARRAY || array&.type == :LIST
+              array.children.each do |arg|
+                if arg
+                  yield arg
+                end
+              end
+            end
+          else
+            enum_for :each_arg, array
+          end
+        end
+
+        def each_child(node)
+          node.children.each do |child|
+            if child.is_a?(RubyVM::AbstractSyntaxTree::Node)
+              yield child
+            end
+          end
+        end
+
+        def node_to_hash(node)
+          if node&.type == :HASH
+            hash = {}
+
+            each_arg(node.children[0]).each_slice(2) do |var, type|
+              if var.type == :LIT && type
+                hash[var.children[0]] = type
+              end
+            end
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end