steep 0.27.0 → 0.31.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e364b23ebecd35868dbde7ea09938fa8208219ee1fcd19a0faaa9a160f6aab'
-  data.tar.gz: c4374adcf1b0c54663e04380229322d9c07865fac69b1b74fa2eeabecd26cd7d
+  metadata.gz: 5fa95738ddb4d770cdba53deb56b05f2ad86523729852ac16823bfb433470a19
+  data.tar.gz: 9c295a1c5f1d28c1b9ae76b0693c582911770185828e18ce114f062a05fd4d24
 SHA512:
-  metadata.gz: e59635b6fba6e2dac0c7ba8fb12d9a4e4734ffd95a48b8af1cb2cdbb0a5280d660c46fbf724ea48a61247165319b448598f702d6ef0dbf78d28b78dcb7ba536c
-  data.tar.gz: 62ca2d4504a4d75922abf3b76def89f0146a298b3452a874d98a869fa3f39942984224324cdec93f7894918b4386a07aabb4a1be6f572bcbbb5d3081086b1cda
+  metadata.gz: 709a0883a3c698f8ca2246763a9c18e8af04072aa6edf7ca5e339a5c6d6e079693e1405c543fe8690276d4eebdcc35e5b65077dcba4c3dca2e1f102e84906e9b
+  data.tar.gz: 3eeef0c3d9cfd34a7678ab8b4f5f125e949d56706510aa1619f018c1346242e10452045b00a09b117bdbec9b5aa27f577ba6ec01c4f732335e9f69dfcf88e228

data/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## master
 
+## 0.31.1 (2020-10-07)
+
+* Fix `if-then-else` parsing ([#236](https://github.com/soutaro/steep/pull/236))
+
+## 0.31.0 (2020-10-04)
+
+* Fix type checking performance ([#230](https://github.com/soutaro/steep/pull/230))
+* Improve LSP completion/hover performance ([#232](https://github.com/soutaro/steep/pull/232))
+* Fix instance variable completion ([#234](https://github.com/soutaro/steep/pull/234))
+* Relax version requirements on Listen to allow installing on Ruby 3 ([#235](https://github.com/soutaro/steep/pull/235))
+
+## 0.30.0 (2020-10-03)
+
+* Let top-level defs be methods of Object ([#227](https://github.com/soutaro/steep/pull/227))
+* Fix error caused by attribute definitions ([#228](https://github.com/soutaro/steep/pull/228))
+* LSP worker improvements ([#222](https://github.com/soutaro/steep/pull/222), [#223](https://github.com/soutaro/steep/pull/223), [#226](https://github.com/soutaro/steep/pull/226), [#229](https://github.com/soutaro/steep/pull/229))
+
+## 0.29.0 (2020-09-28)
+
+* Implement reasoning on `is_a?`, `nil?`, and `===` methods. ([#218](https://github.com/soutaro/steep/pull/218))
+* Better completion based on interface ([#215](https://github.com/soutaro/steep/pull/215))
+* Fix begin-rescue typing ([#221](https://github.com/soutaro/steep/pull/221))
+
+## 0.28.0 (2020-09-17)
+
+* Fix typing case-when with empty body ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix lvasgn typing with `void` type hint ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix subtype checking between type variables and union types ([#200](https://github.com/soutaro/steep/pull/200))
+* Support endless range ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix optarg, kwoptarg typing ([#202](https://github.com/soutaro/steep/pull/202))
+* Better union/intersection types ([#204](https://github.com/soutaro/steep/pull/204))
+* Fix generic method instantiation ([#205](https://github.com/soutaro/steep/pull/205))
+* Fix module typing ([#206](https://github.com/soutaro/steep/pull/206))
+* Fix shutdown problem ([#209](https://github.com/soutaro/steep/pull/209))
+* Update RBS to 0.12.0 ([#210](https://github.com/soutaro/steep/pull/210))
+* Improve processing singleton class decls without RBS ([#211](https://github.com/soutaro/steep/pull/211))
+* Improve processing block parameter with masgn ([#212](https://github.com/soutaro/steep/pull/212))
+
 ## 0.27.0 (2020-08-31)
 
 * Make tuple types _covariant_ ([#195](https://github.com/soutaro/steep/pull/195))

data/bin/smoke_runner.rb

@@ -19,8 +19,6 @@ Expectation = Struct.new(:line, :message, :path, :starts) do
   attr_accessor :prefix_test
 end
 
-allowed_paths = []
-
 failed = false
 
 ARGV.each do |arg|
@@ -29,12 +27,13 @@ ARGV.each do |arg|
 
   rb_files = []
   expectations = []
-
+  allowed_paths = []
+  
   dir.children.each do |file|
     if file.extname == ".rb"
       buffer = ::Parser::Source::Buffer.new(file.to_s)
       buffer.source = file.read
-      parser = ::Parser::Ruby25.new
+      parser = ::Parser::Ruby27.new
 
       _, comments, _ = parser.tokenize(buffer)
       comments.each do |comment|

data/bin/steep-prof

@@ -9,8 +9,7 @@ def exit(*)
 
 end
 
-
 STDERR.puts "Running profiler: mode=#{mode}, out=#{out}"
-StackProf.run(mode: mode, out: out) do
+StackProf.run(mode: mode, out: out, raw: true) do
   load File.join(__dir__, "../exe/steep")
 end

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby25"
+require "parser/ruby27"
 require "ast_utils"
 require "active_support/core_ext/object/try"
 require "logger"
@@ -16,8 +16,6 @@ require 'uri'
 
 require "rbs"
 
-require "steep/ast/namespace"
-require "steep/names"
 require "steep/ast/location"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
@@ -37,6 +35,7 @@ require "steep/ast/types/boolean"
 require "steep/ast/types/tuple"
 require "steep/ast/types/proc"
 require "steep/ast/types/record"
+require "steep/ast/types/logic"
 require "steep/ast/type_params"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
@@ -62,6 +61,7 @@ require "steep/source"
 require "steep/annotation_parser"
 require "steep/typing"
 require "steep/errors"
+require "steep/module_helper"
 require "steep/type_construction"
 require "steep/type_inference/context"
 require "steep/type_inference/context_array"
@@ -71,6 +71,7 @@ require "steep/type_inference/constant_env"
 require "steep/type_inference/type_env"
 require "steep/type_inference/local_variable_type_env"
 require "steep/type_inference/logic"
+require "steep/type_inference/logic_type_interpreter"
 require "steep/ast/types"
 
 require "steep/server/utils"
@@ -82,7 +83,8 @@ require "steep/server/interaction_worker"
 require "steep/server/master"
 
 require "steep/project"
-require "steep/project/file"
+require "steep/project/signature_file"
+require "steep/project/source_file"
 require "steep/project/options"
 require "steep/project/target"
 require "steep/project/dsl"

data/lib/steep/annotation_parser.rb

@@ -80,9 +80,7 @@ module Steep
           name = match[:name]
           type = parse_type(match[:type])
 
-          AST::Annotation::ConstType.new(name: Names::Module.parse(name),
-                                         type: type,
-                                         location: location)
+          AST::Annotation::ConstType.new(name: TypeName(name), type: type, location: location)
         end
 
       when keyword_subject_type("ivar", IVAR_NAME)
@@ -152,7 +150,7 @@ module Steep
 
       when /@implements\s+(?<name>#{CONST_NAME})#{TYPE_PARAMS}$/
         Regexp.last_match.yield_self do |match|
-          type_name = Names::Module.parse(match[:name])
+          type_name = TypeName(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)

data/lib/steep/ast/builtin.rb

@@ -6,7 +6,7 @@ module Steep
         attr_reader :arity
 
         def initialize(module_name, arity: 0)
-          @module_name = Names::Module.parse(module_name)
+          @module_name = TypeName(module_name)
           @arity = arity
         end
 
@@ -15,12 +15,8 @@ module Steep
           Types::Name::Instance.new(name: module_name, args: args)
         end
 
-        def class_type(constructor: nil)
-          Types::Name::Class.new(name: module_name, constructor: constructor)
-        end
-
         def module_type
-          Types::Name::Module.new(name: module_name)
+          Types::Name::Singleton.new(name: module_name)
         end
 
         def instance_type?(type, args: nil)
@@ -36,22 +32,8 @@ module Steep
           end
         end
 
-        NONE = ::Object.new
-
-        def class_type?(type, constructor: NONE)
-          if type.is_a?(Types::Name::Class)
-            unless constructor.equal?(NONE)
-              type.name == module_name && type.name.constructor == constructor
-            else
-              type.name == module_name
-            end
-          else
-            false
-          end
-        end
-
         def module_type?(type)
-          if type.is_a?(Types::Name::Module)
+          if type.is_a?(Types::Name::Singleton)
             type.name == module_name
           else
             false
@@ -99,6 +81,14 @@ module Steep
       def self.optional(type)
         AST::Types::Union.build(types: [type, nil_type])
       end
+
+      def self.true_type
+        AST::Types::Literal.new(value: true)
+      end
+
+      def self.false_type
+        AST::Types::Literal.new(value: false)
+      end
     end
   end
 end

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

@@ -7,11 +7,14 @@ module Steep
         attr_reader :type_name_cache
         attr_reader :type_cache
 
+        attr_reader :type_interface_cache
+
         def initialize(builder:)
           @definition_builder = builder
 
           @type_name_cache = {}
           @type_cache = {}
+          @type_interface_cache = {}
         end
 
         def type_name_resolver
@@ -43,18 +46,18 @@ module Steep
           when RBS::Types::Variable
             Var.new(name: type.name, location: nil)
           when RBS::Types::ClassSingleton
-            type_name = type_name(type.name)
-            Name::Class.new(name: type_name, location: nil, constructor: nil)
+            type_name = type.name
+            Name::Singleton.new(name: type_name, location: nil)
           when RBS::Types::ClassInstance
-            type_name = type_name(type.name)
+            type_name = type.name
             args = type.args.map {|arg| type(arg) }
             Name::Instance.new(name: type_name, args: args, location: nil)
           when RBS::Types::Interface
-            type_name = type_name(type.name)
+            type_name = type.name
             args = type.args.map {|arg| type(arg) }
             Name::Interface.new(name: type_name, args: args, location: nil)
           when RBS::Types::Alias
-            type_name = type_name(type.name)
+            type_name = type.name
             Name::Alias.new(name: type_name, args: [], location: nil)
           when RBS::Types::Union
             Union.build(types: type.types.map {|ty| type(ty) }, location: nil)
@@ -102,23 +105,23 @@ module Steep
             RBS::Types::Bases::Nil.new(location: nil)
           when Var
             RBS::Types::Variable.new(name: type.name, location: nil)
-          when Name::Class, Name::Module
-            RBS::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
+          when Name::Singleton
+            RBS::Types::ClassSingleton.new(name: type.name, location: nil)
           when Name::Instance
             RBS::Types::ClassInstance.new(
-              name: type_name_1(type.name),
+              name: type.name,
               args: type.args.map {|arg| type_1(arg) },
               location: nil
             )
           when Name::Interface
             RBS::Types::Interface.new(
-              name: type_name_1(type.name),
+              name: 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"
-            RBS::Types::Alias.new(name: type_name_1(type.name), location: nil)
+            RBS::Types::Alias.new(name: type.name, location: nil)
           when Union
             RBS::Types::Union.new(
               types: type.types.map {|ty| type_1(ty) },
@@ -151,32 +154,6 @@ module Steep
           end
         end
 
-        def type_name(name)
-          n = type_name_cache[name] and return n
-
-          type_name_cache[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)
-          RBS::TypeName.new(name: name.name, namespace: namespace_1(name.namespace))
-        end
-
-        def namespace(namespace)
-          Namespace.parse(namespace.to_s)
-        end
-
-        def namespace_1(namespace)
-          RBS::Namespace.parse(namespace.to_s)
-        end
-
         def function_1(params, return_type)
           RBS::Types::Function.new(
             required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
@@ -201,7 +178,7 @@ module Steep
           )
         end
 
-        def method_type(method_type, self_type:, subst2: nil)
+        def method_type(method_type, self_type:, subst2: nil, method_def: nil)
           fvs = self_type.free_variables()
 
           type_params = []
@@ -219,20 +196,21 @@ module Steep
             end
           end
           subst = Interface::Substitution.build(alpha_vars, alpha_types)
-          subst.merge!(subst2) if subst2
+          subst.merge!(subst2, overwrite: true) if subst2
 
           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
+            end,
+            method_def: method_def,
+            location: method_def&.member&.location
           )
 
           if block_given?
@@ -292,7 +270,7 @@ module Steep
         end
 
         def unfold(type_name)
-          type_name_1(type_name).yield_self do |type_name|
+          type_name.yield_self do |type_name|
             type(definition_builder.expand_alias(type_name))
           end
         end
@@ -312,19 +290,129 @@ module Steep
           end
         end
 
+        def deep_expand_alias(type, recursive: Set.new, &block)
+          raise "Recursive type definition: #{type}" if recursive.member?(type)
+
+          ty = case type
+               when AST::Types::Name::Alias
+                 deep_expand_alias(expand_alias(type), recursive: recursive.union([type]))
+               when AST::Types::Union
+                 AST::Types::Union.build(
+                   types: type.types.map {|ty| deep_expand_alias(ty, recursive: recursive, &block) },
+                   location: type.location
+                 )
+               else
+                 type
+               end
+
+          if block_given?
+            yield ty
+          else
+            ty
+          end
+        end
+
+        def flatten_union(type, acc = [])
+          case type
+          when AST::Types::Union
+            type.types.each {|ty| flatten_union(ty, acc) }
+          else
+            acc << type
+          end
+
+          acc
+        end
+
+        def unwrap_optional(type)
+          case type
+          when AST::Types::Union
+            falsy_types, truthy_types = type.types.partition do |type|
+              (type.is_a?(AST::Types::Literal) && type.value == false) ||
+                type.is_a?(AST::Types::Nil)
+            end
+
+            [
+              AST::Types::Union.build(types: truthy_types),
+              AST::Types::Union.build(types: falsy_types)
+            ]
+          when AST::Types::Name::Alias
+            unwrap_optional(expand_alias(type))
+          else
+            [type, nil]
+          end
+        end
+
+        def setup_primitives(method_name, method_type)
+          if method_def = method_type.method_def
+            defined_in = method_def.defined_in
+            member = method_def.member
+
+            if member.is_a?(RBS::AST::Members::MethodDefinition)
+              case
+              when defined_in == RBS::BuiltinNames::Object.name && member.instance?
+                case method_name
+                when :is_a?, :kind_of?, :instance_of?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  )
+                when :nil?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  )
+                end
+
+              when defined_in == AST::Builtin::NilClass.module_name && member.instance?
+                case method_name
+                when :nil?
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  )
+                end
+
+              when defined_in == RBS::BuiltinNames::BasicObject.name && member.instance?
+                case method_name
+                when :!
+                  return method_type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  )
+                end
+
+              when defined_in == RBS::BuiltinNames::Module.name && member.instance?
+                case method_name
+                when :===
+                  return method_type.with(
+                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  )
+                end
+              end
+            end
+          end
+
+          method_type
+        end
+
         def interface(type, private:, self_type: type)
-          type = expand_alias(type)
+          Steep.logger.debug { "Factory#interface: #{type}, private=#{private}, self_type=#{self_type}" }
+
+          cache_key = [type, self_type, private]
+          if type_interface_cache.key?(cache_key)
+            return type_interface_cache[cache_key]
+          end
 
           case type
+          when Name::Alias
+            interface(expand_alias(type), private: private, self_type: self_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))
+              definition = definition_builder.build_instance(type.name)
 
               instance_type = Name::Instance.new(name: type.name,
                                                  args: type.args.map { Any.new(location: nil) },
@@ -340,20 +428,27 @@ module Steep
               )
 
               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, subst2: subst)
-                  end,
-                  incompatible: name == :initialize || name == :new
-                )
+                Steep.logger.tagged "method = #{name}" do
+                  next if method.private? && !private
+
+                  interface.methods[name] = Interface::Interface::Entry.new(
+                    method_types: method.defs.map do |type_def|
+                      setup_primitives(
+                        name,
+                        method_type(type_def.type,
+                                    method_def: type_def,
+                                    self_type: self_type,
+                                    subst2: subst)
+                      )
+                    end
+                  )
+                end
               end
             end
 
           when Name::Interface
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
-              type_name = type_name_1(type.name)
+              type_name = type.name
               definition = definition_builder.build_interface(type_name)
 
               subst = Interface::Substitution.build(
@@ -363,18 +458,17 @@ module Steep
               )
 
               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, subst2: subst)
-                  end,
-                  incompatible: false
+                interface.methods[name] = Interface::Interface::Entry.new(
+                  method_types: method.defs.map do |type_def|
+                    method_type(type_def.type, method_def: type_def, self_type: self_type, subst2: subst)
+                  end
                 )
               end
             end
 
-          when Name::Class, Name::Module
+          when Name::Singleton
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
-              definition = definition_builder.build_singleton(type_name_1(type.name))
+              definition = definition_builder.build_singleton(type.name)
 
               instance_type = Name::Instance.new(name: type.name,
                                                  args: definition.type_params.map {Any.new(location: nil)},
@@ -389,11 +483,16 @@ module Steep
               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, subst2: subst)
-                  end,
-                  incompatible: false
+                interface.methods[name] = Interface::Interface::Entry.new(
+                  method_types: method.defs.map do |type_def|
+                    setup_primitives(
+                      name,
+                      method_type(type_def.type,
+                                  method_def: type_def,
+                                  self_type: self_type,
+                                  subst2: subst)
+                    )
+                  end
                 )
               end
             end
@@ -416,7 +515,25 @@ module Steep
                 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]])
+                    types1 = interface1.methods[name].method_types
+                    types2 = interface2.methods[name].method_types
+
+                    if types1 == types2
+                      interface.methods[name] = interface1.methods[name]
+                    else
+                      method_types = {}
+
+                      types1.each do |type1|
+                        types2.each do |type2|
+                          type = type1 | type2 or next
+                          method_types[type] = true
+                        end
+                      end
+
+                      unless method_types.empty?
+                        interface.methods[name] = Interface::Interface::Entry.new(method_types: method_types.keys)
+                      end
+                    end
                   end
                 end
               end
@@ -427,11 +544,8 @@ module Steep
               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
+                  interface.methods.merge!(interface1.methods)
+                  interface.methods.merge!(interface2.methods)
                 end
               end
             end
@@ -442,8 +556,8 @@ module Steep
               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::Interface::Entry.new(
+                    method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
@@ -454,16 +568,16 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: elem_type,
+                        method_def: nil,
                         location: nil
                       )
-                    } + aref.types,
-                    incompatible: false
+                    } + aref.method_types
                   )
                 end
 
                 array_interface.methods[:[]=] = array_interface.methods[:[]=].yield_self do |update|
-                  Interface::Interface::Combination.overload(
-                    type.types.map.with_index {|elem_type, index|
+                  Interface::Interface::Entry.new(
+                    method_types: 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],
@@ -474,40 +588,40 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: elem_type,
+                        method_def: nil,
                         location: nil
                       )
-                    } + update.types,
-                    incompatible: false
+                    } + update.method_types
                   )
                 end
 
                 array_interface.methods[:first] = array_interface.methods[:first].yield_self do |first|
-                  Interface::Interface::Combination.overload(
-                    [
+                  Interface::Interface::Entry.new(
+                    method_types: [
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.empty,
                         block: nil,
                         return_type: type.types[0] || AST::Builtin.nil_type,
+                        method_def: nil,
                         location: nil
                       )
-                    ],
-                    incompatible: false
+                    ]
                   )
                 end
 
                 array_interface.methods[:last] = array_interface.methods[:last].yield_self do |last|
-                  Interface::Interface::Combination.overload(
-                    [
+                  Interface::Interface::Entry.new(
+                    method_types: [
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.empty,
                         block: nil,
                         return_type: type.types.last || AST::Builtin.nil_type,
+                        method_def: nil,
                         location: nil
                       )
-                    ],
-                    incompatible: false
+                    ]
                   )
                 end
               end
@@ -523,8 +637,8 @@ module Steep
 
               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|
+                  Interface::Interface::Entry.new(
+                    method_types: type.elements.map {|key_value, value_type|
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
@@ -536,16 +650,16 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: value_type,
+                        method_def: nil,
                         location: nil
                       )
-                    } + ref.types,
-                    incompatible: false
+                    } + ref.method_types
                   )
                 end
 
                 hash_interface.methods[:[]=] = hash_interface.methods[:[]=].yield_self do |update|
-                  Interface::Interface::Combination.overload(
-                    type.elements.map {|key_value, value_type|
+                  Interface::Interface::Entry.new(
+                    method_types: type.elements.map {|key_value, value_type|
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
@@ -557,10 +671,10 @@ module Steep
                                                       rest_keywords: nil),
                         block: nil,
                         return_type: value_type,
+                        method_def: nil,
                         location: nil
                       )
-                    } + update.types,
-                    incompatible: false
+                    } + update.method_types
                   )
                 end
               end
@@ -573,26 +687,30 @@ module Steep
                 params: type.params,
                 return_type: type.return_type,
                 block: nil,
+                method_def: nil,
                 location: nil
               )
 
-              interface.methods[:[]] = Interface::Interface::Combination.overload([method_type], incompatible: false)
-              interface.methods[:call] = Interface::Interface::Combination.overload([method_type], incompatible: false)
+              interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])
+              interface.methods[:call] = Interface::Interface::Entry.new(method_types: [method_type])
             end
 
+          when Logic::Base
+            interface(AST::Builtin.bool_type, private: private, self_type: self_type)
+
           else
             raise "Unexpected type for interface: #{type}"
+          end.tap do |interface|
+            type_interface_cache[cache_key] = interface
           end
         end
 
         def module_name?(type_name)
-          name = type_name_1(type_name)
-          entry = env.class_decls[name] and entry.is_a?(RBS::Environment::ModuleEntry)
+          entry = env.class_decls[type_name] and entry.is_a?(RBS::Environment::ModuleEntry)
         end
 
         def class_name?(type_name)
-          name = type_name_1(type_name)
-          entry = env.class_decls[name] and entry.is_a?(RBS::Environment::ClassEntry)
+          entry = env.class_decls[type_name] and entry.is_a?(RBS::Environment::ClassEntry)
         end
 
         def env
@@ -607,7 +725,22 @@ module Steep
         end
 
         def absolute_type_name(type_name, namespace:)
-          type_name_resolver.resolve(type_name, context: namespace_1(namespace).ascend)
+          type_name_resolver.resolve(type_name, context: namespace.ascend)
+        end
+
+        def instance_type(type_name, args: nil, location: nil)
+          raise unless type_name.class?
+
+          definition = definition_builder.build_singleton(type_name)
+          def_args = definition.type_params.map { Any.new(location: nil) }
+
+          if args
+            raise if def_args.size != args.size
+          else
+            args = def_args
+          end
+
+          AST::Types::Name::Instance.new(location: location, name: type_name, args: args)
         end
       end
     end