steep 1.1.1 → 1.2.0.pre.1

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

@@ -4,11 +4,8 @@ module Steep
       class Factory
         attr_reader :definition_builder
 
-        attr_reader :type_name_cache
         attr_reader :type_cache
 
-        attr_reader :type_interface_cache
-
         def inspect
           s = "#<%s:%#018x " % [self.class, object_id]
           s << "@definition_builder=#<%s:%#018x>" % [definition_builder.class, definition_builder.object_id]
@@ -18,9 +15,9 @@ module Steep
         def initialize(builder:)
           @definition_builder = builder
 
-          @type_name_cache = {}
           @type_cache = {}
-          @type_interface_cache = {}
+          @method_type_cache = {}
+          @method_type_cache.compare_by_identity
         end
 
         def type_name_resolver
@@ -33,6 +30,12 @@ module Steep
           end
         end
 
+        def type_1_opt(type)
+          if type
+            type_1(type)
+          end
+        end
+
         def type(type)
           ty = type_cache[type] and return ty
 
@@ -101,11 +104,16 @@ module Steep
                             return_type: type(type.block.type.return_type),
                             location: type.location
                           ),
-                          optional: !type.block.required
+                          optional: !type.block.required,
+                          self_type: type_opt(type.block.self_type)
                         )
                       end
 
-              Proc.new(type: func, block: block)
+              Proc.new(
+                type: func,
+                block: block,
+                self_type: type_opt(type.self_type)
+              )
             else
               raise "Unexpected type given: #{type}"
             end
@@ -179,11 +187,13 @@ module Steep
             block = if type.block
                       RBS::Types::Block.new(
                         type: function_1(type.block.type),
-                        required: !type.block.optional?
+                        required: !type.block.optional?,
+                        self_type: type_1_opt(type.block.self_type)
                       )
                     end
             RBS::Types::Proc.new(
               type: function_1(type.type),
+              self_type: type_1_opt(type.self_type),
               block: block,
               location: type.location
             )
@@ -224,7 +234,7 @@ module Steep
         def type_param(type_param)
           Interface::TypeParam.new(
             name: type_param.name,
-            upper_bound: type_param.upper_bound&.yield_self {|u| type(u) },
+            upper_bound: type_opt(type_param.upper_bound),
             variance: type_param.variance,
             unchecked: type_param.unchecked?
           )
@@ -239,135 +249,80 @@ module Steep
           ).unchecked!(type_param.unchecked)
         end
 
-        def method_type(method_type, self_type:, subst2: nil, method_decls:)
-          fvs = self_type.free_variables()
-
-          type_params = []
-          conflicting_names = []
-
-          type_params = method_type.type_params.map do |type_param|
-            if fvs.include?(type_param.name)
-              conflicting_names << type_param.name
-            end
-
-            type_param(type_param)
-          end
-
-          type_params, subst = Interface::TypeParam.rename(type_params, conflicting_names)
-          subst.merge!(subst2, overwrite: true) if subst2
-
-          type =
+        def method_type(method_type, method_decls:)
+          mt = @method_type_cache[method_type] ||=
             Interface::MethodType.new(
-              type_params: type_params,
+              type_params: method_type.type_params.map {|param| type_param(param) },
               type: Interface::Function.new(
-                params: params(method_type.type).subst(subst),
-                return_type: type(method_type.type.return_type).subst(subst),
+                params: params(method_type.type),
+                return_type: type(method_type.type.return_type),
                 location: method_type.location
               ),
               block: method_type.block&.yield_self do |block|
                 Interface::Block.new(
                   optional: !block.required,
                   type: Interface::Function.new(
-                    params: params(block.type).subst(subst),
-                    return_type: type(block.type.return_type).subst(subst),
+                    params: params(block.type),
+                    return_type: type(block.type.return_type),
                     location: nil
-                  )
+                  ),
+                  self_type: type_opt(block.self_type)
                 )
               end,
-              method_decls: method_decls
+              method_decls: Set[]
             )
 
-          if block_given?
-            yield type
-          else
-            type
-          end
+          mt.with(method_decls: method_decls)
         end
 
-        def method_type_1(method_type, self_type:)
-          fvs = self_type.free_variables()
-
-          type_params = []
-
-          conflicting_names = method_type.type_params.each.with_object([]) do |param, names|
-            names << params.name if fvs.include?(param.name)
-          end
-
-          type_params, subst = Interface::TypeParam.rename(method_type.type_params, conflicting_names)
-
-          type = RBS::MethodType.new(
-            type_params: type_params.map {|param| type_param_1(param) },
-            type: function_1(method_type.type.subst(subst)),
+        def method_type_1(method_type)
+          RBS::MethodType.new(
+            type_params: method_type.type_params.map {|param| type_param_1(param) },
+            type: function_1(method_type.type),
             block: method_type.block&.yield_self do |block|
-              block_type = block.type.subst(subst)
-
               RBS::Types::Block.new(
-                type: function_1(block_type),
-                required: !block.optional
+                type: function_1(block.type),
+                required: !block.optional,
+                self_type: type_1_opt(block.self_type)
               )
             end,
             location: nil
           )
-
-          if block_given?
-            yield type
-          else
-            type
-          end
-        end
-
-        class InterfaceCalculationError < StandardError
-          attr_reader :type
-
-          def initialize(type:, message:)
-            @type = type
-            super message
-          end
         end
 
         def unfold(type_name, args)
           type(
             definition_builder.expand_alias2(
               type_name,
-              args.empty? ? args : args.map {|t| type_1(t) }
+              args.empty? ? [] : args.map {|t| type_1(t) }
             )
           )
         end
 
         def expand_alias(type)
-          unfolded = case type
-                     when AST::Types::Name::Alias
-                       unfold(type.name, type.args)
-                     else
-                       type
-                     end
-
-          if block_given?
-            yield unfolded
+          case type
+          when AST::Types::Name::Alias
+            unfold(type.name, type.args)
           else
-            unfolded
+            type
           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
+        def deep_expand_alias(type, recursive: Set.new)
+          case type
+          when AST::Types::Name::Alias
+            unless recursive.member?(type.name)
+              unfolded = expand_alias(type)
+              deep_expand_alias(unfolded, recursive: recursive.union([type.name]))
+            end
+          when AST::Types::Union
+            types = type.types.map {|ty| deep_expand_alias(ty, recursive: recursive) or return }
+            AST::Types::Union.build(types: types, location: type.location)
+          when AST::Types::Intersection
+            types = type.types.map {|ty| deep_expand_alias(ty, recursive: recursive) or return }
+            AST::Types::Intersection.build(types: types, location: type.location)
           else
-            ty
+            type
           end
         end
 
@@ -403,515 +358,24 @@ module Steep
           end
         end
 
-        NilClassName = TypeName("::NilClass")
-
-        def setup_primitives(method_name, method_def, method_type)
-          defined_in = method_def.defined_in
-          member = method_def.member
-
-          if member.is_a?(RBS::AST::Members::MethodDefinition)
-            case method_name
-            when :is_a?, :kind_of?, :instance_of?
-              if defined_in == RBS::BuiltinNames::Object.name && member.instance?
-                return method_type.with(
-                  type: method_type.type.with(
-                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.type.return_type.location)
-                  )
-                )
-              end
-
-            when :nil?
-              case defined_in
-              when RBS::BuiltinNames::Object.name,
-                NilClassName
-                return method_type.with(
-                  type: method_type.type.with(
-                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.type.return_type.location)
-                  )
-                )
-              end
-
-            when :!
-              case defined_in
-              when RBS::BuiltinNames::BasicObject.name,
-                RBS::BuiltinNames::TrueClass.name,
-                RBS::BuiltinNames::FalseClass.name,
-                AST::Builtin::NilClass.module_name
-                return method_type.with(
-                  type: method_type.type.with(
-                    return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)
-                  )
-                )
-              end
-
-            when :===
-              case defined_in
-              when RBS::BuiltinNames::Module.name
-                return method_type.with(
-                  type: method_type.type.with(
-                    return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.type.return_type.location)
-                  )
-                )
-              when RBS::BuiltinNames::Object.name, RBS::BuiltinNames::String.name, RBS::BuiltinNames::Integer.name, RBS::BuiltinNames::Symbol.name,
-                RBS::BuiltinNames::TrueClass.name, RBS::BuiltinNames::FalseClass.name, TypeName("::NilClass")
-                # Value based type-case works on literal types which is available for String, Integer, Symbol, TrueClass, FalseClass, and NilClass
-                return method_type.with(
-                  type: method_type.type.with(
-                    return_type: AST::Types::Logic::ArgEqualsReceiver.new(location: method_type.type.return_type.location)
-                  )
-                )
-              end
-            end
-          end
-
-          method_type
-        end
-
-        def interface(type, private:, self_type: 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)
-
-              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|
-                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|
-                      method_name = InstanceMethodName.new(type_name: type_def.implemented_in || type_def.defined_in, method_name: name)
-                      decl = TypeInference::MethodCall::MethodDecl.new(method_name: method_name, method_def: type_def)
-                      setup_primitives(
-                        name,
-                        type_def,
-                        method_type(type_def.type,
-                                    method_decls: Set[decl],
-                                    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
-              definition = definition_builder.build_interface(type_name)
-
-              subst = Interface::Substitution.build(
-                definition.type_params,
-                type.args,
-                self_type: self_type
-              )
-
-              definition.methods.each do |name, method|
-                interface.methods[name] = Interface::Interface::Entry.new(
-                  method_types: method.defs.map do |type_def|
-                    decls = Set[TypeInference::MethodCall::MethodDecl.new(
-                      method_name: InstanceMethodName.new(type_name: type_def.implemented_in || type_def.defined_in, method_name: name),
-                      method_def: type_def
-                    )]
-                    method_type(type_def.type, method_decls: decls, self_type: self_type, subst2: subst)
-                  end
-                )
-              end
-            end
-
-          when Name::Singleton
-            Interface::Interface.new(type: self_type, private: private).tap do |interface|
-              definition = definition_builder.build_singleton(type.name)
-
-              instance_type = Name::Instance.new(name: type.name,
-                                                 args: definition.type_params.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::Entry.new(
-                  method_types: method.defs.map do |type_def|
-                    decl = TypeInference::MethodCall::MethodDecl.new(
-                      method_name: SingletonMethodName.new(type_name: type_def.implemented_in || type_def.defined_in,
-                                                           method_name: name),
-                      method_def: type_def
-                    )
-                    setup_primitives(
-                      name,
-                      type_def,
-                      method_type(type_def.type,
-                                  method_decls: Set[decl],
-                                  self_type: self_type,
-                                  subst2: subst)
-                    )
-                  end
-                )
-              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|
-                    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
-            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|
-                  interface.methods.merge!(interface1.methods)
-                  interface.methods.merge!(interface2.methods)
-                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::Entry.new(
-                    method_types: type.types.map.with_index {|elem_type, index|
-                      Interface::MethodType.new(
-                        type_params: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
-                          return_type: elem_type,
-                          location: nil
-                        ),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    } + aref.method_types
-                  )
-                end
-
-                array_interface.methods[:[]=] = array_interface.methods[:[]=].yield_self do |update|
-                  Interface::Interface::Entry.new(
-                    method_types: type.types.map.with_index {|elem_type, index|
-                      Interface::MethodType.new(
-                        type_params: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index), elem_type]),
-                          return_type: elem_type,
-                          location: nil
-                        ),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    } + update.method_types
-                  )
-                end
-
-                array_interface.methods[:fetch] = array_interface.methods[:fetch].yield_self do |fetch|
-                  Interface::Interface::Entry.new(
-                    method_types: type.types.flat_map.with_index {|elem_type, index|
-                      [
-                        Interface::MethodType.new(
-                          type_params: [],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
-                            return_type: elem_type,
-                            location: nil
-                          ),
-                          block: nil,
-                          method_decls: Set[]
-                        ),
-                        Interface::MethodType.new(
-                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(
-                              required: [
-                                AST::Types::Literal.new(value: index),
-                                AST::Types::Var.new(name: :T)
-                              ]
-                            ),
-                            return_type: AST::Types::Union.build(types: [elem_type, AST::Types::Var.new(name: :T)]),
-                            location: nil
-                          ),
-                          block: nil,
-                          method_decls: Set[]
-                        ),
-                        Interface::MethodType.new(
-                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
-                            return_type: AST::Types::Union.build(types: [elem_type, AST::Types::Var.new(name: :T)]),
-                            location: nil
-                          ),
-                          block: Interface::Block.new(
-                            type: Interface::Function.new(
-                              params: Interface::Function::Params.build(required: [AST::Builtin::Integer.instance_type]),
-                              return_type: AST::Types::Var.new(name: :T),
-                              location: nil
-                            ),
-                            optional: false
-                          ),
-                          method_decls: Set[]
-                        )
-                      ]
-                    } + fetch.method_types
-                  )
-                end
-
-                array_interface.methods[:first] = array_interface.methods[:first].yield_self do |first|
-                  Interface::Interface::Entry.new(
-                    method_types: [
-                      Interface::MethodType.new(
-                        type_params: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.empty,
-                          return_type: type.types[0] || AST::Builtin.nil_type,
-                          location: nil
-                        ),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    ]
-                  )
-                end
-
-                array_interface.methods[:last] = array_interface.methods[:last].yield_self do |last|
-                  Interface::Interface::Entry.new(
-                    method_types: [
-                      Interface::MethodType.new(
-                        type_params: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.empty,
-                          return_type: type.types.last || AST::Builtin.nil_type,
-                          location: nil
-                        ),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    ]
-                  )
-                end
-              end
-            end
-
-          when Record
-            yield_self do
-              all_key_type = type.elements.keys.map {|value| Literal.new(value: value, location: nil) }.yield_self do |types|
-                Union.build(types: types, location: nil)
-              end
-              all_value_type = Union.build(types: type.elements.values, location: nil)
-              hash_type = Builtin::Hash.instance_type(all_key_type, all_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::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: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.build(
-                            required: [key_type],
-                            optional: [],
-                            rest: nil,
-                            required_keywords: {},
-                            optional_keywords: {},
-                            rest_keywords: nil
-                          ),
-                          return_type: value_type,
-                          location: nil
-                        ),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    } + ref.method_types
-                  )
-                end
-
-                hash_interface.methods[:[]=] = hash_interface.methods[:[]=].yield_self do |update|
-                  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: [],
-                        type: Interface::Function.new(
-                          params: Interface::Function::Params.build(
-                            required: [key_type, value_type],
-                            optional: [],
-                            rest: nil,
-                            required_keywords: {},
-                            optional_keywords: {},
-                            rest_keywords: nil
-                          ),
-                          return_type: value_type,
-                          location: nil),
-                        block: nil,
-                        method_decls: Set[]
-                      )
-                    } + update.method_types
-                  )
-                end
-
-                hash_interface.methods[:fetch] = hash_interface.methods[:fetch].yield_self do |update|
-                  Interface::Interface::Entry.new(
-                    method_types: type.elements.flat_map {|key_value, value_type|
-                      key_type = Literal.new(value: key_value, location: nil)
-
-                      [
-                        Interface::MethodType.new(
-                          type_params: [],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(required: [key_type]),
-                            return_type: value_type,
-                            location: nil
-                          ),
-                          block: nil,
-                          method_decls: Set[]
-                        ),
-                        Interface::MethodType.new(
-                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(required: [key_type, AST::Types::Var.new(name: :T)]),
-                            return_type: AST::Types::Union.build(types: [value_type, AST::Types::Var.new(name: :T)]),
-                            location: nil
-                          ),
-                          block: nil,
-                          method_decls: Set[]
-                        ),
-                        Interface::MethodType.new(
-                          type_params: [Interface::TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
-                          type: Interface::Function.new(
-                            params: Interface::Function::Params.build(required: [key_type]),
-                            return_type: AST::Types::Union.build(types: [value_type, AST::Types::Var.new(name: :T)]),
-                            location: nil
-                          ),
-                          block: Interface::Block.new(
-                            type: Interface::Function.new(
-                              params: Interface::Function::Params.build(required: [all_key_type]),
-                              return_type: AST::Types::Var.new(name: :T),
-                              location: nil
-                            ),
-                            optional: false
-                          ),
-                          method_decls: Set[]
-                        )
-                      ]
-                    } + update.method_types
-                  )
-                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: [],
-                type: type.type,
-                block: type.block,
-                method_decls: Set[]
-              )
-
-              interface.methods[:call] = Interface::Interface::Entry.new(method_types: [method_type])
-
-              if type.block_required?
-                interface.methods.delete(:[])
-              else
-                interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type.with(block: nil)])
-              end
-            end
-
-          when Logic::Base
-            interface(AST::Builtin.bool_type, private: private, self_type: self_type)
-
+        def module_name?(type_name)
+          if entry = env.class_decls[type_name]
+            entry.is_a?(RBS::Environment::ModuleEntry)
           else
-            raise "Unexpected type for interface: #{type}"
-          end.tap do |interface|
-            type_interface_cache[cache_key] = interface
+            false
           end
         end
 
-        def module_name?(type_name)
-          entry = env.class_decls[type_name] and entry.is_a?(RBS::Environment::ModuleEntry)
-        end
-
         def class_name?(type_name)
-          entry = env.class_decls[type_name] and entry.is_a?(RBS::Environment::ClassEntry)
+          if entry = env.class_decls[type_name]
+            entry.is_a?(RBS::Environment::ClassEntry)
+          else
+            false
+          end
         end
 
         def env
-          @env ||= definition_builder.env
+          definition_builder.env
         end
 
         def absolute_type(type, context:)
@@ -939,6 +403,26 @@ module Steep
 
           AST::Types::Name::Instance.new(location: location, name: type_name, args: args)
         end
+
+        def try_instance_type(type)
+          case type
+          when AST::Types::Name::Instance
+            instance_type(type.name)
+          when AST::Types::Name::Singleton
+            instance_type(type.name)
+          else
+            nil
+          end
+        end
+
+        def try_singleton_type(type)
+          case type
+          when AST::Types::Name::Instance, AST::Types::Name::Singleton
+            AST::Types::Name::Singleton.new(name:type.name)
+          else
+            nil
+          end
+        end
       end
     end
   end