steep 0.11.1 → 0.12.0

data/lib/steep/annotation_parser.rb

@@ -0,0 +1,167 @@
+module Steep
+  class AnnotationParser
+    VAR_NAME = /[a-z][A-Za-z0-9_]*/
+    METHOD_NAME = Regexp.union(
+      /[A-Za-z][A-Za-z0-9_]*[?!]?/
+    )
+    CONST_NAME = Regexp.union(
+      /(::)?([A-Z][A-Za-z0-9_]*::)*[A-Z][A-Za-z0-9_]*/
+    )
+    DYNAMIC_NAME = /(self\??\.)?#{METHOD_NAME}/
+    IVAR_NAME = /@[^:\s]+/
+
+    attr_reader :factory
+
+    def initialize(factory:)
+      @factory = factory
+    end
+
+    class SyntaxError < StandardError
+      attr_reader :source
+      attr_reader :location
+
+      def initialize(source:, location:, exn: nil)
+        @source = source
+        @location = location
+        super "Syntax error on annotation: `#{source}`, cause=#{exn.inspect}"
+      end
+    end
+
+    TYPE = /(?<type>.*)/
+    COLON = /\s*:\s*/
+
+    PARAM = /[A-Z][A-Za-z0-9_]*/
+    TYPE_PARAMS = /(\[(?<params>#{PARAM}(,\s*#{PARAM})*)\])?/
+
+    def parse_type(string)
+      factory.type(Ruby::Signature::Parser.parse_type(string))
+    end
+
+    # @type ${keyword} ${name}: ${type}
+    # Example: @type const Foo::Bar: String
+    #          @type var xyzzy: Array[String]
+    def keyword_subject_type(keyword, name)
+      /@type\s+#{keyword}\s+(?<name>#{name})#{COLON}#{TYPE}/
+    end
+
+    # @type ${keyword}: ${type}
+    # Example: @type break: String
+    #          @type self: Foo
+    def keyword_and_type(keyword)
+      /@type\s+#{keyword}#{COLON}#{TYPE}/
+    end
+
+    def parse(src, location:)
+      case src
+      when keyword_subject_type("var", VAR_NAME)
+        Regexp.last_match.yield_self do |match|
+          name = match[:name]
+          type = match[:type]
+
+          AST::Annotation::VarType.new(name: name.to_sym,
+                                       type: parse_type(type),
+                                       location: location)
+        end
+
+      when keyword_subject_type("method", METHOD_NAME)
+        Regexp.last_match.yield_self do |match|
+          name = match[:name]
+          type = match[:type]
+
+          method_type = factory.method_type(Ruby::Signature::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
+
+          AST::Annotation::MethodType.new(name: name.to_sym,
+                                          type: method_type,
+                                          location: location)
+        end
+
+      when keyword_subject_type("const", CONST_NAME)
+        Regexp.last_match.yield_self do |match|
+          name = match[:name]
+          type = parse_type(match[:type])
+
+          AST::Annotation::ConstType.new(name: Names::Module.parse(name),
+                                         type: type,
+                                         location: location)
+        end
+
+      when keyword_subject_type("ivar", IVAR_NAME)
+        Regexp.last_match.yield_self do |match|
+          name = match[:name]
+          type = parse_type(match[:type])
+
+          AST::Annotation::IvarType.new(name: name.to_sym,
+                                         type: type,
+                                         location: location)
+        end
+
+      when keyword_and_type("return")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::ReturnType.new(type: type, location: location)
+        end
+
+      when keyword_and_type("block")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::BlockType.new(type: type, location: location)
+        end
+
+      when keyword_and_type("self")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::SelfType.new(type: type, location: location)
+        end
+
+      when keyword_and_type("instance")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::InstanceType.new(type: type, location: location)
+        end
+
+      when keyword_and_type("module")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::ModuleType.new(type: type, location: location)
+        end
+
+      when keyword_and_type("break")
+        Regexp.last_match.yield_self do |match|
+          type = parse_type(match[:type])
+          AST::Annotation::BreakType.new(type: type, location: location)
+        end
+
+      when /@dynamic\s+(?<names>(#{DYNAMIC_NAME}\s*,\s*)*#{DYNAMIC_NAME})/
+        Regexp.last_match.yield_self do |match|
+          names = match[:names].split(/\s*,\s*/)
+
+          AST::Annotation::Dynamic.new(
+            names: names.map {|name|
+              case name
+              when /^self\./
+                AST::Annotation::Dynamic::Name.new(name: name[5..].to_sym, kind: :module)
+              when /^self\?\./
+                AST::Annotation::Dynamic::Name.new(name: name[6..].to_sym, kind: :module_instance)
+              else
+                AST::Annotation::Dynamic::Name.new(name: name.to_sym, kind: :instance)
+              end
+            },
+            location: location
+          )
+        end
+
+      when /@implements\s+(?<name>#{CONST_NAME})#{TYPE_PARAMS}$/
+        Regexp.last_match.yield_self do |match|
+          type_name = Names::Module.parse(match[:name])
+          params = match[:params]&.yield_self {|params| params.split(/,/).map {|param| param.strip.to_sym } } || []
+
+          name = AST::Annotation::Implements::Module.new(name: type_name, args: params)
+          AST::Annotation::Implements.new(name: name, location: location)
+        end
+      end
+
+    rescue Ruby::Signature::Parser::SyntaxError, Ruby::Signature::Parser::SemanticsError => exn
+      raise SyntaxError.new(source: src, location: location, exn: exn)
+    end
+  end
+end

data/lib/steep/ast/annotation/collection.rb

@@ -3,7 +3,7 @@ module Steep
     module Annotation
       class Collection
         attr_reader :annotations
-        attr_reader :builder
+        attr_reader :factory
         attr_reader :current_module
 
         attr_reader :var_type_annotations
@@ -19,9 +19,9 @@ module Steep
         attr_reader :dynamic_annotations
         attr_reader :break_type_annotation
 
-        def initialize(annotations:, builder:, current_module:)
+        def initialize(annotations:, factory:, current_module:)
           @annotations = annotations
-          @builder = builder
+          @factory = factory
           @current_module = current_module
 
           @var_type_annotations = {}
@@ -64,7 +64,7 @@ module Steep
 
         def absolute_type(type)
           if type
-            builder.absolute_type(type, current: current_module)
+            factory.absolute_type(type, namespace: current_module)
           end
         end
 
@@ -81,7 +81,7 @@ module Steep
 
         def method_type(name)
           if (a = method_type_annotations[name])
-            builder.method_type_to_method_type(a.type, current: current_module)
+            a.type.map_type {|type| absolute_type(type) }
           end
         end
 
@@ -140,7 +140,7 @@ module Steep
         end
 
         def merge_block_annotations(annotations)
-          if annotations.current_module != current_module || annotations.builder != builder
+          if annotations.current_module != current_module || annotations.factory != factory
             raise "Cannot merge another annotation: self=#{self}, other=#{annotations}"
           end
 
@@ -149,7 +149,7 @@ module Steep
           end
 
           self.class.new(annotations: retained_annotations + annotations.annotations,
-                         builder: builder,
+                         factory: factory,
                          current_module: current_module)
         end
 

data/lib/steep/ast/types.rb

@@ -0,0 +1,60 @@
+module Steep
+  module AST
+    module Types
+      class Masked
+        attr_reader :location
+        attr_reader :type
+        attr_reader :mask
+
+        def initialize(type:, mask:, location:)
+          @type = type
+          @mask = mask
+          @location = location
+        end
+
+        def ==(other)
+          other.is_a?(Masked) &&
+            other.type == type &&
+            other.mask == mask
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ type.hash ^ mask.hash
+        end
+
+        def to_json(*a)
+          { class: :masked,
+            type: type,
+            mask: mask,
+            location: location }.to_json(*a)
+        end
+
+        def to_s(level = 0)
+          "masked(#{type}|#{mask})"
+        end
+
+        def free_variables(set = Set.new)
+          type.free_variables(set)
+          mask.free_variables(set)
+        end
+
+        def each_type(&block)
+          if block_given?
+            yield type
+            yield mask
+          else
+            enum_for :each_type
+          end
+        end
+
+        def sub(s)
+          self.class.new(type: type.sub(s),
+                         mask: mask.sub(s),
+                         location: location)
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/any.rb

@@ -23,7 +23,7 @@ module Steep
         end
 
         def to_s
-          "any"
+          "untyped"
         end
 
         def free_variables

data/lib/steep/ast/types/factory.rb

@@ -0,0 +1,535 @@
+module Steep
+  module AST
+    module Types
+      class Factory
+        attr_reader :definition_builder
+
+        def initialize(builder:)
+          @definition_builder = builder
+        end
+
+        def type(type)
+          case type
+          when Ruby::Signature::Types::Bases::Any
+            Any.new(location: nil)
+          when Ruby::Signature::Types::Bases::Class
+            Class.new(location: nil)
+          when Ruby::Signature::Types::Bases::Instance
+            Instance.new(location: nil)
+          when Ruby::Signature::Types::Bases::Self
+            Self.new(location: nil)
+          when Ruby::Signature::Types::Bases::Top
+            Top.new(location: nil)
+          when Ruby::Signature::Types::Bases::Bottom
+            Bot.new(location: nil)
+          when Ruby::Signature::Types::Bases::Bool
+            Boolean.new(location: nil)
+          when Ruby::Signature::Types::Bases::Void
+            Void.new(location: nil)
+          when Ruby::Signature::Types::Bases::Nil
+            Nil.new(location: nil)
+          when Ruby::Signature::Types::Variable
+            Var.new(name: type.name, location: nil)
+          when Ruby::Signature::Types::ClassSingleton
+            type_name = type_name(type.name)
+            Name::Class.new(name: type_name, location: nil, constructor: nil)
+          when Ruby::Signature::Types::ClassInstance
+            type_name = type_name(type.name)
+            args = type.args.map {|arg| type(arg) }
+            Name::Instance.new(name: type_name, args: args, location: nil)
+          when Ruby::Signature::Types::Interface
+            type_name = type_name(type.name)
+            args = type.args.map {|arg| type(arg) }
+            Name::Interface.new(name: type_name, args: args, location: nil)
+          when Ruby::Signature::Types::Alias
+            type_name = type_name(type.name)
+            Name::Alias.new(name: type_name, args: [], location: nil)
+          when Ruby::Signature::Types::Union
+            Union.build(types: type.types.map {|ty| type(ty) }, location: nil)
+          when Ruby::Signature::Types::Intersection
+            Intersection.build(types: type.types.map {|ty| type(ty) }, location: nil)
+          when Ruby::Signature::Types::Optional
+            Union.build(types: [type(type.type), Nil.new(location: nil)], location: nil)
+          when Ruby::Signature::Types::Literal
+            Literal.new(value: type.literal, location: nil)
+          when Ruby::Signature::Types::Tuple
+            Tuple.new(types: type.types.map {|ty| type(ty) }, location: nil)
+          when Ruby::Signature::Types::Record
+            elements = type.fields.each.with_object({}) do |(key, value), hash|
+              hash[key] = type(value)
+            end
+            Record.new(elements: elements, location: nil)
+          when Ruby::Signature::Types::Proc
+            params = params(type.type)
+            return_type = type(type.type.return_type)
+            Proc.new(params: params, return_type: return_type, location: nil)
+          else
+            raise "Unexpected type given: #{type}"
+          end
+        end
+
+        def type_1(type)
+          case type
+          when Any
+            Ruby::Signature::Types::Bases::Any.new(location: nil)
+          when Class
+            Ruby::Signature::Types::Bases::Class.new(location: nil)
+          when Instance
+            Ruby::Signature::Types::Bases::Instance.new(location: nil)
+          when Self
+            Ruby::Signature::Types::Bases::Self.new(location: nil)
+          when Top
+            Ruby::Signature::Types::Bases::Top.new(location: nil)
+          when Bot
+            Ruby::Signature::Types::Bases::Bottom.new(location: nil)
+          when Boolean
+            Ruby::Signature::Types::Bases::Bool.new(location: nil)
+          when Void
+            Ruby::Signature::Types::Bases::Void.new(location: nil)
+          when Nil
+            Ruby::Signature::Types::Bases::Nil.new(location: nil)
+          when Var
+            Ruby::Signature::Types::Variable.new(name: type.name, location: nil)
+          when Name::Class, Name::Module
+            Ruby::Signature::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
+          when Name::Instance
+            Ruby::Signature::Types::ClassInstance.new(
+              name: type_name_1(type.name),
+              args: type.args.map {|arg| type_1(arg) },
+              location: nil
+            )
+          when Name::Interface
+            Ruby::Signature::Types::Interface.new(
+              name: type_name_1(type.name),
+              args: type.args.map {|arg| type_1(arg) },
+              location: nil
+            )
+          when Name::Alias
+            type.args.empty? or raise "alias type with args is not supported"
+            Ruby::Signature::Types::Alias.new(name: type_name_1(type.name), location: nil)
+          when Union
+            Ruby::Signature::Types::Union.new(
+              types: type.types.map {|ty| type_1(ty) },
+              location: nil
+            )
+          when Intersection
+            Ruby::Signature::Types::Intersection.new(
+              types: type.types.map {|ty| type_1(ty) },
+              location: nil
+            )
+          when Literal
+            Ruby::Signature::Types::Literal.new(literal: type.value, location: nil)
+          when Tuple
+            Ruby::Signature::Types::Tuple.new(
+              types: type.types.map {|ty| type_1(ty) },
+              location: nil
+            )
+          when Record
+            fields = type.elements.each.with_object({}) do |(key, value), hash|
+              hash[key] = type_1(value)
+            end
+            Ruby::Signature::Types::Record.new(fields: fields, location: nil)
+          when Proc
+            Ruby::Signature::Types::Proc.new(
+              type: function_1(type.params, type.return_type),
+              location: nil
+            )
+          else
+            raise "Unexpected type given: #{type} (#{type.class})"
+          end
+        end
+
+        def type_name(name)
+          case
+          when name.class?
+            Names::Module.new(name: name.name, namespace: namespace(name.namespace), location: nil)
+          when name.interface?
+            Names::Interface.new(name: name.name, namespace: namespace(name.namespace), location: nil)
+          when name.alias?
+            Names::Alias.new(name: name.name, namespace: namespace(name.namespace), location: nil)
+          end
+        end
+
+        def type_name_1(name)
+          Ruby::Signature::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
+        end
+
+        def namespace(namespace)
+          Namespace.parse(namespace.to_s)
+        end
+
+        def namespace_1(namespace)
+          Ruby::Signature::Namespace.parse(namespace.to_s)
+        end
+
+        def function_1(params, return_type)
+          Ruby::Signature::Types::Function.new(
+            required_positionals: params.required.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_positionals: params.optional.map {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_positionals: params.rest&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            trailing_positionals: [],
+            required_keywords: params.required_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            optional_keywords: params.optional_keywords.transform_values {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            rest_keywords: params.rest_keywords&.yield_self {|type| Ruby::Signature::Types::Function::Param.new(name: nil, type: type_1(type)) },
+            return_type: type_1(return_type)
+          )
+        end
+
+        def params(type)
+          Interface::Params.new(
+            required: type.required_positionals.map {|param| type(param.type) },
+            optional: type.optional_positionals.map {|param| type(param.type) },
+            rest: type.rest_positionals&.yield_self {|param| type(param.type) },
+            required_keywords: type.required_keywords.transform_values {|param| type(param.type) },
+            optional_keywords: type.optional_keywords.transform_values {|param| type(param.type) },
+            rest_keywords: type.rest_keywords&.yield_self {|param| type(param.type) }
+          )
+        end
+
+        def method_type(method_type, self_type:)
+          case method_type
+          when Ruby::Signature::MethodType
+            fvs = self_type.free_variables()
+
+            type_params = []
+            alpha_vars = []
+            alpha_types = []
+
+            method_type.type_params.map do |name|
+              if fvs.include?(name)
+                type = Types::Var.fresh(name)
+                alpha_vars << name
+                alpha_types << type
+                type_params << type.name
+              else
+                type_params << name
+              end
+            end
+            subst = Interface::Substitution.build(alpha_vars, alpha_types)
+
+            type = Interface::MethodType.new(
+              type_params: type_params,
+              return_type: type(method_type.type.return_type).subst(subst),
+              params: params(method_type.type).subst(subst),
+              location: nil,
+              block: method_type.block&.yield_self do |block|
+                Interface::Block.new(
+                  optional: !block.required,
+                  type: Proc.new(params: params(block.type).subst(subst),
+                                 return_type: type(block.type.return_type).subst(subst), location: nil)
+                )
+              end
+            )
+
+            if block_given?
+              yield type
+            else
+              type
+            end
+          when :any
+            :any
+          end
+        end
+
+        class InterfaceCalculationError < StandardError
+          attr_reader :type
+
+          def initialize(type:, message:)
+            @type = type
+            super message
+          end
+        end
+
+        def unfold(type_name)
+          type_name_1(type_name).yield_self do |type_name|
+            decl = definition_builder.env.find_alias(type_name) or raise "Unknown type name: #{type_name}"
+            type(definition_builder.env.absolute_type(decl.type, namespace: type_name.namespace))
+          end
+        end
+
+        def expand_alias(type)
+          unfolded = case type
+                     when AST::Types::Name::Alias
+                       unfolded = unfold(type.name)
+                     else
+                       type
+                     end
+
+          if block_given?
+            yield unfolded
+          else
+            unfolded
+          end
+        end
+
+        def interface(type, private:, self_type: type)
+          type = expand_alias(type)
+
+          case type
+          when Self
+            if self_type != type
+              interface self_type, private: private, self_type: Self.new
+            else
+              raise "Unexpected `self` type interface"
+            end
+          when Name::Instance
+            Interface::Interface.new(type: self_type, private: private).tap do |interface|
+              definition = definition_builder.build_instance(type_name_1(type.name))
+
+              instance_type = Name::Instance.new(name: type.name,
+                                                 args: type.args.map { Any.new(location: nil) },
+                                                 location: nil)
+              module_type = type.to_module()
+
+              subst = Interface::Substitution.build(
+                definition.type_params,
+                type.args,
+                instance_type: instance_type,
+                module_type: module_type,
+                self_type: self_type
+              )
+
+              definition.methods.each do |name, method|
+                next if method.private? && !private
+
+                interface.methods[name] = Interface::Interface::Combination.overload(
+                  method.method_types.map do |type|
+                    method_type(type, self_type: self_type) {|ty| ty.subst(subst) }
+                  end,
+                  incompatible: method.attributes.include?(:incompatible)
+                )
+              end
+            end
+
+          when Name::Interface
+            Interface::Interface.new(type: self_type, private: private).tap do |interface|
+              type_name = type_name_1(type.name)
+              decl = definition_builder.env.find_class(type_name) or raise "Unknown class: #{type_name}"
+              definition = definition_builder.build_interface(type_name, decl)
+
+              subst = Interface::Substitution.build(
+                definition.type_params,
+                type.args,
+                self_type: self_type
+              )
+
+              definition.methods.each do |name, method|
+                interface.methods[name] = Interface::Interface::Combination.overload(
+                  method.method_types.map do |type|
+                    method_type(type, self_type: self_type) {|type| type.subst(subst) }
+                  end,
+                  incompatible: method.attributes.include?(:incompatible)
+                )
+              end
+            end
+
+          when Name::Class, Name::Module
+            Interface::Interface.new(type: self_type, private: private).tap do |interface|
+              definition = definition_builder.build_singleton(type_name_1(type.name))
+
+              instance_type = Name::Instance.new(name: type.name,
+                                                 args: definition.declaration.type_params.each.map {Any.new(location: nil)},
+                                                 location: nil)
+              subst = Interface::Substitution.build(
+                [],
+                instance_type: instance_type,
+                module_type: type,
+                self_type: self_type
+              )
+
+              definition.methods.each do |name, method|
+                next if !private && method.private?
+
+                interface.methods[name] = Interface::Interface::Combination.overload(
+                  method.method_types.map do |type|
+                    method_type(type, self_type: self_type) {|type| type.subst(subst) }
+                  end,
+                  incompatible: method.attributes.include?(:incompatible)
+                )
+              end
+            end
+
+          when Literal
+            interface type.back_type, private: private, self_type: self_type
+
+          when Nil
+            interface Builtin::NilClass.instance_type, private: private, self_type: self_type
+
+          when Boolean
+            interface(AST::Types::Union.build(types: [Builtin::TrueClass.instance_type, Builtin::FalseClass.instance_type]),
+                      private: private,
+                      self_type: self_type)
+
+          when Union
+            yield_self do
+              interfaces = type.types.map {|ty| interface(ty, private: private, self_type: self_type) }
+              interfaces.inject do |interface1, interface2|
+                Interface::Interface.new(type: self_type, private: private).tap do |interface|
+                  common_methods = Set.new(interface1.methods.keys) & Set.new(interface2.methods.keys)
+                  common_methods.each do |name|
+                    interface.methods[name] = Interface::Interface::Combination.union([interface1.methods[name], interface2.methods[name]])
+                  end
+                end
+              end
+            end
+
+          when Intersection
+            yield_self do
+              interfaces = type.types.map {|ty| interface(ty, private: private, self_type: self_type) }
+              interfaces.inject do |interface1, interface2|
+                Interface::Interface.new(type: self_type, private: private).tap do |interface|
+                  all_methods = Set.new(interface1.methods.keys) + Set.new(interface2.methods.keys)
+                  all_methods.each do |name|
+                    methods = [interface1.methods[name], interface2.methods[name]].compact
+                    interface.methods[name] = Interface::Interface::Combination.intersection(methods)
+                  end
+                end
+              end
+            end
+
+          when Tuple
+            yield_self do
+              element_type = Union.build(types: type.types, location: nil)
+              array_type = Builtin::Array.instance_type(element_type)
+              interface(array_type, private: private, self_type: self_type).tap do |array_interface|
+                array_interface.methods[:[]] = array_interface.methods[:[]].yield_self do |aref|
+                  Interface::Interface::Combination.overload(
+                    type.types.map.with_index {|elem_type, index|
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
+                                                      optional: [],
+                                                      rest: nil,
+                                                      required_keywords: {},
+                                                      optional_keywords: {},
+                                                      rest_keywords: nil),
+                        block: nil,
+                        return_type: elem_type,
+                        location: nil
+                      )
+                    } + aref.types,
+                    incompatible: false
+                  )
+                end
+
+                array_interface.methods[:[]=] = array_interface.methods[:[]=].yield_self do |update|
+                  Interface::Interface::Combination.overload(
+                    type.types.map.with_index {|elem_type, index|
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
+                                                      optional: [],
+                                                      rest: nil,
+                                                      required_keywords: {},
+                                                      optional_keywords: {},
+                                                      rest_keywords: nil),
+                        block: nil,
+                        return_type: elem_type,
+                        location: nil
+                      )
+                    } + update.types,
+                    incompatible: false
+                  )
+                end
+              end
+            end
+
+          when Record
+            yield_self do
+              key_type = type.elements.keys.map {|value| Literal.new(value: value, location: nil) }.yield_self do |types|
+                Union.build(types: types, location: nil)
+              end
+              value_type = Union.build(types: type.elements.values, location: nil)
+              hash_type = Builtin::Hash.instance_type(key_type, value_type)
+
+              interface(hash_type, private: private, self_type: self_type).tap do |hash_interface|
+                hash_interface.methods[:[]] = hash_interface.methods[:[]].yield_self do |ref|
+                  Interface::Interface::Combination.overload(
+                    type.elements.map {|key_value, value_type|
+                      key_type = Literal.new(value: key_value, location: nil)
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.new(required: [key_type],
+                                                      optional: [],
+                                                      rest: nil,
+                                                      required_keywords: {},
+                                                      optional_keywords: {},
+                                                      rest_keywords: nil),
+                        block: nil,
+                        return_type: value_type,
+                        location: nil
+                      )
+                    } + ref.types,
+                    incompatible: false
+                  )
+                end
+
+                hash_interface.methods[:[]=] = hash_interface.methods[:[]=].yield_self do |update|
+                  Interface::Interface::Combination.overload(
+                    type.elements.map {|key_value, value_type|
+                      key_type = Literal.new(value: key_value, location: nil)
+                      Interface::MethodType.new(
+                        type_params: [],
+                        params: Interface::Params.new(required: [key_type, value_type],
+                                                      optional: [],
+                                                      rest: nil,
+                                                      required_keywords: {},
+                                                      optional_keywords: {},
+                                                      rest_keywords: nil),
+                        block: nil,
+                        return_type: value_type,
+                        location: nil
+                      )
+                    } + update.types,
+                    incompatible: false
+                  )
+                end
+              end
+            end
+
+          when Proc
+            interface(Builtin::Proc.instance_type, private: private, self_type: self_type).tap do |interface|
+              method_type = Interface::MethodType.new(
+                type_params: [],
+                params: type.params,
+                return_type: type.return_type,
+                block: nil,
+                location: nil
+              )
+
+              interface.methods[:[]] = Interface::Interface::Combination.overload([method_type], incompatible: false)
+              interface.methods[:call] = Interface::Interface::Combination.overload([method_type], incompatible: false)
+            end
+
+          else
+            raise "Unexpected type for interface: #{type}"
+          end
+        end
+
+        def module_name?(type_name)
+          name = type_name_1(type_name)
+          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Module)
+        end
+
+        def class_name?(type_name)
+          name = type_name_1(type_name)
+          env.class?(name) && env.find_class(name).is_a?(Ruby::Signature::AST::Declarations::Class)
+        end
+
+        def env
+          @env ||= definition_builder.env
+        end
+
+        def absolute_type(type, namespace:)
+          type(env.absolute_type(type_1(type),
+                                 namespace: namespace_1(namespace)) {|type| type.name.absolute! })
+        end
+
+        def absolute_type_name(type_name, namespace:)
+          type(env.absolute_type_name(type_name_1(type_name),
+                                      namespace: namespace_1(namespace)) {|name| name.absolute! })
+        end
+      end
+    end
+  end
+end