steep 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e364b23ebecd35868dbde7ea09938fa8208219ee1fcd19a0faaa9a160f6aab'
-  data.tar.gz: c4374adcf1b0c54663e04380229322d9c07865fac69b1b74fa2eeabecd26cd7d
+  metadata.gz: 8e15a2388cd89e6b169243007211840853be8c126e035f7aa6434b00258e1087
+  data.tar.gz: e3bb8c7a1d816cb2667e7dc977f5e3155bcb9444e995a210bd58dc716a6a71b7
 SHA512:
-  metadata.gz: e59635b6fba6e2dac0c7ba8fb12d9a4e4734ffd95a48b8af1cb2cdbb0a5280d660c46fbf724ea48a61247165319b448598f702d6ef0dbf78d28b78dcb7ba536c
-  data.tar.gz: 62ca2d4504a4d75922abf3b76def89f0146a298b3452a874d98a869fa3f39942984224324cdec93f7894918b4386a07aabb4a1be6f572bcbbb5d3081086b1cda
+  metadata.gz: fb77f06dcef27e222984269a637966fa581cd78b3157c31a71793e8447f7059467140b7bb3f8f3e7f059a37492c9988f428234011ff7b3f7133a627f60a63cf4
+  data.tar.gz: 9319aebc6f74f89d055098312f460b2ed86ae9cfcd5c17bd21425c69e3ebe8838dffa3f4db9c99bc23bbc4657e4ee9f453bf1a2b3b7e4afe1531c0ba0ccb386c

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## master
 
+## 0.28.0 (2020-09-17)
+
+* Fix typing case-when with empty body ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix lvasgn typing with `void` type hint ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix subtype checking between type variables and union types ([#200](https://github.com/soutaro/steep/pull/200))
+* Support endless range ([#200](https://github.com/soutaro/steep/pull/200))
+* Fix optarg, kwoptarg typing ([#202](https://github.com/soutaro/steep/pull/202))
+* Better union/intersection types ([#204](https://github.com/soutaro/steep/pull/204))
+* Fix generic method instantiation ([#205](https://github.com/soutaro/steep/pull/205))
+* Fix module typing ([#206](https://github.com/soutaro/steep/pull/206))
+* Fix shutdown problem ([#209](https://github.com/soutaro/steep/pull/209))
+* Update RBS to 0.12.0 ([#210](https://github.com/soutaro/steep/pull/210))
+* Improve processing singleton class decls without RBS ([#211](https://github.com/soutaro/steep/pull/211))
+* Improve processing block parameter with masgn ([#212](https://github.com/soutaro/steep/pull/212))
+
 ## 0.27.0 (2020-08-31)
 
 * Make tuple types _covariant_ ([#195](https://github.com/soutaro/steep/pull/195))

data/bin/smoke_runner.rb

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

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby25"
+require "parser/ruby27"
 require "ast_utils"
 require "active_support/core_ext/object/try"
 require "logger"

data/lib/steep/ast/builtin.rb

@@ -15,12 +15,8 @@ module Steep
           Types::Name::Instance.new(name: module_name, args: args)
         end
 
-        def class_type(constructor: nil)
-          Types::Name::Class.new(name: module_name, constructor: constructor)
-        end
-
         def module_type
-          Types::Name::Module.new(name: module_name)
+          Types::Name::Singleton.new(name: module_name)
         end
 
         def instance_type?(type, args: nil)
@@ -36,22 +32,8 @@ module Steep
           end
         end
 
-        NONE = ::Object.new
-
-        def class_type?(type, constructor: NONE)
-          if type.is_a?(Types::Name::Class)
-            unless constructor.equal?(NONE)
-              type.name == module_name && type.name.constructor == constructor
-            else
-              type.name == module_name
-            end
-          else
-            false
-          end
-        end
-
         def module_type?(type)
-          if type.is_a?(Types::Name::Module)
+          if type.is_a?(Types::Name::Singleton)
             type.name == module_name
           else
             false

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

@@ -44,7 +44,7 @@ module Steep
             Var.new(name: type.name, location: nil)
           when RBS::Types::ClassSingleton
             type_name = type_name(type.name)
-            Name::Class.new(name: type_name, location: nil, constructor: nil)
+            Name::Singleton.new(name: type_name, location: nil)
           when RBS::Types::ClassInstance
             type_name = type_name(type.name)
             args = type.args.map {|arg| type(arg) }
@@ -102,7 +102,7 @@ module Steep
             RBS::Types::Bases::Nil.new(location: nil)
           when Var
             RBS::Types::Variable.new(name: type.name, location: nil)
-          when Name::Class, Name::Module
+          when Name::Singleton
             RBS::Types::ClassSingleton.new(name: type_name_1(type.name), location: nil)
           when Name::Instance
             RBS::Types::ClassInstance.new(
@@ -219,7 +219,7 @@ module Steep
             end
           end
           subst = Interface::Substitution.build(alpha_vars, alpha_types)
-          subst.merge!(subst2) if subst2
+          subst.merge!(subst2, overwrite: true) if subst2
 
           type = Interface::MethodType.new(
             type_params: type_params,
@@ -313,6 +313,7 @@ module Steep
         end
 
         def interface(type, private:, self_type: type)
+          Steep.logger.debug { "Factory#interface: #{type}, private=#{private}, self_type=#{self_type}" }
           type = expand_alias(type)
 
           case type
@@ -340,14 +341,15 @@ module Steep
               )
 
               definition.methods.each do |name, method|
-                next if method.private? && !private
+                Steep.logger.tagged "method = #{name}" do
+                  next if method.private? && !private
 
-                interface.methods[name] = Interface::Interface::Combination.overload(
-                  method.method_types.map do |type|
-                    method_type(type, self_type: self_type, subst2: subst)
-                  end,
-                  incompatible: name == :initialize || name == :new
-                )
+                  interface.methods[name] = Interface::Interface::Entry.new(
+                    method_types: method.method_types.map do |type|
+                      method_type(type, self_type: self_type, subst2: subst)
+                    end
+                  )
+                end
               end
             end
 
@@ -363,16 +365,15 @@ module Steep
               )
 
               definition.methods.each do |name, method|
-                interface.methods[name] = Interface::Interface::Combination.overload(
-                  method.method_types.map do |type|
+                interface.methods[name] = Interface::Interface::Entry.new(
+                  method_types: method.method_types.map do |type|
                     method_type(type, self_type: self_type, subst2: subst)
-                  end,
-                  incompatible: false
+                  end
                 )
               end
             end
 
-          when Name::Class, Name::Module
+          when Name::Singleton
             Interface::Interface.new(type: self_type, private: private).tap do |interface|
               definition = definition_builder.build_singleton(type_name_1(type.name))
 
@@ -389,11 +390,10 @@ module Steep
               definition.methods.each do |name, method|
                 next if !private && method.private?
 
-                interface.methods[name] = Interface::Interface::Combination.overload(
-                  method.method_types.map do |type|
+                interface.methods[name] = Interface::Interface::Entry.new(
+                  method_types: method.method_types.map do |type|
                     method_type(type, self_type: self_type, subst2: subst)
-                  end,
-                  incompatible: false
+                  end
                 )
               end
             end
@@ -416,7 +416,25 @@ module Steep
                 Interface::Interface.new(type: self_type, private: private).tap do |interface|
                   common_methods = Set.new(interface1.methods.keys) & Set.new(interface2.methods.keys)
                   common_methods.each do |name|
-                    interface.methods[name] = Interface::Interface::Combination.union([interface1.methods[name], interface2.methods[name]])
+                    types1 = interface1.methods[name].method_types
+                    types2 = interface2.methods[name].method_types
+
+                    if types1 == types2
+                      interface.methods[name] = interface1.methods[name]
+                    else
+                      method_types = {}
+
+                      types1.each do |type1|
+                        types2.each do |type2|
+                          type = type1 | type2 or next
+                          method_types[type] = true
+                        end
+                      end
+
+                      unless method_types.empty?
+                        interface.methods[name] = Interface::Interface::Entry.new(method_types: method_types.keys)
+                      end
+                    end
                   end
                 end
               end
@@ -427,11 +445,8 @@ module Steep
               interfaces = type.types.map {|ty| interface(ty, private: private, self_type: self_type) }
               interfaces.inject do |interface1, interface2|
                 Interface::Interface.new(type: self_type, private: private).tap do |interface|
-                  all_methods = Set.new(interface1.methods.keys) + Set.new(interface2.methods.keys)
-                  all_methods.each do |name|
-                    methods = [interface1.methods[name], interface2.methods[name]].compact
-                    interface.methods[name] = Interface::Interface::Combination.intersection(methods)
-                  end
+                  interface.methods.merge!(interface1.methods)
+                  interface.methods.merge!(interface2.methods)
                 end
               end
             end
@@ -442,8 +457,8 @@ module Steep
               array_type = Builtin::Array.instance_type(element_type)
               interface(array_type, private: private, self_type: self_type).tap do |array_interface|
                 array_interface.methods[:[]] = array_interface.methods[:[]].yield_self do |aref|
-                  Interface::Interface::Combination.overload(
-                    type.types.map.with_index {|elem_type, index|
+                  Interface::Interface::Entry.new(
+                    method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.new(required: [AST::Types::Literal.new(value: index)],
@@ -456,14 +471,13 @@ module Steep
                         return_type: elem_type,
                         location: nil
                       )
-                    } + aref.types,
-                    incompatible: false
+                    } + aref.method_types
                   )
                 end
 
                 array_interface.methods[:[]=] = array_interface.methods[:[]=].yield_self do |update|
-                  Interface::Interface::Combination.overload(
-                    type.types.map.with_index {|elem_type, index|
+                  Interface::Interface::Entry.new(
+                    method_types: type.types.map.with_index {|elem_type, index|
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.new(required: [AST::Types::Literal.new(value: index), elem_type],
@@ -476,14 +490,13 @@ module Steep
                         return_type: elem_type,
                         location: nil
                       )
-                    } + update.types,
-                    incompatible: false
+                    } + update.method_types
                   )
                 end
 
                 array_interface.methods[:first] = array_interface.methods[:first].yield_self do |first|
-                  Interface::Interface::Combination.overload(
-                    [
+                  Interface::Interface::Entry.new(
+                    method_types: [
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.empty,
@@ -491,14 +504,13 @@ module Steep
                         return_type: type.types[0] || AST::Builtin.nil_type,
                         location: nil
                       )
-                    ],
-                    incompatible: false
+                    ]
                   )
                 end
 
                 array_interface.methods[:last] = array_interface.methods[:last].yield_self do |last|
-                  Interface::Interface::Combination.overload(
-                    [
+                  Interface::Interface::Entry.new(
+                    method_types: [
                       Interface::MethodType.new(
                         type_params: [],
                         params: Interface::Params.empty,
@@ -506,8 +518,7 @@ module Steep
                         return_type: type.types.last || AST::Builtin.nil_type,
                         location: nil
                       )
-                    ],
-                    incompatible: false
+                    ]
                   )
                 end
               end
@@ -523,8 +534,8 @@ module Steep
 
               interface(hash_type, private: private, self_type: self_type).tap do |hash_interface|
                 hash_interface.methods[:[]] = hash_interface.methods[:[]].yield_self do |ref|
-                  Interface::Interface::Combination.overload(
-                    type.elements.map {|key_value, value_type|
+                  Interface::Interface::Entry.new(
+                    method_types: type.elements.map {|key_value, value_type|
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
@@ -538,14 +549,13 @@ module Steep
                         return_type: value_type,
                         location: nil
                       )
-                    } + ref.types,
-                    incompatible: false
+                    } + ref.method_types
                   )
                 end
 
                 hash_interface.methods[:[]=] = hash_interface.methods[:[]=].yield_self do |update|
-                  Interface::Interface::Combination.overload(
-                    type.elements.map {|key_value, value_type|
+                  Interface::Interface::Entry.new(
+                    method_types: type.elements.map {|key_value, value_type|
                       key_type = Literal.new(value: key_value, location: nil)
                       Interface::MethodType.new(
                         type_params: [],
@@ -559,8 +569,7 @@ module Steep
                         return_type: value_type,
                         location: nil
                       )
-                    } + update.types,
-                    incompatible: false
+                    } + update.method_types
                   )
                 end
               end
@@ -576,8 +585,8 @@ module Steep
                 location: nil
               )
 
-              interface.methods[:[]] = Interface::Interface::Combination.overload([method_type], incompatible: false)
-              interface.methods[:call] = Interface::Interface::Combination.overload([method_type], incompatible: false)
+              interface.methods[:[]] = Interface::Interface::Entry.new(method_types: [method_type])
+              interface.methods[:call] = Interface::Interface::Entry.new(method_types: [method_type])
             end
 
           else

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

@@ -28,33 +28,36 @@ module Steep
             else
               type
             end
-          end.compact.uniq.yield_self do |tys|
-            if tys.size == 1
+          end.compact.yield_self do |tys|
+            dups = Set.new(tys)
+
+            case dups.size
+            when 0
+              AST::Types::Top.new(location: location)
+            when 1
               tys.first
             else
-              new(types: tys.sort_by(&:hash), location: location)
+              new(types: dups.to_a, location: location)
             end
           end
         end
 
         def ==(other)
-          other.is_a?(Intersection) &&
-            other.types == types
+          other.is_a?(Intersection) && other.types == types
         end
 
         def hash
-          self.class.hash ^ types.hash
+          @hash ||= self.class.hash ^ types.hash
         end
 
         alias eql? ==
 
         def subst(s)
-          self.class.build(location: location,
-                           types: types.map {|ty| ty.subst(s) })
+          self.class.build(location: location, types: types.map {|ty| ty.subst(s) })
         end
 
         def to_s
-          "(#{types.map(&:to_s).sort.join(" & ")})"
+          "(#{types.map(&:to_s).join(" & ")})"
         end
 
         def free_variables()

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

@@ -79,59 +79,7 @@ module Steep
           end
         end
 
-        class Class < Base
-          attr_reader :constructor
-
-          def initialize(name:, constructor:, location: nil)
-            raise "Name should be a module name: #{name.inspect}" unless name.is_a?(Names::Module)
-            super(name: name, location: location)
-            @constructor = constructor
-          end
-
-          def ==(other)
-            other.class == self.class &&
-              other.name == name &&
-              other.constructor == constructor
-          end
-
-          alias eql? ==
-
-          def hash
-            self.class.hash ^ name.hash ^ constructor.hash
-          end
-
-          def to_s
-            k = case constructor
-                when true
-                  " constructor"
-                when false
-                  " noconstructor"
-                when nil
-                  ""
-                end
-            "singleton(#{name.to_s})"
-          end
-
-          def with_location(new_location)
-            self.class.new(name: name, constructor: constructor, location: new_location)
-          end
-
-          def to_instance(*args)
-            Instance.new(name: name, args: args)
-          end
-
-          NOTHING = ::Object.new
-
-          def updated(constructor: NOTHING)
-            if NOTHING == constructor
-              constructor = self.constructor
-            end
-
-            self.class.new(name: name, constructor: constructor, location: location)
-          end
-        end
-
-        class Module < Base
+        class Singleton < Base
           def ==(other)
             other.class == self.class &&
               other.name == name
@@ -153,12 +101,8 @@ module Steep
         end
 
         class Instance < Applying
-          def to_class(constructor:)
-            Class.new(name: name, location: location, constructor: constructor)
-          end
-
           def to_module
-            Module.new(name: name, location: location)
+            Singleton.new(name: name, location: location)
           end
         end