steep 0.38.0 → 0.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1662ab3cd8c9b1630d38939e491bd9db3b46701a5ab6f09061e4470c95fbbae8
-  data.tar.gz: 9fea79ba28f595b1a51812708c0b3a98170110f0367a0baa287623232fe64156
+  metadata.gz: 33c89b6005654ebdc947af336b1c7fa47e02c45c480d27b9f4ef0ab6d3403dd1
+  data.tar.gz: be7b7812e1ba321b91680884fccc55fd57dd5836c89bf7817624b72706490d6e
 SHA512:
-  metadata.gz: 2f42e7e12ff24d1d4acbebc7693b1bb7f1417f4d44f0cc2b2590990a50a1c20ee690d23a316414113e9a65601971cd3bf19b13babc9e09a64cfcebae1fe8c4ec
-  data.tar.gz: 6aa3693092fa2811fe0663c4266ed3cf9ccd2b79d7e0e8e6c3c79e3c3a29b1d19954ac0127ed0c62a1619dac2555c67ae987f3a4386001cbdf6a73a76e405829
+  metadata.gz: 36945eb5fe4a04061c87bc76488c65ef2b009fcdb8279fd542a1249a10a223cd9571371f333e4ec29870a66dd120c4d9e65d572a9d3c90d56dba5c2c1dd95761
+  data.tar.gz: d9c2e56878f06d71edeb9a10b275c19afd7ba42b1af16ef01ef890ca3791ad4f92f903f7679fcf77b310638b0d0f5fced596e094ec225ff2f567e0f063bfc527

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## 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))

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

@@ -368,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
@@ -421,6 +423,14 @@ module Steep
                     return_type: AST::Types::Logic::ArgIsReceiver.new(location: method_type.type.return_type.location)
                   )
                 )
+              when RBS::BuiltinNames::Object.name, RBS::BuiltinNames::String.name, RBS::BuiltinNames::Integer.name, RBS::BuiltinNames::Symbol.name,
+                RBS::BuiltinNames::TrueClass.name, RBS::BuiltinNames::FalseClass.name, TypeName("::NilClass")
+                # Value based type-case works on literal types which is available for String, Integer, Symbol, TrueClass, FalseClass, and NilClass
+                return method_type.with(
+                  type: method_type.type.with(
+                    return_type: AST::Types::Logic::ArgEqualsReceiver.new(location: method_type.type.return_type.location)
+                  )
+                )
               end
             end
           end

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

@@ -58,16 +58,23 @@ module Steep
           end
         end
 
+        class ArgEqualsReceiver < Base
+          def initialize(location: nil)
+            @location = location
+          end
+        end
+
         class Env < Base
-          attr_reader :truthy, :falsy
+          attr_reader :truthy, :falsy, :type
 
-          def initialize(truthy:, falsy:, location: nil)
+          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.is_a?(Env) && other.truthy == truthy && other.falsy == falsy && other.type == type
           end
 
           alias eql? ==
@@ -75,6 +82,12 @@ module Steep
           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

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

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

data/lib/steep/errors.rb

@@ -8,7 +8,18 @@ module Steep
       end
 
       def location_to_str
-        Rainbow("#{node.loc.expression.source_buffer.name}:#{node.loc.first_line}:#{node.loc.column}").red
+        file = Rainbow(node.loc.expression.source_buffer.name).cyan
+        line = Rainbow(node.loc.first_line).bright
+        column = Rainbow(node.loc.column).bright
+        "#{file}:#{line}:#{column}"
+      end
+
+      def format_message(message, class_name: self.class.name.split("::").last)
+        if message.empty?
+          "#{location_to_str}: #{Rainbow(class_name).red}"
+        else
+          "#{location_to_str}: #{Rainbow(class_name).red}: #{message}"
+        end
       end
 
       def print_to(io)
@@ -45,7 +56,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleAssignment: lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
+        format_message "lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
       end
     end
 
@@ -61,7 +72,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleArguments: receiver=#{receiver_type}, method_type=#{method_type}"
+        format_message "receiver=#{receiver_type}, method_type=#{method_type}"
       end
     end
 
@@ -79,7 +90,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnresolvedOverloading: receiver=#{receiver_type}, method_name=#{method_name}, method_types=#{method_types.join(" | ")}"
+        format_message "receiver=#{receiver_type}, method_name=#{method_name}, method_types=#{method_types.join(" | ")}"
       end
     end
 
@@ -97,7 +108,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ArgumentTypeMismatch: receiver=#{receiver_type}, expected=#{expected}, actual=#{actual}"
+        format_message "receiver=#{receiver_type}, expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -112,7 +123,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BlockParameterTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -127,7 +138,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: NoMethodError: type=#{type}, method=#{method}"
+        format_message "type=#{type}, method=#{method}", class_name: "NoMethodError"
       end
     end
 
@@ -146,7 +157,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ReturnTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -159,7 +170,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedBlockGiven: method_type=#{method_type}"
+        format_message "method_type=#{method_type}"
       end
     end
 
@@ -172,7 +183,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.to_s}"
+        format_message "method_type=#{method_type}"
       end
     end
 
@@ -191,7 +202,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BlockTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -210,7 +221,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BlockBodyTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -229,25 +240,25 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BreakTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
     class UnexpectedJump < Base
       def to_s
-        "#{location_to_str}: UnexpectedJump"
+        format_message ""
       end
     end
 
     class UnexpectedJumpValue < Base
       def to_s
-        "#{location_to_str}: UnexpectedJumpValue"
+        format_message ""
       end
     end
 
     class MethodArityMismatch < Base
       def to_s
-        "#{location_to_str}: MethodArityMismatch: method=#{node.children[0]}"
+        format_message "method=#{node.children[0]}"
       end
     end
 
@@ -266,7 +277,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleMethodTypeAnnotation: interface_method=#{interface_method.type_name}.#{interface_method.name}, annotation_method=#{annotation_method.name}"
+        format_message "interface_method=#{interface_method.type_name}.#{interface_method.name}, annotation_method=#{annotation_method.name}"
       end
     end
 
@@ -279,7 +290,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MethodDefinitionWithOverloading: method=#{method.name}, types=#{method.types.join(" | ")}"
+        format_message "method=#{method.name}, types=#{method.types.join(" | ")}"
       end
     end
 
@@ -298,7 +309,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MethodReturnTypeAnnotationMismatch: method_type=#{method_type.return_type}, annotation_type=#{annotation_type}"
+        format_message "method_type=#{method_type.return_type}, annotation_type=#{annotation_type}"
       end
     end
 
@@ -324,13 +335,13 @@ module Steep
                    prefix = node.children[0].type == :self ? "self" : "*"
                    "#{prefix}.#{node.children[1]}"
                  end
-        "#{location_to_str}: MethodBodyTypeMismatch: method=#{method}, expected=#{expected}, actual=#{actual}"
+        format_message "method=#{method}, expected=#{expected}, actual=#{actual}"
       end
     end
 
     class UnexpectedYield < Base
       def to_s
-        "#{location_to_str}: UnexpectedYield"
+        format_message ""
       end
     end
 
@@ -343,7 +354,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedSuper: method=#{method}"
+        format_message "method=#{method}"
       end
     end
 
@@ -356,7 +367,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleZuper: method=#{method}"
+        format_message "method=#{method}"
       end
     end
 
@@ -379,7 +390,7 @@ module Steep
                  when :module
                    "self.#{missing_method}"
                  end
-        "#{location_to_str}: MethodDefinitionMissing: module=#{module_name}, method=#{method}"
+        format_message "module=#{module_name}, method=#{method}"
       end
     end
 
@@ -394,7 +405,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedDynamicMethod: module=#{module_name}, method=#{method_name}"
+        format_message "module=#{module_name}, method=#{method_name}"
       end
     end
 
@@ -407,7 +418,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnknownConstantAssigned: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -417,7 +428,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: FallbackAny"
+        format_message ""
       end
     end
 
@@ -440,7 +451,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: UnsatisfiableConstraint: method_type=#{method_type}, constraint=#{sub_type} <: '#{var} <: #{super_type}"
+        format_message "method_type=#{method_type}, constraint=#{sub_type} <: '#{var} <: #{super_type}"
       end
     end
 
@@ -459,7 +470,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: IncompatibleAnnotation: var_name=#{var_name}, #{relation}"
+        format_message "var_name=#{var_name}, #{relation}"
       end
     end
 
@@ -478,7 +489,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: IncompatibleTypeCase: var_name=#{var_name}, #{relation}"
+        format_message "var_name=#{var_name}, #{relation}"
       end
     end
 
@@ -491,7 +502,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ElseOnExhaustiveCase: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -504,7 +515,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedSplat: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -519,7 +530,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleTuple: expected_tuple=#{expected_tuple}"
+        format_message "expected_tuple=#{expected_tuple}"
       end
     end
 
@@ -532,7 +543,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedKeyword: #{unexpected_keywords.to_a.join(", ")}"
+        format_message unexpected_keywords.to_a.join(", ")
       end
     end
 
@@ -545,7 +556,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MissingKeyword: #{missing_keywords.to_a.join(", ")}"
+        format_message missing_keywords.to_a.join(", ")
       end
     end
 
@@ -558,8 +569,7 @@ module Steep
       end
 
       def to_s
-        msg = message || "#{node.type} is not supported"
-        "#{location_to_str}: UnsupportedSyntax: #{msg}"
+        format_message(message || "#{node.type} is not supported")
       end
     end
 
@@ -574,8 +584,8 @@ module Steep
       end
 
       def to_s
-        <<-MESSAGE
-#{location_to_str}: UnexpectedError: #{error.class}
+        format_message <<-MESSAGE
+#{error.class}
 >> #{message}
         MESSAGE
       end

data/lib/steep/project/target.rb

@@ -192,8 +192,8 @@ module Steep
             rescue RBS::DuplicatedDeclarationError => exn
               @status = SignatureValidationErrorStatus.new(
                 errors: [
-                  Signature::Errors::DuplicatedDefinitionError.new(
-                    name: exn.name,
+                  Signature::Errors::DuplicatedDeclarationError.new(
+                    type_name: exn.name,
                     location: exn.decls[0].location
                   )
                 ],

data/lib/steep/signature/errors.rb

@@ -19,16 +19,16 @@ module Steep
         end
       end
 
-      class DuplicatedDefinitionError < Base
-        attr_reader :name
+      class DuplicatedDeclarationError < Base
+        attr_reader :type_name
 
-        def initialize(name:, location:)
-          @name = name
+        def initialize(type_name:, location:)
+          @type_name = type_name
           @location = location
         end
 
         def puts(io)
-          io.puts "#{loc_to_s}\sDuplicatedDefinitionError: name=#{name}"
+          io.puts "#{loc_to_s}\sDuplicatedDeclarationError: name=#{type_name}"
         end
       end
 
@@ -76,6 +76,52 @@ module Steep
           io.puts "#{loc_to_s}\tInvalidMethodOverloadError: class_name=#{class_name}, method_name=#{method_name}"
         end
       end
+
+      class UnknownMethodAliasError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tUnknownMethodAliasError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
+
+      class DuplicatedMethodDefinitionError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tDuplicatedMethodDefinitionError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
+
+      class RecursiveAliasError < Base
+        attr_reader :class_name
+        attr_reader :names
+        attr_reader :location
+
+        def initialize(class_name:, names:, location:)
+          @class_name = class_name
+          @names = names
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tRecursiveAliasError: class_name=#{class_name}, names=#{names.join(", ")}"
+        end
+      end
     end
   end
 end

data/lib/steep/signature/validator.rb

@@ -62,7 +62,7 @@ module Steep
       end
 
       def validate_one_class(name)
-        rescue_validation_errors do
+        rescue_validation_errors(name) do
           Steep.logger.debug "Validating class definition `#{name}`..."
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).each_type do |type|
@@ -76,7 +76,7 @@ module Steep
       end
 
       def validate_one_interface(name)
-        rescue_validation_errors do
+        rescue_validation_errors(name) do
           Steep.logger.debug "Validating interface `#{name}`..."
           Steep.logger.tagged "#{name}" do
             builder.build_interface(name).each_type do |type|
@@ -117,7 +117,7 @@ module Steep
 
       def validate_alias
         env.alias_decls.each do |name, entry|
-          rescue_validation_errors do
+          rescue_validation_errors(name) do
             Steep.logger.debug "Validating alias `#{name}`..."
             builder.expand_alias(name).tap do |type|
               validate_type(type)
@@ -126,7 +126,7 @@ module Steep
         end
       end
 
-      def rescue_validation_errors
+      def rescue_validation_errors(type_name = nil)
         yield
       rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
@@ -146,6 +146,30 @@ module Steep
           method_name: exn.method_name,
           location: exn.members[0].location
         )
+      rescue RBS::DuplicatedMethodDefinitionError => exn
+        @errors << Errors::DuplicatedMethodDefinitionError.new(
+          class_name: type_name,
+          method_name: exn.method_name,
+          location: exn.location
+        )
+      rescue RBS::DuplicatedInterfaceMethodDefinitionError => exn
+        @errors << Errors::DuplicatedMethodDefinitionError.new(
+          class_name: type_name,
+          method_name: exn.method_name,
+          location: exn.member.location
+        )
+      rescue RBS::UnknownMethodAliasError => exn
+        @errors << Errors::UnknownMethodAliasError.new(
+          class_name: type_name,
+          method_name: exn.aliased_name,
+          location: exn.location
+        )
+      rescue RBS::RecursiveAliasDefinitionError => exn
+        @errors << Errors::RecursiveAliasError.new(
+          class_name: exn.type.name,
+          names: exn.defs.map(&:name),
+          location: exn.defs[0].original.location
+        )
       end
     end
   end

data/lib/steep/subtyping/check.rb

@@ -10,7 +10,7 @@ module Steep
       end
 
       def instance_super_types(type_name, args:)
-        ancestors = factory.definition_builder.one_instance_ancestors(type_name)
+        ancestors = factory.definition_builder.ancestor_builder.one_instance_ancestors(type_name)
 
         subst = unless args.empty?
                   args_ = args.map {|type| factory.type_1(type) }
@@ -50,7 +50,7 @@ module Steep
       end
 
       def singleton_super_types(type_name)
-        ancestors = factory.definition_builder.one_singleton_ancestors(type_name)
+        ancestors = factory.definition_builder.ancestor_builder.one_singleton_ancestors(type_name)
 
         ancestors.each_ancestor.map do |ancestor|
           name = ancestor.name

data/lib/steep/type_construction.rb

@@ -399,6 +399,9 @@ module Steep
 
         instance_type = AST::Types::Name::Instance.new(name: class_name, args: class_args)
         module_type = AST::Types::Name::Singleton.new(name: class_name)
+      else
+        instance_type = AST::Builtin::Object.instance_type
+        module_type = AST::Builtin::Object.module_type
       end
 
       if annots.instance_type
@@ -642,7 +645,7 @@ module Steep
       Pair.new(type: call.return_type, constr: self)
     end
 
-    def synthesize(node, hint: nil)
+    def synthesize(node, hint: nil, condition: false)
       Steep.logger.tagged "synthesize:(#{node.location.expression.to_s.split(/:/, 2).last})" do
         Steep.logger.debug node.type
         case node.type
@@ -879,9 +882,7 @@ module Steep
             new.typing.add_context_for_node(node, context: new.context)
             new.typing.add_context_for_body(node, context: new.context)
 
-            each_child_node(args_node) do |arg|
-              _, new = new.synthesize(arg)
-            end
+            new = new.synthesize_children(args_node)
 
             body_pair = if body_node
                           return_type = expand_alias(new.method_context&.return_type)
@@ -936,14 +937,17 @@ module Steep
                            checker.factory.definition_builder.build_singleton(name)
                          end
 
+            args_node = node.children[2]
             new = for_new_method(node.children[1],
                                  node,
-                                 args: node.children[2].children,
+                                 args: args_node.children,
                                  self_type: self_type,
                                  definition: definition)
             new.typing.add_context_for_node(node, context: new.context)
             new.typing.add_context_for_body(node, context: new.context)
 
+            new = new.synthesize_children(args_node)
+
             each_child_node(node.children[2]) do |arg|
               new.synthesize(arg)
             end
@@ -1091,10 +1095,6 @@ module Steep
               add_typing(node, type: type)
             else
               type = AST::Builtin.any_type
-              if context&.method_context&.method_type
-                Steep.logger.error { "Unknown arg type: #{node}" }
-              end
-
               lvasgn(node, type)
             end
           end
@@ -1514,18 +1514,22 @@ module Steep
           yield_self do
             left, right = node.children
 
-            left_type, constr = synthesize(left)
+            left_type, constr = synthesize(left, hint: hint, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
 
+            if left_type.is_a?(AST::Types::Logic::Env)
+              left_type = left_type.type
+            end
+
             right_type, constr = constr
                                    .update_lvar_env { truthy_env }
                                    .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
                                    .for_branch(right)
-                                   .synthesize(right)
+                                   .synthesize(right, hint: hint, condition: true)
 
-            truthy_env, _ = interpreter.eval(env: truthy_env, type: right_type, node: right)
+            truthy_env, _ = interpreter.eval(env: constr.context.lvar_env, type: right_type, node: right)
 
             env = if right_type.is_a?(AST::Types::Bot)
                     falsey_env
@@ -1534,14 +1538,14 @@ module Steep
                   end
 
             type = case
-                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
-                     AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env)
                    when check_relation(sub_type: left_type, super_type: AST::Types::Boolean.new).success?
                      union_type(left_type, right_type)
                    else
                      union_type(right_type, AST::Builtin.nil_type)
                    end
 
+            type = AST::Types::Logic::Env.new(truthy: truthy_env, falsy: env, type: type) if condition
+
             add_typing(node,
                        type: type,
                        constr: constr.update_lvar_env { env })
@@ -1551,17 +1555,21 @@ module Steep
           yield_self do
             left, right = node.children
 
-            left_type, constr = synthesize(left, hint: hint)
+            left_type, constr = synthesize(left, hint: hint, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: left_type, node: left)
 
+            if left_type.is_a?(AST::Types::Logic::Env)
+              left_type = left_type.type
+            end
             left_type, _ = checker.factory.unwrap_optional(left_type)
+
             right_type, constr = constr
                                    .update_lvar_env { falsey_env }
                                    .tap {|constr| typing.add_context_for_node(right, context: constr.context) }
                                    .for_branch(right)
-                                   .synthesize(right, hint: left_type)
+                                   .synthesize(right, hint: left_type, condition: true)
 
             _, falsey_env = interpreter.eval(env: falsey_env, type: right_type, node: right)
 
@@ -1572,12 +1580,14 @@ module Steep
                   end
 
             type = case
-                   when left_type.is_a?(AST::Types::Logic::Base) && right_type.is_a?(AST::Types::Logic::Base)
-                     AST::Types::Logic::Env.new(truthy: env, falsy: falsey_env)
+                   when check_relation(sub_type: left_type, super_type: AST::Builtin.bool_type).success?
+                     AST::Builtin.bool_type
                    else
                      union_type(left_type, right_type)
                    end
 
+            type = AST::Types::Logic::Env.new(truthy: env, falsy: falsey_env, type: type) if condition
+            
             add_typing(node,
                        type: type,
                        constr: constr.update_lvar_env { env })
@@ -1586,7 +1596,7 @@ module Steep
         when :if
           cond, true_clause, false_clause = node.children
 
-          cond_type, constr = synthesize(cond)
+          cond_type, constr = synthesize(cond, condition: true)
           interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: constr.typing)
           truthy_env, falsey_env = interpreter.eval(env: constr.context.lvar_env, type: cond_type, node: cond)
 
@@ -1667,7 +1677,7 @@ module Steep
 
                 tests.each do |test|
                   test_node = test.updated(:send, [test, :===, var_node])
-                  test_type, test_constr = test_constr.synthesize(test_node)
+                  test_type, test_constr = test_constr.synthesize(test_node, condition: true)
                   truthy_env, falsy_env = interpreter.eval(type: test_type, node: test_node, env: test_constr.context.lvar_env)
                   truthy_env = cond_vars.inject(truthy_env) do |env, var|
                     env.assign!(var, node: test_node, type: env[first_var])
@@ -1675,6 +1685,7 @@ module Steep
                   falsy_env = cond_vars.inject(falsy_env) do |env, var|
                     env.assign!(var, node: test_node, type: env[first_var])
                   end
+
                   test_envs << truthy_env
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
@@ -1719,21 +1730,20 @@ module Steep
               branch_pairs = []
 
               when_constr = constr
+              clause_constr = constr
 
               whens.each do |clause|
                 *tests, body = clause.children
 
                 test_constr = when_constr
-                test_envs = []
 
                 tests.each do |test|
-                  test_type, test_constr = test_constr.synthesize(test)
+                  test_type, test_constr = test_constr.synthesize(test, condition: true)
                   truthy_env, falsy_env = interpreter.eval(env: test_constr.context.lvar_env, type: test_type, node: test)
-                  test_envs << truthy_env
+                  clause_constr = clause_constr.update_lvar_env { truthy_env }
                   test_constr = test_constr.update_lvar_env { falsy_env }
                 end
 
-                clause_constr = when_constr.update_lvar_env {|env| env.join(*test_envs) }
                 when_constr = test_constr
 
                 if body
@@ -1907,7 +1917,7 @@ module Steep
         when :while, :until
           yield_self do
             cond, body = node.children
-            cond_type, constr = synthesize(cond)
+            cond_type, constr = synthesize(cond, condition: true)
 
             interpreter = TypeInference::LogicTypeInterpreter.new(subtyping: checker, typing: typing)
             truthy_env, falsy_env = interpreter.eval(env: constr.context.lvar_env, node: cond, type: cond_type)
@@ -2154,7 +2164,12 @@ module Steep
 
         when :splat
           yield_self do
-            Steep.logger.warn { "Unsupported node #{node.type} (#{node.location.expression.source_buffer.name}:#{node.location.expression.line})" }
+            typing.add_error(
+              Errors::UnsupportedSyntax.new(
+                node: node,
+                message: "Unsupported splat node occurrence"
+              )
+            )
 
             each_child_node node do |child|
               synthesize(child)
@@ -2173,7 +2188,7 @@ module Steep
           add_typing node, type: AST::Builtin.any_type, constr: constr
 
         else
-          raise "Unexpected node: #{node.inspect}, #{node.location.expression}"
+          typing.add_error(Errors::UnsupportedSyntax.new(node: node))
 
         end.tap do |pair|
           unless pair.is_a?(Pair) && !pair.type.is_a?(Pair)
@@ -2542,7 +2557,25 @@ module Steep
 
         constr.add_call(call)
       else
-        add_call(
+        skips = []
+        skips << receiver if receiver
+        skips << node.children[0] if node.type == :block
+        skips << block_params if block_params
+        skips << block_body if block_body
+
+        constr = synthesize_children(node, skips: skips)
+        if block_params
+          block_annotations = source.annotations(block: node, factory: checker.factory, current_module: current_namespace)
+
+          constr.type_block_without_hint(
+            node: node,
+            block_params: TypeInference::BlockParams.from_node(block_params, annotations: block_annotations),
+            block_annotations: block_annotations,
+            block_body: block_body
+          )
+        end
+
+        constr.add_call(
           TypeInference::MethodCall::NoMethodError.new(
             node: node,
             context: context.method_context,
@@ -3129,9 +3162,9 @@ module Steep
       block_constr = for_block(
         block_params: block_params,
         block_param_hint: nil,
-        block_type_hint: nil,
+        block_type_hint: AST::Builtin.any_type,
         block_annotations: block_annotations,
-        node_type_hint: nil
+        node_type_hint: AST::Builtin.any_type
       )
 
       block_constr.typing.add_context_for_body(node, context: block_constr.context)

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -41,8 +41,11 @@ module Steep
 
         if type.is_a?(AST::Types::Logic::Base)
           vars.each do |var_name|
-            truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.true_type)
-            falsy_env = truthy_env.assign!(var_name, node: node, type: AST::Builtin.false_type)
+            var_type = truthy_env[var_name]
+            truthy_type, falsy_type = factory.unwrap_optional(var_type)
+            falsy_type ||= AST::Builtin.nil_type
+            truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type) {|_, type, _| type }
+            falsy_env = truthy_env.assign!(var_name, node: node, type: falsy_type) {|_, type, _| type }
           end
 
           case type
@@ -77,11 +80,16 @@ module Steep
 
                 if arg_type.is_a?(AST::Types::Name::Singleton)
                   receiver_vars.each do |var_name|
-                    var_type = env[var_name]
-                    truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
-
-                    truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
-                    falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    case var_name
+                    when :_, :__any__, :__skip__
+                      # skip
+                    else
+                      var_type = env[var_name]
+                      truthy_type, falsy_type = type_case_select(var_type, arg_type.name)
+
+                      truthy_env = truthy_env.assign!(var_name, node: node, type: truthy_type)
+                      falsy_env = falsy_env.assign!(var_name, node: node, type: falsy_type)
+                    end
                   end
                 end
               end
@@ -93,7 +101,7 @@ module Steep
 
               if receiver
                 _, arg_vars = decompose_value(arg)
-                receiver_type = typing.type_of(node: receiver)
+                receiver_type = factory.deep_expand_alias(typing.type_of(node: receiver))
 
                 if receiver_type.is_a?(AST::Types::Name::Singleton)
                   arg_vars.each do |var_name|
@@ -106,6 +114,23 @@ module Steep
                 end
               end
             end
+          when AST::Types::Logic::ArgEqualsReceiver
+            case value_node.type
+            when :send
+              receiver, _, arg = value_node.children
+
+              if receiver
+                _, arg_vars = decompose_value(arg)
+
+                arg_vars.each do |var_name|
+                  var_type = factory.deep_expand_alias(env[var_name])
+                  truthy_types, falsy_types = literal_var_type_case_select(receiver, var_type)
+
+                  truthy_env = truthy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: truthy_types, location: nil))
+                  falsy_env = falsy_env.assign!(var_name, node: node, type: AST::Types::Union.build(types: falsy_types, location: nil))
+                end
+              end
+            end
           when AST::Types::Logic::Not
             receiver, * = value_node.children
             receiver_type = typing.type_of(node: receiver)
@@ -156,6 +181,60 @@ module Steep
         end
       end
 
+      def literal_var_type_case_select(value_node, arg_type)
+        case arg_type
+        when AST::Types::Union
+          truthy_types = []
+          falsy_types = []
+
+          arg_type.types.each do |type|
+            ts, fs = literal_var_type_case_select(value_node, type)
+            truthy_types.push(*ts)
+            falsy_types.push(*fs)
+          end
+
+          [truthy_types, falsy_types]
+        else
+          value_type = typing.type_of(node: value_node)
+          types = [arg_type]
+
+          case value_node.type
+          when :nil
+            types.partition do |type|
+              type.is_a?(AST::Types::Nil) || AST::Builtin::NilClass.instance_type?(type)
+            end
+          when :true
+            types.partition do |type|
+              AST::Builtin::TrueClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == true)
+            end
+          when :false
+            types.partition do |type|
+              AST::Builtin::FalseClass.instance_type?(type) ||
+                (type.is_a?(AST::Types::Literal) && type.value == false)
+            end
+          when :int, :str, :sym
+            types.each.with_object([[], []]) do |type, pair|
+              true_types, false_types = pair
+
+              case
+              when type.is_a?(AST::Types::Literal)
+                if type.value == value_node.children[0]
+                  true_types << type
+                else
+                  false_types << type
+                end
+              else
+                true_types << AST::Types::Literal.new(value: value_node.children[0])
+                false_types << type
+              end
+            end
+          else
+            [[arg_type], [arg_type]]
+          end
+        end
+      end
+
       def type_case_select(type, klass)
         truth_types, false_types = type_case_select0(type, klass)
 
@@ -186,20 +265,6 @@ module Steep
 
           [truthy_types, falsy_types]
 
-        when AST::Types::Name::Instance
-          relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
-          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
-            [
-              [type],
-              []
-            ]
-          else
-            [
-              [],
-              [type]
-            ]
-          end
-
         when AST::Types::Name::Alias
           ty = factory.expand_alias(type)
           type_case_select0(ty, klass)
@@ -217,10 +282,18 @@ module Steep
           ]
 
         else
-          [
-            [],
-            [type]
-          ]
+          relation = Subtyping::Relation.new(sub_type: type, super_type: instance_type)
+          if subtyping.check(relation, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new).success?
+            [
+              [type],
+              []
+            ]
+          else
+            [
+              [],
+              [type]
+            ]
+          end
         end
       end
     end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.38.0"
+  VERSION = "0.39.0"
 end

data/smoke/type_case/a.rb

@@ -16,7 +16,7 @@ end
 
 case x
 when 1
-  # !expects NoMethodError: type=(::Integer | ::String | ::Symbol), method=foobar
+  # !expects NoMethodError: type=1, method=foobar
   x.foobar
 end
 

data/steep.gemspec

@@ -34,5 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", "~> 3.15.0.1"
-  spec.add_runtime_dependency "rbs", ">= 0.20.0"
+  spec.add_runtime_dependency "rbs", "~> 1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.38.0
+  version: 0.39.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-10 00:00:00.000000000 Z
+date: 2020-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -104,16 +104,16 @@ dependencies:
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.20.0
+        version: 1.0.0
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -389,7 +389,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Gradual Typing for Ruby