steep 0.32.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aa3a8e2257e84d0ed22ede78f6ddc038a43bada5127863bf308ec00e5cb2ca6
-  data.tar.gz: fc29cc0b62e9a9c0bfdf3e1a2093e50bb6a53c474ca5de9472a7297694f6f020
+  metadata.gz: f3d9186b6988081611f8bf060700ad97eb408ab605ab11ab32b717b9a0e9b8b9
+  data.tar.gz: 6f308f7bd551472237d5857614b765468782290733514793b2dfe35a3ac232cf
 SHA512:
-  metadata.gz: 827e7bf852501b156d0f77b4120401ad02a5ed070335342d7b316f37c286f347cc183e2f1a68849c9f0d2f78cdd53d64a0a8151f2958d8b7562fda0afb256ccc
-  data.tar.gz: 72444df723fe5ffaf552e6e5e92e7318c71d5ed9b2d77048faa928368626423b59ed9046b4a16cc916819f4fef8343b5e1866f9715ed95c701770dc49ec6a47d
+  metadata.gz: 1fee308a7783a6e54c974c71c78189492c0f557528bccb0da530927cfdb4e4a16f4ff6cd2ec9f8c3292dd9839bb1637f68fd3aff9da0fef6783e3f4b5d838984
+  data.tar.gz: 7cd72caf879d339e5fec0bed219957befd40d5dc2466b345435f4b523c8028a9264404b1d9c695c11ca638b8e6bbeb1d1ad8f600367cd87bf9b3c4fade99eeaa

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## master
 
+## 0.37.0 (2020-12-06)
+
+* Update to RBS 0.20.0 with _singleton attribute_ syntax and _proc types with blocks_. ([#264](https://github.com/soutaro/steep/pull/264))
+
+## 0.36.0 (2020-11-16)
+
+* Flow-sensitive typing improvements with `||` and `&&` ([#260](https://github.com/soutaro/steep/pull/260))
+* Type-case improvement ([#259](https://github.com/soutaro/steep/pull/259))
+* Subtyping between `bool` and logic types ([#258](https://github.com/soutaro/steep/pull/258))
+
+## 0.35.0 (2020-11-14)
+
+* Support third party RBS repository ([#231](https://github.com/soutaro/steep/pull/231), [#254](https://github.com/soutaro/steep/pull/254), [#255](https://github.com/soutaro/steep/pull/255))
+* Boolean type semantics update ([#252](https://github.com/soutaro/steep/pull/252))
+* More flexible record typing ([#256](https://github.com/soutaro/steep/pull/256))
+
+## 0.34.0 (2020-10-27)
+
+* Add `steep stats` command to show method call typing stats ([#246](https://github.com/soutaro/steep/pull/246))
+* Fix attribute assignment typing ([#243](https://github.com/soutaro/steep/pull/243))
+* Let `Range[T]` be covariant ([#242](https://github.com/soutaro/steep/pull/242))
+* Fix constant typing ([#247](https://github.com/soutaro/steep/pull/247), [#248](https://github.com/soutaro/steep/pull/248))
+
+## 0.33.0 (2020-10-13)
+
+* Make `!` typing flow sensitive ([#240](https://github.com/soutaro/steep/pull/240))
+
 ## 0.32.0 (2020-10-09)
 
 * Let type-case support interface types ([#237](https://github.com/soutaro/steep/pull/237))

data/lib/steep.rb

@@ -16,7 +16,7 @@ require 'uri'
 
 require "rbs"
 
-require "steep/ast/location"
+require "steep/method_name"
 require "steep/ast/types/helper"
 require "steep/ast/types/any"
 require "steep/ast/types/instance"
@@ -39,10 +39,11 @@ require "steep/ast/types/logic"
 require "steep/ast/type_params"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
-require "steep/ast/buffer"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"
 
+require "steep/interface/function"
+require "steep/interface/block"
 require "steep/interface/method_type"
 require "steep/interface/substitution"
 require "steep/interface/interface"
@@ -72,6 +73,7 @@ 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/type_inference/method_call"
 require "steep/ast/types"
 
 require "steep/server/utils"
@@ -93,6 +95,7 @@ require "steep/project/hover_content"
 require "steep/project/completion_provider"
 require "steep/drivers/utils/driver_helper"
 require "steep/drivers/check"
+require "steep/drivers/stats"
 require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/watch"

data/lib/steep/annotation_parser.rb

@@ -68,7 +68,7 @@ module Steep
           name = match[:name]
           type = match[:type]
 
-          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new)
+          method_type = factory.method_type(RBS::Parser.parse_method_type(type), self_type: AST::Types::Self.new, method_decls: Set[])
 
           AST::Annotation::MethodType.new(name: name.to_sym,
                                           type: method_type,

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

@@ -75,9 +75,23 @@ module Steep
             end
             Record.new(elements: elements, location: nil)
           when RBS::Types::Proc
-            params = params(type.type)
-            return_type = type(type.type.return_type)
-            Proc.new(params: params, return_type: return_type, location: nil)
+            func = Interface::Function.new(
+              params: params(type.type),
+              return_type: type(type.type.return_type),
+              location: type.location
+            )
+            block = if type.block
+                      Interface::Block.new(
+                        type: Interface::Function.new(
+                          params: params(type.block.type),
+                          return_type: type(type.block.type.return_type),
+                          location: type.location
+                        ),
+                        optional: !type.block.required
+                      )
+                    end
+
+            Proc.new(type: func, block: block)
           else
             raise "Unexpected type given: #{type}"
           end
@@ -145,16 +159,28 @@ module Steep
             end
             RBS::Types::Record.new(fields: fields, location: nil)
           when Proc
+            block = if type.block
+                      RBS::Types::Block.new(
+                        type: function_1(type.block.type),
+                        required: !type.block.optional?
+                      )
+                    end
             RBS::Types::Proc.new(
-              type: function_1(type.params, type.return_type),
+              type: function_1(type.type),
+              block: block,
               location: nil
             )
+          when Logic::Base
+            RBS::Types::Bases::Bool.new(location: nil)
           else
             raise "Unexpected type given: #{type} (#{type.class})"
           end
         end
 
-        def function_1(params, return_type)
+        def function_1(func)
+          params = func.params
+          return_type = func.return_type
+
           RBS::Types::Function.new(
             required_positionals: params.required.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
             optional_positionals: params.optional.map {|type| RBS::Types::Function::Param.new(name: nil, type: type_1(type)) },
@@ -168,7 +194,7 @@ module Steep
         end
 
         def params(type)
-          Interface::Params.new(
+          Interface::Function::Params.new(
             required: type.required_positionals.map {|param| type(param.type) },
             optional: type.optional_positionals.map {|param| type(param.type) },
             rest: type.rest_positionals&.yield_self {|param| type(param.type) },
@@ -178,7 +204,7 @@ module Steep
           )
         end
 
-        def method_type(method_type, self_type:, subst2: nil, method_def: nil)
+        def method_type(method_type, self_type:, subst2: nil, method_decls:)
           fvs = self_type.free_variables()
 
           type_params = []
@@ -200,17 +226,22 @@ module Steep
 
           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),
+            type: Interface::Function.new(
+              params: params(method_type.type).subst(subst),
+              return_type: type(method_type.type.return_type).subst(subst),
+              location: method_type.location
+            ),
             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)
+                type: Interface::Function.new(
+                  params: params(block.type).subst(subst),
+                  return_type: type(block.type.return_type).subst(subst),
+                  location: nil
+                )
               )
             end,
-            method_def: method_def,
-            location: method_def&.member&.location
+            method_decls: method_decls
           )
 
           if block_given?
@@ -241,12 +272,12 @@ module Steep
 
           type = RBS::MethodType.new(
             type_params: type_params,
-            type: function_1(method_type.params.subst(subst), method_type.return_type.subst(subst)),
+            type: function_1(method_type.type.subst(subst)),
             block: method_type.block&.yield_self do |block|
               block_type = block.type.subst(subst)
 
-              RBS::MethodType::Block.new(
-                type: function_1(block_type.params, block_type.return_type),
+              RBS::Types::Block.new(
+                type: function_1(block_type),
                 required: !block.optional
               )
             end,
@@ -342,48 +373,54 @@ module Steep
           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)
+        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
+                )
+              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)
+            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
+                )
+              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)
+            when :!
+              case defined_in
+              when RBS::BuiltinNames::BasicObject.name,
+                RBS::BuiltinNames::TrueClass.name,
+                RBS::BuiltinNames::FalseClass.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
+                )
+              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)
+            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)
                   )
-                end
+                )
               end
             end
           end
@@ -409,7 +446,7 @@ module Steep
             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)
@@ -433,10 +470,13 @@ module Steep
 
                   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_def: type_def,
+                                    method_decls: Set[decl],
                                     self_type: self_type,
                                     subst2: subst)
                       )
@@ -460,7 +500,11 @@ module Steep
               definition.methods.each do |name, method|
                 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)
+                    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
@@ -485,10 +529,16 @@ module Steep
 
                 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_def: type_def,
+                                  method_decls: Set[decl],
                                   self_type: self_type,
                                   subst2: subst)
                     )
@@ -560,16 +610,18 @@ module Steep
                     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)],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index)],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + aref.method_types
                   )
@@ -580,16 +632,18 @@ module Steep
                     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],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: elem_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: elem_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + update.method_types
                   )
@@ -600,11 +654,13 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types[0] || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types[0] || AST::Builtin.nil_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     ]
                   )
@@ -615,11 +671,13 @@ module Steep
                     method_types: [
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.empty,
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.empty,
+                          return_type: type.types.last || AST::Builtin.nil_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: type.types.last || AST::Builtin.nil_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     ]
                   )
@@ -640,18 +698,21 @@ module Steep
                   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: [],
-                        params: Interface::Params.new(required: [key_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil
+                        ),
                         block: nil,
-                        return_type: value_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + ref.method_types
                   )
@@ -663,16 +724,17 @@ module Steep
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
-                        params: Interface::Params.new(required: [key_type, value_type],
-                                                      optional: [],
-                                                      rest: nil,
-                                                      required_keywords: {},
-                                                      optional_keywords: {},
-                                                      rest_keywords: nil),
+                        type: Interface::Function.new(
+                          params: Interface::Function::Params.new(required: [key_type, value_type],
+                                                                  optional: [],
+                                                                  rest: nil,
+                                                                  required_keywords: {},
+                                                                  optional_keywords: {},
+                                                                  rest_keywords: nil),
+                          return_type: value_type,
+                          location: nil),
                         block: nil,
-                        return_type: value_type,
-                        method_def: nil,
-                        location: nil
+                        method_decls: Set[]
                       )
                     } + update.method_types
                   )
@@ -684,15 +746,18 @@ module Steep
             interface(Builtin::Proc.instance_type, private: private, self_type: self_type).tap do |interface|
               method_type = Interface::MethodType.new(
                 type_params: [],
-                params: type.params,
-                return_type: type.return_type,
-                block: nil,
-                method_def: nil,
-                location: nil
+                type: type.type,
+                block: type.block,
+                method_decls: Set[]
               )
 
-              interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])
               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