steep 1.2.0 → 1.3.0.pre.1

data/lib/steep/type_construction.rb

@@ -52,10 +52,18 @@ module Steep
       context.module_context
     end
 
+    def module_context!
+      module_context or raise
+    end
+
     def method_context
       context.method_context
     end
 
+    def method_context!
+      method_context or raise
+    end
+
     def block_context
       context.block_context
     end
@@ -798,42 +806,6 @@ module Steep
             end
           end
 
-        when :send
-          yield_self do
-            if self_class?(node)
-              module_type = expand_alias(module_context.module_type)
-              type = if module_type.is_a?(AST::Types::Name::Singleton)
-                       AST::Types::Name::Singleton.new(name: module_type.name)
-                     else
-                       module_type
-                     end
-
-              add_typing(node, type: type)
-            else
-              type_send(node, send_node: node, block_params: nil, block_body: nil)
-            end
-          end
-
-        when :csend
-          yield_self do
-            send_type, constr =
-              if self_class?(node)
-                module_type = expand_alias(module_context.module_type)
-                type = if module_type.is_a?(AST::Types::Name::Singleton)
-                         AST::Types::Name::Singleton.new(name: module_type.name)
-                       else
-                         module_type
-                       end
-                add_typing(node, type: type).to_ary
-              else
-                type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true).to_ary
-              end
-
-            constr
-              .update_type_env { context.type_env.join(constr.context.type_env, context.type_env) }
-              .add_typing(node, type: union_type(send_type, AST::Builtin.nil_type))
-          end
-
         when :match_with_lvasgn
           each_child_node(node) do |child|
             synthesize(child)
@@ -907,14 +879,16 @@ module Steep
                   }
                 )
 
-                call, constr = type_method_call(node,
-                                                receiver_type: self_type,
-                                                method_name: method_context.name,
-                                                method: super_method,
-                                                arguments: node.children,
-                                                block_params: nil,
-                                                block_body: nil,
-                                                topdown_hint: true)
+                call, constr = type_method_call(
+                  node,
+                  receiver_type: self_type,
+                  method_name: method_context.name,
+                  method: super_method,
+                  arguments: node.children,
+                  block_params: nil,
+                  block_body: nil,
+                  tapp: nil
+                )
 
                 if call && constr
                   constr.add_call(call)
@@ -947,35 +921,6 @@ module Steep
             end
           end
 
-        when :block
-          yield_self do
-            send_node, params, body = node.children
-            if send_node.type == :lambda
-              type_lambda(node, params_node: params, body_node: body, type_hint: hint)
-            else
-              type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
-            end
-          end
-
-        when :numblock
-          yield_self do
-            send_node, max_num, body = node.children
-
-            if max_num == 1
-              arg_nodes = [Parser::AST::Node.new(:procarg0, [:_1])]
-            else
-              arg_nodes = max_num.times.map {|i| Parser::AST::Node.new(:arg, [:"_#{i+1}"]) }
-            end
-
-            params = Parser::AST::Node.new(:args, arg_nodes)
-
-            if send_node.type == :lambda
-              type_lambda(node, params_node: params, body_node: body, type_hint: hint)
-            else
-              type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend)
-            end
-          end
-
         when :def
           yield_self do
             name, args_node, body_node = node.children
@@ -1547,9 +1492,9 @@ module Steep
 
               constructor.synthesize(node.children[1]) if node.children[1]
 
-              if constructor.module_context.instance_definition && module_context.module_definition
-                if constructor.module_context.instance_definition.type_name == module_context.module_definition.type_name
-                  module_context.defined_module_methods.merge(constructor.module_context.defined_instance_methods)
+              if constructor.module_context!.instance_definition && module_context!.module_definition
+                if constructor.module_context!.instance_definition.type_name == module_context!.module_definition.type_name
+                  module_context!.defined_module_methods.merge(constructor.module_context!.defined_instance_methods)
                 end
               end
             end
@@ -2446,6 +2391,41 @@ module Steep
 
           add_typing node, type: AST::Builtin.any_type, constr: constr
 
+        when :assertion
+          yield_self do
+            # @type var as_type: AST::Node::TypeAssertion
+            asserted_node, as_type = node.children
+
+            if type = as_type.type?(module_context!.nesting, checker.factory, [])
+              actual_type, constr = synthesize(asserted_node, hint: type)
+
+              if result = no_subtyping?(sub_type: type, super_type: actual_type)
+                typing.add_error(
+                  Diagnostic::Ruby::FalseAssertion.new(
+                    node: node,
+                    assertion_type: type,
+                    node_type: actual_type
+                  )
+                )
+              end
+
+              constr.add_typing(node, type: type)
+            else
+              synthesize(asserted_node, hint: hint)
+            end
+          end
+
+        when :block, :numblock, :send, :csend
+          synthesize_sendish(node, hint: hint, tapp: nil)
+
+        when :tapp
+          yield_self do
+            sendish, tapp = node.children
+            type, constr = synthesize_sendish(sendish, hint: hint, tapp: tapp)
+
+            constr.add_typing(node, type: type)
+          end
+
         else
           typing.add_error(Diagnostic::Ruby::UnsupportedSyntax.new(node: node))
           add_typing(node, type: AST::Builtin.any_type)
@@ -2481,6 +2461,74 @@ module Steep
       end
     end
 
+    def synthesize_sendish(node, hint:, tapp:)
+      case node.type
+      when :send
+        yield_self do
+          if self_class?(node)
+            module_type = expand_alias(module_context!.module_type)
+            type = if module_type.is_a?(AST::Types::Name::Singleton)
+                     AST::Types::Name::Singleton.new(name: module_type.name)
+                   else
+                     module_type
+                   end
+
+            add_typing(node, type: type)
+          else
+            type_send(node, send_node: node, block_params: nil, block_body: nil, tapp: tapp)
+          end
+        end
+      when :csend
+        yield_self do
+          send_type, constr =
+            if self_class?(node)
+              module_type = expand_alias(module_context!.module_type)
+              type = if module_type.is_a?(AST::Types::Name::Singleton)
+                       AST::Types::Name::Singleton.new(name: module_type.name)
+                     else
+                       module_type
+                     end
+              add_typing(node, type: type).to_ary
+            else
+              type_send(node, send_node: node, block_params: nil, block_body: nil, unwrap: true, tapp: tapp).to_ary
+            end
+
+          constr
+            .update_type_env { context.type_env.join(constr.context.type_env, context.type_env) }
+            .add_typing(node, type: union_type(send_type, AST::Builtin.nil_type))
+        end
+      when :block
+        yield_self do
+          send_node, params, body = node.children
+          if send_node.type == :lambda
+            type_lambda(node, params_node: params, body_node: body, type_hint: hint)
+          else
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp)
+          end
+        end
+      when :numblock
+        yield_self do
+          send_node, max_num, body = node.children
+
+          if max_num == 1
+            arg_nodes = [Parser::AST::Node.new(:procarg0, [:_1])]
+          else
+            arg_nodes = max_num.times.map {|i| Parser::AST::Node.new(:arg, [:"_#{i+1}"]) }
+          end
+
+          params = Parser::AST::Node.new(:args, arg_nodes)
+
+          if send_node.type == :lambda
+            type_lambda(node, params_node: params, body_node: body, type_hint: hint)
+          else
+            type_send(node, send_node: send_node, block_params: params, block_body: body, unwrap: send_node.type == :csend, tapp: tapp)
+          end
+        end
+      else
+        raise "Unexpected node is given to `#synthesize_sendish` (#{node.type}, #{node.location.first_line})"
+      end
+    end
+
     def masgn_lhs?(lhs)
       lhs.children.all? do |a|
         asgn_type = if a.type == :splat
@@ -2833,6 +2881,7 @@ module Steep
     def synthesize_children(node, skips: [])
       skips = Set.new.compare_by_identity.merge(skips)
 
+      # @type var constr: TypeConstruction
       constr = self
 
       each_child_node(node) do |child|
@@ -2858,18 +2907,20 @@ module Steep
       end
     end
 
-    def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:)
+    def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:, tapp:)
       method = interface&.methods&.[](method_name)
 
       if method
-        call, constr = type_method_call(node,
-                                        method: method,
-                                        method_name: method_name,
-                                        arguments: arguments,
-                                        block_params: block_params,
-                                        block_body: block_body,
-                                        receiver_type: receiver_type,
-                                        topdown_hint: true)
+        call, constr = type_method_call(
+          node,
+          method: method,
+          method_name: method_name,
+          arguments: arguments,
+          block_params: block_params,
+          block_body: block_body,
+          receiver_type: receiver_type,
+          tapp: tapp
+        )
 
         if call && constr
           case method_name.to_s
@@ -2962,7 +3013,7 @@ module Steep
           send_node = node.children[0]
           case send_node.type
           when :super, :zsuper
-            method_name = method_context.name
+            method_name = method_context!.name or raise
             return fallback_to_any(send_node) do
               Diagnostic::Ruby::UnexpectedSuper.new(node: send_node, method: method_name)
             end
@@ -2981,8 +3032,9 @@ module Steep
       end
     end
 
-    def type_send(node, send_node:, block_params:, block_body:, unwrap: false)
+    def type_send(node, send_node:, block_params:, block_body:, unwrap: false, tapp:)
       # @type var constr: TypeConstruction
+      # @type var receiver: Parser::AST::Node?
 
       case send_node.type
       when :super, :zsuper
@@ -3042,7 +3094,8 @@ module Steep
                             method_name: method_name,
                            arguments: arguments,
                            block_params: block_params,
-                           block_body: block_body
+                           block_body: block_body,
+                           tapp: tapp
                          )
                        else
                          constr = constr.synthesize_children(node, skips: [receiver])
@@ -3064,8 +3117,8 @@ module Steep
     def builder_config
       Interface::Builder::Config.new(
         self_type: self_type,
-        class_type: module_context.module_type,
-        instance_type: module_context.instance_type,
+        class_type: module_context!.module_type,
+        instance_type: module_context!.instance_type,
         variable_bounds: variable_context.upper_bounds
       )
     end
@@ -3113,6 +3166,7 @@ module Steep
           # compact
           return_type = method_type.type.return_type
           if AST::Builtin::Array.instance_type?(return_type)
+            # @type var return_type: AST::Types::Name::Instance
             elem = return_type.args[0]
             type = AST::Builtin::Array.instance_type(unwrap(elem))
 
@@ -3120,7 +3174,7 @@ module Steep
             call = TypeInference::MethodCall::Special.new(
               node: node,
               context: constr.context.method_context,
-              method_name: decl.method_name,
+              method_name: decl.method_name.method_name,
               receiver_type: receiver_type,
               actual_method_type: method_type.with(type: method_type.type.with(return_type: type)),
               return_type: type,
@@ -3135,6 +3189,7 @@ module Steep
           # compact
           return_type = method_type.type.return_type
           if AST::Builtin::Hash.instance_type?(return_type)
+            # @type var return_type: AST::Types::Name::Instance
             key = return_type.args[0]
             value = return_type.args[1]
             type = AST::Builtin::Hash.instance_type(key, unwrap(value))
@@ -3143,7 +3198,7 @@ module Steep
             call = TypeInference::MethodCall::Special.new(
               node: node,
               context: constr.context.method_context,
-              method_name: decl.method_name,
+              method_name: decl.method_name.method_name,
               receiver_type: receiver_type,
               actual_method_type: method_type.with(type: method_type.type.with(return_type: type)),
               return_type: type,
@@ -3158,7 +3213,7 @@ module Steep
       nil
     end
 
-    def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, topdown_hint:)
+    def type_method_call(node, method_name:, receiver_type:, method:, arguments:, block_params:, block_body:, tapp:)
       node_range = node.loc.expression.yield_self {|l| l.begin_pos..l.end_pos }
 
       results = method.method_types.map do |method_type|
@@ -3182,39 +3237,26 @@ module Steep
               arguments: arguments,
               block_params: block_params,
               block_body: block_body,
-              topdown_hint: topdown_hint
+              tapp: tapp
             )
           end
         end
       end
 
       case
-      when results.empty?
-        method_type = method.method_types.last
-        all_decls = method.method_types.each.with_object(Set[]) do |method_type, set|
-          set.merge(method_type.method_decls)
-        end
-
-        error = Diagnostic::Ruby::IncompatibleArguments.new(node: node, method_name: method_name, receiver_type: receiver_type, method_types: method.method_types)
-        call = TypeInference::MethodCall::Error.new(
-          node: node,
-          context: context.method_context,
-          method_name: method_name,
-          receiver_type: receiver_type,
-          return_type: method_type.type.return_type,
-          errors: [error],
-          method_decls: all_decls
-        )
-        constr = self.with_new_typing(typing.new_child(node_range))
+      when results.one?
+        # There is only one overload, use the type checking result
+        call, constr = results[0]
       when (call, constr = results.find {|call, _| call.is_a?(TypeInference::MethodCall::Typed) })
-        # Nop
+        # Successfully type checked with one of the overloads
       else
-        if results.one?
-          call, constr = results[0]
-        else
-          return
-        end
+        # No suitable overload, more than one overlodas
+        return
       end
+
+      constr or raise
+      call or raise
+
       constr.typing.save!
 
       [
@@ -3367,12 +3409,78 @@ module Steep
       constr
     end
 
-    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, topdown_hint:)
-      type_params, instantiation = Interface::TypeParam.rename(method_type.type_params)
-      type_param_names = type_params.map(&:name)
-
+    def try_method_type(node, receiver_type:, method_name:, method_type:, arguments:, block_params:, block_body:, tapp:)
       constr = self
 
+      if tapp && type_args = tapp.types?(module_context!.nesting, checker.factory, [])
+        type_arity = method_type.type_params.size
+        type_param_names = method_type.type_params.map(&:name)
+
+        # Explicit type application
+        if type_args.size == type_arity
+          # @type var args_: Array[AST::Types::t]
+          args_ = []
+
+          type_args.each_with_index do |type, index|
+            param = method_type.type_params[index]
+            if param.upper_bound
+              if result = no_subtyping?(sub_type: type, super_type: param.upper_bound)
+                args_ << AST::Builtin.any_type
+                constr.typing.add_error(
+                  Diagnostic::Ruby::TypeArgumentMismatchError.new(
+                    type_arg: type,
+                    type_param: param,
+                    result: result
+                  )
+                )
+              else
+                args_ << type
+              end
+            else
+              args_ << type
+            end
+          end
+
+          method_type = method_type.instantiate(Interface::Substitution.build(type_param_names, args_))
+        else
+          if type_args.size > type_arity
+            type_args.drop(type_arity).each do |type_arg|
+              constr.typing.add_error(
+                Diagnostic::Ruby::UnexpectedTypeArgument.new(
+                  type_arg: type_arg,
+                  method_type: method_type
+                )
+              )
+            end
+          end
+
+          if type_args.size < type_arity
+            constr.typing.add_error(
+              Diagnostic::Ruby::InsufficientTypeArgument.new(
+                node: tapp.node,
+                type_args: type_args,
+                method_type: method_type
+              )
+            )
+          end
+
+          method_type = method_type.instantiate(
+            Interface::Substitution.build(
+              type_param_names,
+              Array.new(type_param_names.size, AST::Builtin.any_type)
+            )
+          )
+        end
+
+        type_params = []
+        type_param_names.clear
+      else
+        # Infer type application
+        type_params, instantiation = Interface::TypeParam.rename(method_type.type_params)
+        type_param_names = type_params.map(&:name)
+        method_type = method_type.instantiate(instantiation)
+      end
+
       constr = constr.with(
         context: context.with(
           variable_context: TypeInference::Context::TypeVariableContext.new(
@@ -3382,14 +3490,12 @@ module Steep
         )
       )
 
-      method_type = method_type.instantiate(instantiation)
-
       variance = Subtyping::VariableVariance.from_method_type(method_type)
       constraints = Subtyping::Constraints.new(unknowns: type_params.map(&:name))
       ccontext = Subtyping::Constraints::Context.new(
         self_type: self_type,
-        instance_type: module_context.instance_type,
-        class_type: module_context.module_type,
+        instance_type: module_context!.instance_type,
+        class_type: module_context!.module_type,
         variance: variance
       )
 
@@ -3576,7 +3682,7 @@ module Steep
 
             case node.children[0].type
             when :super, :zsuper
-              unless method_context.super_method
+              unless method_context!.super_method
                 errors << Diagnostic::Ruby::UnexpectedSuper.new(
                   node: node.children[0],
                   method: method_name

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -134,7 +134,9 @@ module Steep
             assignments = masgn.expand(lhs, rhs_type_converted, false)
           end
 
-          assignments or raise
+          unless assignments
+            raise "Multiple assignment rhs doesn't look correct: #{rhs_type.to_s} (#{assignment_node.location.expression&.source_line})"
+          end
 
           assignments.each do |pair|
             node, type = pair
@@ -373,17 +375,41 @@ module Steep
           ]
 
         else
+          # There are four possible relations between `type` and `instance_type`
+          #
+          # ```ruby
+          # case object      # object: T
+          # when K           # K: singleton(K)
+          # when ...
+          # end
+          # ````
+          #
+          # 1. T <: K && K <: T (T == K, T = Integer, K = Numeric)
+          # 2. T <: K           (example: T = Integer, K = Numeric)
+          # 3. K <: T           (example: T = Numeric, K = Integer)
+          # 4. none of the above (example: T = String, K = Integer)
+
           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, instance_type: AST::Types::Instance.new, class_type: AST::Types::Class.new).success?
+            # 1 or 2. Satisfies the condition, no narrowing because `type` is already more specific than/equals to `instance_type`
             [
               [type],
               []
             ]
           else
-            [
-              [],
-              [type]
-            ]
+            if subtyping.check(relation.flip, constraints: Subtyping::Constraints.empty, self_type: AST::Types::Self.new, instance_type: AST::Types::Instance.new, class_type: AST::Types::Class.new).success?
+              # 3. Satisfied the condition, narrows to `instance_type`, but cannot remove it from *falsy* list
+              [
+                [instance_type],
+                [type]
+              ]
+            else
+              # 4
+              [
+                [],
+                [type]
+              ]
+            end
           end
         end
       end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.2.0"
+  VERSION = "1.3.0.pre.1"
 end

data/lib/steep.rb

@@ -50,6 +50,8 @@ require "steep/ast/types/record"
 require "steep/ast/types/logic"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
+require "steep/ast/node/type_assertion"
+require "steep/ast/node/type_application"
 require "steep/ast/builtin"
 require "steep/ast/types/factory"