steep 1.8.0.dev.1 → 1.8.0.pre.1

data/lib/steep/drivers/watch.rb

@@ -59,7 +59,7 @@ module Steep
         end
 
         initialize_id = request_id()
-        client_writer.write(method: "initialize", id: initialize_id)
+        client_writer.write(method: "initialize", id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS)
         wait_for_response_id(reader: client_reader, id: initialize_id)
 
         Steep.logger.info "Watching #{dirs.join(", ")}..."
@@ -112,7 +112,7 @@ module Steep
             end
           end
 
-          client_writer.write(method: "$/typecheck", params: { guid: nil })
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
 
           stdout.puts Rainbow("done!").bold
         end.tap(&:start)
@@ -120,7 +120,7 @@ module Steep
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
 
-          client_writer.write(method: "$/typecheck", params: { guid: nil })
+          client_writer.write(Server::CustomMethods::TypeCheck.request(SecureRandom.uuid, { guid: nil }))
 
           client_reader.read do |response|
             case response[:method]

data/lib/steep/interface/builder.rb

@@ -277,15 +277,14 @@ module Steep
 
           definition.methods.each do |name, method|
             Steep.logger.tagged "method = #{type_name}.#{name}" do
-              shape.methods[name] = Interface::Shape::Entry.new(
-                private_method: method.private?,
-                method_types: method.defs.map do |type_def|
-                  method_name = method_name_for(type_def, name)
-                  decl = TypeInference::MethodCall::MethodDecl.new(method_name: method_name, method_def: type_def)
-                  method_type = factory.method_type(type_def.type, method_decls: Set[decl])
-                  replace_primitive_method(method_name, type_def, method_type)
-                end
-              )
+              overloads = method.defs.map do |type_def|
+                method_name = method_name_for(type_def, name)
+                method_type = factory.method_type(type_def.type)
+                method_type = replace_primitive_method(method_name, type_def, method_type)
+                Shape::MethodOverload.new(method_type, [type_def])
+              end
+
+              shape.methods[name] = Interface::Shape::Entry.new(method_name: name, private_method: method.private?, overloads: overloads)
             end
           end
 
@@ -308,15 +307,14 @@ module Steep
 
           definition.methods.each do |name, method|
             Steep.logger.tagged "method = #{type_name}##{name}" do
-              shape.methods[name] = Interface::Shape::Entry.new(
-                private_method: method.private?,
-                method_types: method.defs.map do |type_def|
-                  method_name = method_name_for(type_def, name)
-                  decl = TypeInference::MethodCall::MethodDecl.new(method_name: method_name, method_def: type_def)
-                  method_type = factory.method_type(type_def.type, method_decls: Set[decl])
-                  replace_primitive_method(method_name, type_def, method_type)
-                end
-              )
+              overloads = method.defs.map do |type_def|
+                method_name = method_name_for(type_def, name)
+                method_type = factory.method_type(type_def.type)
+                method_type = replace_primitive_method(method_name, type_def, method_type)
+                Shape::MethodOverload.new(method_type, [type_def])
+              end
+
+              shape.methods[name] = Interface::Shape::Entry.new(method_name: name, private_method: method.private?, overloads: overloads)
             end
           end
 
@@ -334,51 +332,49 @@ module Steep
 
         shape = Interface::Shape.new(type: shape_type, private: true)
         all_common_methods.each do |method_name|
-          method_typess = [] #: Array[Array[MethodType]]
+          overloadss = [] #: Array[Array[Shape::MethodOverload]]
           private_method = false
           shapes.each do |shape|
             entry = shape.methods[method_name] || raise
-            method_typess << entry.method_types
+            overloadss << entry.overloads
             private_method ||= entry.private_method?
           end
 
-          shape.methods[method_name] = Interface::Shape::Entry.new(private_method: private_method) do
-            method_typess.inject do |types1, types2|
+          shape.methods[method_name] = Interface::Shape::Entry.new(method_name: method_name, private_method: private_method) do
+            overloadss.inject do |overloads1, overloads2|
               # @type break: nil
 
-              if types1 == types2
-                decl_array1 = types1.map(&:method_decls)
-                decl_array2 = types2.map(&:method_decls)
-
-                if decl_array1 == decl_array2
-                  next types1
-                end
+              types1 = overloads1.map(&:method_type)
+              types2 = overloads2.map(&:method_type)
 
-                decls1 = decl_array1.each.with_object(Set[]) {|array, decls| decls.merge(array) } #$ Set[TypeInference::MethodCall::MethodDecl]
-                decls2 = decl_array2.each.with_object(Set[]) {|array, decls| decls.merge(array) } #$ Set[TypeInference::MethodCall::MethodDecl]
+              if types1 == types2
+                defs1 = overloads1.flat_map(&:method_defs)
+                defs2 = overloads2.flat_map(&:method_defs)
 
-                if decls1 == decls2
-                  next types1
+                if defs1 == defs2
+                  next overloads1
                 end
               end
 
-              method_types = {} #: Hash[MethodType, bool]
+              method_overloads = {} #: Hash[Shape::MethodOverload, bool]
 
-              types1.each do |type1|
-                types2.each do |type2|
-                  if type1 == type2
-                    method_types[type1.with(method_decls: type1.method_decls + type2.method_decls)] = true
+              overloads1.each do |overload1|
+                overloads2.each do |overload2|
+                  if overload1.method_type == overload2.method_type
+                    overload = Shape::MethodOverload.new(overload1.method_type, overload1.method_defs + overload2.method_defs)
+                    method_overloads[overload] = true
                   else
-                    if type = MethodType.union(type1, type2, subtyping)
-                      method_types[type] = true
+                    if type = MethodType.union(overload1.method_type, overload2.method_type, subtyping)
+                      overload = Shape::MethodOverload.new(type, overload1.method_defs + overload2.method_defs)
+                      method_overloads[overload] = true
                     end
                   end
                 end
               end
 
-              break nil if method_types.empty?
+              break nil if method_overloads.empty?
 
-              method_types.keys
+              method_overloads.keys
             end
           end
         end
@@ -427,7 +423,7 @@ module Steep
       end
 
       def tuple_shape(tuple)
-        element_type = AST::Types::Union.build(types: tuple.types, location: nil)
+        element_type = AST::Types::Union.build(types: tuple.types)
         array_type = AST::Builtin::Array.instance_type(element_type)
 
         array_shape = yield(array_type) or raise
@@ -438,19 +434,22 @@ module Steep
           raise unless aref
 
           Shape::Entry.new(
+            method_name: :[],
             private_method: false,
-            method_types: tuple.types.map.with_index {|elem_type, index|
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
-                  return_type: elem_type,
-                  location: nil
+            overloads: tuple.types.map.with_index {|elem_type, index|
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.build(required: [AST::Types::Literal.new(value: index)]),
+                    return_type: elem_type,
+                    location: nil
+                  ),
+                  block: nil
                 ),
-                block: nil,
-                method_decls: Set[]
+                []
               )
-            } + aref.method_types
+            } + aref.overloads
           )
         end
 
@@ -458,19 +457,22 @@ module Steep
           raise unless update
 
           Shape::Entry.new(
+            method_name: :[]=,
             private_method: false,
-            method_types: tuple.types.map.with_index {|elem_type, index|
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.build(required: [AST::Types::Literal.new(value: index), elem_type]),
-                  return_type: elem_type,
-                  location: nil
+            overloads: tuple.types.map.with_index {|elem_type, index|
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.build(required: [AST::Types::Literal.new(value: index), elem_type]),
+                    return_type: elem_type,
+                    location: nil
+                  ),
+                  block: nil
                 ),
-                block: nil,
-                method_decls: Set[]
+                []
               )
-            } + update.method_types
+            } + update.overloads
           )
         end
 
@@ -478,8 +480,9 @@ module Steep
           raise unless fetch
 
           Shape::Entry.new(
+            method_name: :fetch,
             private_method: false,
-            method_types: tuple.types.flat_map.with_index {|elem_type, index|
+            overloads: tuple.types.flat_map.with_index {|elem_type, index|
               [
                 MethodType.new(
                   type_params: [],
@@ -488,11 +491,10 @@ module Steep
                     return_type: elem_type,
                     location: nil
                   ),
-                  block: nil,
-                  method_decls: Set[]
+                  block: nil
                 ),
                 MethodType.new(
-                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false, default_type: nil)],
                   type: Function.new(
                     params: Function::Params.build(
                       required: [
@@ -503,11 +505,10 @@ module Steep
                     return_type: AST::Types::Union.build(types: [elem_type, AST::Types::Var.new(name: :T)]),
                     location: nil
                   ),
-                  block: nil,
-                  method_decls: Set[]
+                  block: nil
                 ),
                 MethodType.new(
-                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false, default_type: nil)],
                   type: Function.new(
                     params: 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)]),
@@ -521,27 +522,29 @@ module Steep
                     ),
                     optional: false,
                     self_type: nil
-                  ),
-                  method_decls: Set[]
+                  )
                 )
-              ]
-            } + fetch.method_types
+              ].map { Shape::MethodOverload.new(_1, []) }
+            } + fetch.overloads
           )
         end
 
         first_entry = array_shape.methods[:first].yield_self do |first|
           Shape::Entry.new(
+            method_name: :first,
             private_method: false,
-            method_types: [
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.empty,
-                  return_type: tuple.types[0] || AST::Builtin.nil_type,
-                  location: nil
+            overloads: [
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.empty,
+                    return_type: tuple.types[0] || AST::Builtin.nil_type,
+                    location: nil
+                  ),
+                  block: nil
                 ),
-                block: nil,
-                method_decls: Set[]
+                []
               )
             ]
           )
@@ -549,17 +552,20 @@ module Steep
 
         last_entry = array_shape.methods[:last].yield_self do |last|
           Shape::Entry.new(
+            method_name: :last,
             private_method: false,
-            method_types: [
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.empty,
-                  return_type: tuple.types.last || AST::Builtin.nil_type,
-                  location: nil
+            overloads: [
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.empty,
+                    return_type: tuple.types.last || AST::Builtin.nil_type,
+                    location: nil
+                  ),
+                  block: nil
                 ),
-                block: nil,
-                method_decls: Set[]
+                []
               )
             ]
           )
@@ -576,10 +582,9 @@ module Steep
 
       def record_shape(record)
         all_key_type = AST::Types::Union.build(
-          types: record.elements.each_key.map {|value| AST::Types::Literal.new(value: value, location: nil) },
-          location: nil
+          types: record.elements.each_key.map {|value| AST::Types::Literal.new(value: value) }
         )
-        all_value_type = AST::Types::Union.build(types: record.elements.values, location: nil)
+        all_value_type = AST::Types::Union.build(types: record.elements.values)
         hash_type = AST::Builtin::Hash.instance_type(all_key_type, all_value_type)
 
         hash_shape = yield(hash_type) or raise
@@ -589,21 +594,28 @@ module Steep
         shape.methods[:[]] = hash_shape.methods[:[]].yield_self do |aref|
           aref or raise
           Shape::Entry.new(
+            method_name: :[],
             private_method: false,
-            method_types: record.elements.map do |key_value, value_type|
-              key_type = AST::Types::Literal.new(value: key_value, location: nil)
-
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.build(required: [key_type]),
-                  return_type: value_type,
-                  location: nil
+            overloads: record.elements.map do |key_value, value_type|
+              key_type = AST::Types::Literal.new(value: key_value)
+
+              if record.optional?(key_value)
+                value_type = AST::Builtin.optional(value_type)
+              end
+
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.build(required: [key_type]),
+                    return_type: value_type,
+                    location: nil
+                  ),
+                  block: nil
                 ),
-                block: nil,
-                method_decls: Set[]
+                []
               )
-            end + aref.method_types
+            end + aref.overloads
           )
         end
 
@@ -611,19 +623,22 @@ module Steep
           update or raise
 
           Shape::Entry.new(
+            method_name: :[]=,
             private_method: false,
-            method_types: record.elements.map do |key_value, value_type|
-              key_type = AST::Types::Literal.new(value: key_value, location: nil)
-              MethodType.new(
-                type_params: [],
-                type: Function.new(
-                  params: Function::Params.build(required: [key_type, value_type]),
-                  return_type: value_type,
-                  location: nil),
-                block: nil,
-                method_decls: Set[]
+            overloads: record.elements.map do |key_value, value_type|
+              key_type = AST::Types::Literal.new(value: key_value)
+              Shape::MethodOverload.new(
+                MethodType.new(
+                  type_params: [],
+                  type: Function.new(
+                    params: Function::Params.build(required: [key_type, value_type]),
+                    return_type: value_type,
+                    location: nil),
+                  block: nil
+                ),
+                []
               )
-            end + update.method_types
+            end + update.overloads
           )
         end
 
@@ -631,9 +646,10 @@ module Steep
           update or raise
 
           Shape::Entry.new(
+            method_name: :fetch,
             private_method: false,
-            method_types: record.elements.flat_map {|key_value, value_type|
-              key_type = AST::Types::Literal.new(value: key_value, location: nil)
+            overloads: record.elements.flat_map {|key_value, value_type|
+              key_type = AST::Types::Literal.new(value: key_value)
 
               [
                 MethodType.new(
@@ -643,21 +659,19 @@ module Steep
                     return_type: value_type,
                     location: nil
                   ),
-                  block: nil,
-                  method_decls: Set[]
+                  block: nil
                 ),
                 MethodType.new(
-                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false, default_type: nil)],
                   type: Function.new(
                     params: 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[]
+                  block: nil
                 ),
                 MethodType.new(
-                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false)],
+                  type_params: [TypeParam.new(name: :T, upper_bound: nil, variance: :invariant, unchecked: false, default_type: nil)],
                   type: Function.new(
                     params: Function::Params.build(required: [key_type]),
                     return_type: AST::Types::Union.build(types: [value_type, AST::Types::Var.new(name: :T)]),
@@ -671,11 +685,10 @@ module Steep
                     ),
                     optional: false,
                     self_type: nil
-                  ),
-                  method_decls: Set[]
+                  )
                 )
-              ]
-            } + update.method_types
+              ].map { Shape::MethodOverload.new(_1, []) }
+            } + update.overloads
           )
         end
 
@@ -686,9 +699,20 @@ module Steep
         shape = Shape.new(type: proc, private: true)
         shape.methods.merge!(proc_shape.methods)
 
-        shape.methods[:[]] = shape.methods[:call] = Shape::Entry.new(
+        overload = Shape::MethodOverload.new(
+          MethodType.new(type_params: [], type: proc.type, block: proc.block),
+          []
+        )
+
+        shape.methods[:[]] = Shape::Entry.new(
+          method_name: :[],
+          private_method: false,
+          overloads: [overload]
+        )
+        shape.methods[:call] = Shape::Entry.new(
+          method_name: :call,
           private_method: false,
-          method_types: [MethodType.new(type_params: [], type: proc.type, block: proc.block, method_decls: Set[])]
+          overloads: [overload]
         )
 
         shape
@@ -707,7 +731,7 @@ module Steep
               if 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)
+                    return_type: AST::Types::Logic::ReceiverIsArg.instance()
                   )
                 )
               end
@@ -721,7 +745,7 @@ module Steep
               if member.instance?
                 return method_type.with(
                   type: method_type.type.with(
-                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.type.return_type.location)
+                    return_type: AST::Types::Logic::ReceiverIsNil.instance()
                   )
                 )
             end
@@ -735,7 +759,7 @@ module Steep
               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)
+                  return_type: AST::Types::Logic::Not.instance()
                 )
               )
             end
@@ -745,7 +769,7 @@ module Steep
             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)
+                  return_type: AST::Types::Logic::ArgIsReceiver.instance()
                 )
               )
             when RBS::BuiltinNames::Object.name,
@@ -759,7 +783,7 @@ module Steep
               # 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)
+                  return_type: AST::Types::Logic::ArgEqualsReceiver.instance()
                 )
               )
             end
@@ -768,7 +792,7 @@ module Steep
             when RBS::BuiltinNames::Module.name
               return method_type.with(
                 type: method_type.type.with(
-                  return_type: AST::Types::Logic::ArgIsAncestor.new(location: method_type.type.return_type.location)
+                  return_type: AST::Types::Logic::ArgIsAncestor.instance()
                 )
               )
             end

data/lib/steep/interface/method_type.rb

@@ -4,13 +4,11 @@ module Steep
       attr_reader :type_params
       attr_reader :type
       attr_reader :block
-      attr_reader :method_decls
 
-      def initialize(type_params:, type:, block:, method_decls:)
+      def initialize(type_params:, type:, block:)
         @type_params = type_params
         @type = type
         @block = block
-        @method_decls = method_decls
       end
 
       def ==(other)
@@ -52,7 +50,7 @@ module Steep
         if ty == type && bl == block
           self
         else
-          self.class.new(type_params: type_params, type: ty, block: bl, method_decls: method_decls)
+          self.class.new(type_params: type_params, type: ty, block: bl)
         end
       end
 
@@ -72,15 +70,13 @@ module Steep
       def instantiate(s)
         self.class.new(type_params: [],
                        type: type.subst(s),
-                       block: block&.subst(s),
-                       method_decls: method_decls)
+                       block: block&.subst(s))
       end
 
-      def with(type_params: self.type_params, type: self.type, block: self.block, method_decls: self.method_decls)
+      def with(type_params: self.type_params, type: self.type, block: self.block)
         self.class.new(type_params: type_params,
                        type: type,
-                       block: block,
-                       method_decls: method_decls)
+                       block: block)
       end
 
       def to_s
@@ -95,8 +91,7 @@ module Steep
       def map_type(&block)
         self.class.new(type_params: type_params,
                        type: type.map_type(&block),
-                       block: self.block&.yield_self {|blk| blk.map_type(&block) },
-                       method_decls: method_decls)
+                       block: self.block&.yield_self {|blk| blk.map_type(&block) })
       end
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
@@ -125,8 +120,7 @@ module Steep
             ),
             location: nil
           ),
-          block: block,
-          method_decls: method_decls + other.method_decls
+          block: block
         )
       end
 
@@ -245,7 +239,7 @@ module Steep
               when (self_self = b.self_type) && (other_self = ob.self_type)
                 AST::Types::Union.build(types: [self_self, other_self])
               when b.self_type || ob.self_type
-                AST::Types::Bot.new()
+                AST::Types::Bot.instance
               else
                 nil
               end
@@ -280,8 +274,7 @@ module Steep
         MethodType.new(
           type_params: [],
           type: Function.new(params: params, return_type: return_type, location: nil),
-          block: block,
-          method_decls: method_decls + other.method_decls
+          block: block
         )
       end
 
@@ -293,7 +286,7 @@ module Steep
         else
           params = self.type.params || other.type.params
         end
-        
+
         block =
           case
           when (b = self.block) && (ob = other.block)
@@ -302,7 +295,7 @@ module Steep
               when (self_self = b.self_type) && (other_self = ob.self_type)
                 AST::Types::Intersection.build(types: [self_self, other_self])
               when b.self_type || ob.self_type
-                AST::Types::Top.new()
+                AST::Types::Top.instance
               else
                 nil
               end
@@ -324,8 +317,7 @@ module Steep
         MethodType.new(
           type_params: [],
           type: Function.new(params: params, return_type: return_type, location: nil),
-          block: block,
-          method_decls: method_decls + other.method_decls
+          block: block
         )
       end
     end