steep 0.34.0 → 0.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec77465913e4b2146e068c58f63b7ae8b5c51fd2391f6eb2776dba8372a81c2
-  data.tar.gz: 7528dbaf4873d9eb77728521837ecb0fe43a2010036572be2c3dc017c5b903cc
+  metadata.gz: 33c89b6005654ebdc947af336b1c7fa47e02c45c480d27b9f4ef0ab6d3403dd1
+  data.tar.gz: be7b7812e1ba321b91680884fccc55fd57dd5836c89bf7817624b72706490d6e
 SHA512:
-  metadata.gz: b0426373f8fb9e48ccec48d0676d70d5a674a389a83624df78dc3deacaba23840b02cc94becba92304de35f98c8d8bb3af12ef185161e4e6a6c37600cb61a82d
-  data.tar.gz: 5f3a32240541f116b6299c354fada0c8de398b6139b9d5e275e7b05490ccc401aa1b4f70978af5561e2ce9c6c7bb2587c1c8e43801276c0875000496ed332a5b
+  metadata.gz: 36945eb5fe4a04061c87bc76488c65ef2b009fcdb8279fd542a1249a10a223cd9571371f333e4ec29870a66dd120c4d9e65d572a9d3c90d56dba5c2c1dd95761
+  data.tar.gz: d9c2e56878f06d71edeb9a10b275c19afd7ba42b1af16ef01ef890ca3791ad4f92f903f7679fcf77b310638b0d0f5fced596e094ec225ff2f567e0f063bfc527

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## master
 
+## 0.39.0 (2020-12-25)
+
+* Update RBS to 1.0.0 ([#282](https://github.com/soutaro/steep/pull/282))
+* Better `&&` and `||` typing ([#276](https://github.com/soutaro/steep/pull/276))
+* Type case based on literals ([#277](https://github.com/soutaro/steep/pull/277))
+* Type case improvements ([#279](https://github.com/soutaro/steep/pull/279), [#283](https://github.com/soutaro/steep/pull/283))
+* Improvements on untyped classes/modules, unsupported syntax error handling, and argument types in untyped methods ([#280](https://github.com/soutaro/steep/pull/280))
+* Fix `bot` and `top` type format ([#278](https://github.com/soutaro/steep/pull/278))
+* Colorfull error messages ([#273](https://github.com/soutaro/steep/pull/273))
+
+## 0.38.0 (2020-12-10)
+
+* Improve `break`/`next` typing ([#271](https://github.com/soutaro/steep/pull/271))
+* Add LSP `workspace/symbol` feature ([#267](https://github.com/soutaro/steep/pull/267))
+
+## 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))

data/lib/steep.rb

@@ -42,6 +42,8 @@ require "steep/ast/annotation/collection"
 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"
@@ -74,6 +76,10 @@ require "steep/type_inference/logic_type_interpreter"
 require "steep/type_inference/method_call"
 require "steep/ast/types"
 
+require "steep/index/rbs_index"
+require "steep/index/signature_symbol_provider"
+require "steep/index/source_index"
+
 require "steep/server/utils"
 require "steep/server/base_worker"
 require "steep/server/code_worker"

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

@@ -23,7 +23,7 @@ module Steep
         end
 
         def to_s
-          "⟘"
+          "bot"
         end
 
         include Helper::NoFreeVariables

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,8 +159,15 @@ 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
@@ -156,7 +177,10 @@ module Steep
           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)) },
@@ -170,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) },
@@ -202,13 +226,19 @@ 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_decls: method_decls
@@ -242,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,
@@ -338,6 +368,8 @@ module Steep
             ]
           when AST::Types::Name::Alias
             unwrap_optional(expand_alias(type))
+          when AST::Types::Boolean
+            [AST::Builtin.true_type, AST::Builtin.false_type]
           else
             [type, nil]
           end
@@ -354,7 +386,9 @@ module Steep
             when :is_a?, :kind_of?, :instance_of?
               if defined_in == RBS::BuiltinNames::Object.name && member.instance?
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsArg.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -363,7 +397,9 @@ module Steep
               when RBS::BuiltinNames::Object.name,
                 NilClassName
                 return method_type.with(
-                  return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ReceiverIsNil.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -373,7 +409,9 @@ module Steep
                 RBS::BuiltinNames::TrueClass.name,
                 RBS::BuiltinNames::FalseClass.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::Not.new(location: method_type.return_type.location)
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::Not.new(location: method_type.type.return_type.location)
+                  )
                 )
               end
 
@@ -381,7 +419,17 @@ module Steep
               case defined_in
               when RBS::BuiltinNames::Module.name
                 return method_type.with(
-                  return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.return_type.location)
+                  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
@@ -572,14 +620,17 @@ 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_decls: Set[]
                       )
                     } + aref.method_types
@@ -591,14 +642,17 @@ 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_decls: Set[]
                       )
                     } + update.method_types
@@ -610,9 +664,12 @@ 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_decls: Set[]
                       )
                     ]
@@ -624,9 +681,12 @@ 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_decls: Set[]
                       )
                     ]
@@ -651,14 +711,17 @@ module Steep
 
                       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_decls: Set[]
                       )
                     } + ref.method_types
@@ -671,14 +734,16 @@ 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_decls: Set[]
                       )
                     } + update.method_types
@@ -691,14 +756,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,
+                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

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

@@ -18,7 +18,7 @@ module Steep
           end
 
           def ==(other)
-            other.class ==self.class
+            other.class == self.class
           end
 
           alias eql? ==
@@ -57,6 +57,38 @@ module Steep
             @location = location
           end
         end
+
+        class ArgEqualsReceiver < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
+        class Env < Base
+          attr_reader :truthy, :falsy, :type
+
+          def initialize(truthy:, falsy:, type:, location: nil)
+            @truthy = truthy
+            @falsy = falsy
+            @type = type
+          end
+
+          def ==(other)
+            other.is_a?(Env) && other.truthy == truthy && other.falsy == falsy && other.type == type
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ truthy.hash ^ falsy.hash
+          end
+
+          def inspect
+            "#<Steep::AST::Types::Env @type=#{type}, @truthy=..., @falsy=...>"
+          end
+
+          alias to_s inspect
+        end
       end
     end
   end

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

@@ -3,68 +3,76 @@ module Steep
     module Types
       class Proc
         attr_reader :location
-        attr_reader :params
-        attr_reader :return_type
+        attr_reader :type
+        attr_reader :block
 
-        def initialize(params:, return_type:, location: nil)
+        def initialize(type:, block:, location: type.location)
+          @type = type
+          @block = block
           @location = location
-          @params = params
-          @return_type = return_type
         end
 
         def ==(other)
-          other.is_a?(self.class) &&
-            other.params == params &&
-            other.return_type == return_type
+          other.is_a?(self.class) && other.type == type && other.block == block
         end
 
         def hash
-          self.class.hash && params.hash && return_type.hash
+          self.class.hash ^ type.hash ^ block.hash
         end
 
         alias eql? ==
 
         def subst(s)
           self.class.new(
-            params: params.subst(s),
-            return_type: return_type.subst(s),
+            type: type.subst(s),
+            block: block&.subst(s),
             location: location
           )
         end
 
         def to_s
-          "^#{params} -> #{return_type}"
+          if block
+            "^#{type.params} #{block} -> #{type.return_type}"
+          else
+            "^#{type.params} -> #{type.return_type}"
+          end
         end
 
         def free_variables()
-          @fvs ||= Set.new.tap do |set|
-            set.merge(params.free_variables)
-            set.merge(return_type.free_variables)
+          @fvs ||= Set[].tap do |fvs|
+            fvs.merge(type.free_variables)
+            fvs.merge(block.free_variables) if block
           end
         end
 
         def level
-          children = params.each_type.to_a + [return_type]
+          children = type.params.each_type.to_a + [type.return_type]
+          if block
+            children.push(*block.type.params.each_type.to_a)
+            children.push(block.type.return_type)
+          end
           [0] + level_of_children(children)
         end
 
         def closed?
-          params.closed? && return_type.closed?
+          type.closed? && (block.nil? || block.closed?)
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location, params: params, return_type: return_type)
+          self.class.new(location: new_location, block: block, type: type)
         end
 
         def map_type(&block)
           self.class.new(
-            params: params.map_type(&block),
-            return_type: yield(return_type),
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
             location: location
           )
         end
 
         def one_arg?
+          params = type.params
+
           params.required.size == 1 &&
             params.optional.empty? &&
             !params.rest &&
@@ -78,6 +86,10 @@ module Steep
                              args: [],
                              location: location)
         end
+
+        def block_required?
+          block && !block.optional?
+        end
       end
     end
   end