steep-relaxed 1.9.3.3

data/lib/steep/type_inference/method_call.rb

@@ -0,0 +1,193 @@
+module Steep
+  module TypeInference
+    module MethodCall
+      class MethodDecl
+        attr_reader :method_name
+        attr_reader :method_def
+
+        def initialize(method_name:, method_def:)
+          @method_name = method_name
+          @method_def = method_def
+        end
+
+        def hash
+          method_name.hash
+        end
+
+        def ==(other)
+          other.is_a?(MethodDecl) && other.method_name == method_name && other.method_def == method_def
+        end
+
+        alias eql? ==
+
+        def method_type
+          method_def.type
+        end
+      end
+
+      MethodContext = _ = Struct.new(:method_name, keyword_init: true) do
+        # @implements MethodContext
+
+        def to_s
+          "@#{method_name}"
+        end
+      end
+
+      ModuleContext = _ = Struct.new(:type_name, keyword_init: true) do
+        # @implements ModuleContext
+
+        def to_s
+          "@#{type_name}@"
+        end
+      end
+
+      TopLevelContext = _ = Class.new() do
+        def to_s
+          "@<main>"
+        end
+
+        def ==(other)
+          other.is_a?(TopLevelContext)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+      end
+
+      UnknownContext = _ = Class.new() do
+        def to_s
+          "@<unknown>"
+        end
+
+        def ==(other)
+          other.is_a?(UnknownContext)
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash
+        end
+      end
+
+      class Base
+        attr_reader :node
+        attr_reader :context
+        attr_reader :method_name
+        attr_reader :return_type
+        attr_reader :receiver_type
+
+        def initialize(node:, context:, method_name:, receiver_type:, return_type:)
+          @node = node
+          @context = context
+          @method_name = method_name
+          @receiver_type = receiver_type
+          @return_type = return_type
+        end
+
+        def with_return_type(new_type)
+          dup.tap do |copy|
+            copy.instance_eval do
+              @return_type = new_type
+            end
+          end
+        end
+
+        def ==(other)
+          other.is_a?(Base) &&
+            other.node == node &&
+            other.context == context &&
+            other.method_name == method_name &&
+            other.return_type == return_type &&
+            other.receiver_type == receiver_type
+        end
+
+        alias eql? ==
+
+        def hash
+          node.hash ^ context.hash ^ method_name.hash ^ return_type.hash ^ receiver_type.hash
+        end
+      end
+
+      class Typed < Base
+        attr_reader :actual_method_type
+        attr_reader :method_decls
+
+        def initialize(node:, context:, method_name:, receiver_type:, actual_method_type:, method_decls:, return_type:)
+          super(node: node, context: context, method_name: method_name, receiver_type: receiver_type, return_type: return_type)
+          @actual_method_type = actual_method_type
+          @method_decls = method_decls
+        end
+
+        def pure?
+          method_decls.all? do |method_decl|
+            case member = method_decl.method_def.member
+            when RBS::AST::Members::MethodDefinition
+              member.annotations.any? {|annotation| annotation.string == "pure" }
+            when RBS::AST::Members::Attribute
+              # The attribute writer is not pure
+              !method_decl.method_name.method_name.end_with?("=")
+            end
+          end
+        end
+
+        def update(node: self.node, return_type: self.return_type)
+          _ = self.class.new(
+            node: node,
+            return_type: return_type,
+            context: context,
+            method_name: method_name,
+            receiver_type: receiver_type,
+            actual_method_type: actual_method_type,
+            method_decls: method_decls
+          )
+        end
+
+        def ==(other)
+          super &&
+          other.is_a?(Typed) &&
+            other.actual_method_type == actual_method_type &&
+            other.method_decls == method_decls
+        end
+
+        alias eql? ==
+
+        def hash
+          super ^ actual_method_type.hash ^ method_decls.hash
+        end
+      end
+
+      class Special < Typed
+      end
+
+      class Untyped < Base
+        def initialize(node:, context:, method_name:)
+          super(node: node, context: context, method_name: method_name, receiver_type: AST::Types::Any.instance, return_type: AST::Types::Any.instance)
+        end
+      end
+
+      class NoMethodError < Base
+        attr_reader :error
+
+        def initialize(node:, context:, method_name:, receiver_type:, error:)
+          super(node: node, context: context, method_name: method_name, receiver_type: receiver_type, return_type: AST::Types::Any.instance)
+          @error = error
+        end
+      end
+
+      class Error < Base
+        attr_reader :errors
+        attr_reader :method_decls
+
+        def initialize(node:, context:, method_name:, receiver_type:, errors:, method_decls: Set[], return_type: AST::Types::Any.instance)
+          super(node: node, context: context, method_name: method_name, receiver_type: receiver_type, return_type: return_type)
+          @method_decls = method_decls
+          @errors = errors
+        end
+      end
+    end
+  end
+end

data/lib/steep/type_inference/method_params.rb

@@ -0,0 +1,531 @@
+module Steep
+  module TypeInference
+    class MethodParams
+      class BaseParameter
+        attr_reader :name
+        attr_reader :type
+        attr_reader :node
+
+        def initialize(name:, type:, node:)
+          @name = name
+          @type = type
+          @node = node
+        end
+
+        def optional?
+          case node.type
+          when :optarg, :kwoptarg
+            true
+          else
+            false
+          end
+        end
+
+        def value
+          case node.type
+          when :optarg, :kwoptarg
+            node.children[1]
+          end
+        end
+
+        def var_type
+          type || AST::Builtin.any_type
+        end
+
+        def untyped?
+          !type
+        end
+
+        def ==(other)
+          other.class == self.class &&
+            other.name == name &&
+            other.type == type &&
+            other.value == value &&
+            other.node == node
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ name.hash ^ type.hash ^ value.hash ^ node.hash
+        end
+      end
+
+      class PositionalParameter < BaseParameter; end
+      class KeywordParameter < BaseParameter; end
+
+      class BaseRestParameter
+        attr_reader :name
+        attr_reader :type
+        attr_reader :node
+
+        def initialize(name:, type:, node:)
+          @name = name
+          @type = type
+          @node = node
+        end
+
+        def ==(other)
+          other.class == self.class &&
+            other.name == name &&
+            other.type == type &&
+            other.node == node
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ name.hash ^ type.hash ^ node.hash
+        end
+      end
+
+      class PositionalRestParameter < BaseRestParameter
+        def var_type
+          AST::Builtin::Array.instance_type(type || AST::Builtin.any_type)
+        end
+      end
+
+      class KeywordRestParameter < BaseRestParameter
+        def var_type
+          AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type, type || AST::Builtin.any_type)
+        end
+      end
+
+      class BlockParameter
+        attr_reader :name
+        attr_reader :type
+        attr_reader :node
+        attr_reader :self_type
+
+        def initialize(name:, type:, node:, optional:, self_type:)
+          @name = name
+          @type = type
+          @node = node
+          @optional = optional
+          @self_type = self_type
+        end
+
+        def optional?
+          @optional ? true : false
+        end
+
+        def var_type
+          if type
+            proc_type = AST::Types::Proc.new(type: type, block: nil, self_type: self_type)
+
+            if optional?
+              AST::Types::Union.build(types: [proc_type, AST::Builtin.nil_type])
+            else
+              proc_type
+            end
+          else
+            AST::Builtin.nil_type
+          end
+        end
+
+        def ==(other)
+          other.class == self.class &&
+            other.name == name &&
+            other.type == type &&
+            other.node == node &&
+            other.optional? == optional? &&
+            other.self_type == self_type
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ name.hash ^ type.hash ^ node.hash ^ optional?.hash ^ self_type.hash
+        end
+      end
+
+      attr_reader :args
+      attr_reader :method_type
+      attr_reader :params
+      attr_reader :errors
+      attr_reader :forward_arg_type
+
+      def initialize(args:, method_type:, forward_arg_type:)
+        @args = args
+        @method_type = method_type
+        @params = {}
+        @errors = []
+        @forward_arg_type = forward_arg_type
+      end
+
+      def [](name)
+        params[name] or raise "Unknown variable name: #{name}"
+      end
+
+      def param?(name)
+        params.key?(name)
+      end
+
+      def size
+        params.size
+      end
+
+      def each_param(&block)
+        if block
+          params.each_value(&block)
+        else
+          params.each_value
+        end
+      end
+
+      def each
+        if block_given?
+          each_param do |param|
+            yield param.name, param.var_type
+          end
+        else
+          enum_for :each
+        end
+      end
+
+      def update(forward_arg_type: self.forward_arg_type)
+        MethodParams.new(args: args, method_type: method_type, forward_arg_type: forward_arg_type)
+      end
+
+      def self.empty(node:)
+        # @type var args_node: ::Parser::AST::Node
+        args_node =
+          case node.type
+          when :def
+            node.children[1]
+          when :defs
+            node.children[2]
+          else
+            raise
+          end
+
+        params = new(args: args_node.children, method_type: nil, forward_arg_type: nil)
+
+        args_node.children.each do |arg|
+          # @type var arg: ::Parser::AST::Node
+          case arg.type
+          when :arg, :optarg
+            name = arg.children[0]
+            params.params[name] = PositionalParameter.new(name: name, type: nil, node: arg)
+          when :kwarg, :kwoptarg
+            name = arg.children[0]
+            params.params[name] = KeywordParameter.new(name: name, type: nil, node: arg)
+          when :restarg
+            name = arg.children[0]
+            params.params[name] = PositionalRestParameter.new(name: name, type: nil, node: arg)
+          when :kwrestarg
+            name = arg.children[0]
+            params.params[name] = KeywordRestParameter.new(name: name, type: nil, node: arg)
+          when :blockarg
+            name = arg.children[0]
+            params.params[name] = BlockParameter.new(name: name, type: nil, optional: nil, node: arg, self_type: nil)
+          end
+        end
+
+        params
+      end
+
+      def self.build(node:, method_type:)
+        # @type var args_node: ::Parser::AST::Node
+        args_node =
+          case node.type
+          when :def
+            node.children[1]
+          when :defs
+            node.children[2]
+          else
+            raise
+          end
+        original = args_node.children #: Array[Parser::AST::Node]
+        args = original.dup
+
+        instance = new(args: original, method_type: method_type, forward_arg_type: nil)
+
+        unless method_type.type.params
+          args.each do |arg|
+            case arg.type
+            when :arg
+              name = arg.children[0]
+              instance.params[name] = PositionalParameter.new(name: name, type: AST::Builtin.any_type, node: arg)
+            when :optarg
+              name = arg.children[0]
+              instance.params[name] = PositionalParameter.new(name: name, type: AST::Builtin.any_type, node: arg)
+            when :forward_arg
+              return instance.update(forward_arg_type: true)
+            end
+          end
+          return instance
+        end
+
+        positional_params = method_type.type.params.positional_params
+
+        loop do
+          arg = args.first or break
+
+          case arg.type
+          when :arg
+            name = arg.children[0]
+            param = positional_params&.head
+
+            case param
+            when Interface::Function::Params::PositionalParams::Required
+              instance.params[name] = PositionalParameter.new(name: name, type: param.type, node: arg)
+            when Interface::Function::Params::PositionalParams::Optional
+              method_param = PositionalParameter.new(name: name, type: param.type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            when Interface::Function::Params::PositionalParams::Rest
+              method_param = PositionalParameter.new(name: name, type: param.type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            when nil
+              method_param = PositionalParameter.new(name: name, type: nil, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            end
+
+            positional_params = positional_params&.tail
+
+          when :optarg
+            name = arg.children[0]
+            param = positional_params&.head
+
+            case param
+            when Interface::Function::Params::PositionalParams::Required
+              method_param = PositionalParameter.new(name: name, type: param.type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            when Interface::Function::Params::PositionalParams::Optional
+              instance.params[name] = PositionalParameter.new(name: name, type: param.type, node: arg)
+            when Interface::Function::Params::PositionalParams::Rest
+              method_param = PositionalParameter.new(name: name, type: param.type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            when nil
+              method_param = PositionalParameter.new(name: name, type: nil, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            end
+
+            positional_params = positional_params&.tail
+          else
+            break
+          end
+
+          args.shift
+        end
+
+        if (arg = args.first) && arg.type == :forward_arg
+          forward_params = method_type.type.params.update(positional_params: positional_params)
+          return instance.update(forward_arg_type: [forward_params, method_type.block])
+        end
+
+        if (arg = args.first) && arg.type == :restarg
+          name = arg.children[0]
+          rest_types = [] #: Array[AST::Types::t]
+          has_error = false
+
+          loop do
+            param = positional_params&.head
+
+            case param
+            when Interface::Function::Params::PositionalParams::Required
+              rest_types << param.type
+              has_error = true
+            when Interface::Function::Params::PositionalParams::Optional
+              rest_types << param.type
+              has_error = true
+            when Interface::Function::Params::PositionalParams::Rest
+              rest_types << param.type
+              positional_params = nil
+              args.shift
+              break
+            when nil
+              has_error = true
+              break
+            end
+
+            if positional_params
+              positional_params = positional_params.tail
+            else
+              raise "Fatal error"
+            end
+          end
+
+          type = rest_types.empty? ? nil : AST::Types::Union.build(types: rest_types)
+
+          method_param = PositionalRestParameter.new(name: name, type: type, node: arg)
+          instance.params[name] = method_param
+          if has_error
+            instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+              method_param: method_param,
+              method_type: method_type
+            )
+          end
+        end
+
+        if positional_params
+          instance.errors << Diagnostic::Ruby::MethodArityMismatch.new(node: node, method_type: method_type)
+        end
+
+        keyword_params = method_type.type.params.keyword_params
+        keywords = keyword_params.keywords
+
+        loop do
+          arg = args.first or break
+
+          case arg.type
+          when :kwarg
+            name = arg.children[0]
+
+            case
+            when type = keyword_params.requireds[name]
+              instance.params[name] = KeywordParameter.new(name: name, type: type, node: arg)
+              keywords.delete(name)
+            when type = keyword_params.optionals[name]
+              method_param = KeywordParameter.new(name: name, type: type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+              keywords.delete(name)
+            when type = keyword_params.rest
+              method_param = KeywordParameter.new(name: name, type: type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+              keywords.delete(name)
+            else
+              method_param = KeywordParameter.new(name: name, type: nil, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::MethodParameterMismatch.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            end
+          when :kwoptarg
+            name = arg.children[0]
+
+            case
+            when type = keyword_params.requireds[name]
+              method_param = KeywordParameter.new(name: name, type: type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+              keywords.delete(name)
+            when type = keyword_params.optionals[name]
+              method_param = KeywordParameter.new(name: name, type: type, node: arg)
+              instance.params[name] = method_param
+              keywords.delete(name)
+            when type = keyword_params.rest
+              method_param = KeywordParameter.new(name: name, type: type, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+              keywords.delete(name)
+            else
+              method_param = KeywordParameter.new(name: name, type: nil, node: arg)
+              instance.params[name] = method_param
+              instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+                method_param: method_param,
+                method_type: method_type
+              )
+            end
+          else
+            break
+          end
+
+          args.shift
+        end
+
+        if (arg = args.first) && arg.type == :kwrestarg
+          name = arg.children[0]
+          rest_types = [] #: Array[AST::Types::t]
+          has_error = false
+
+          keywords.each do |keyword|
+            rest_types << (keyword_params.requireds[keyword] || keyword_params.optionals.fetch(keyword))
+            has_error = true
+          end
+          keywords.clear
+
+          if keyword_params.rest
+            rest_types << keyword_params.rest
+          else
+            has_error = true
+          end
+
+          type = rest_types.empty? ? nil : AST::Types::Union.build(types: rest_types)
+
+          method_param = KeywordRestParameter.new(name: name, type: type, node: arg)
+          instance.params[name] = method_param
+
+          if has_error
+            instance.errors << Diagnostic::Ruby::DifferentMethodParameterKind.new(
+              method_param: method_param,
+              method_type: method_type
+            )
+          end
+
+          args.shift
+        else
+          if !keywords.empty? || keyword_params.rest
+            instance.errors << Diagnostic::Ruby::MethodArityMismatch.new(
+              node: node,
+              method_type: method_type
+            )
+          end
+        end
+
+        if (arg = args.first) && arg.type == :blockarg
+          name = arg.children[0] #: Symbol
+
+          if method_type.block
+            instance.params[name] = BlockParameter.new(
+              name: name,
+              type: method_type.block.type,
+              optional: method_type.block.optional?,
+              node: arg,
+              self_type: method_type.block.self_type
+            )
+          else
+            instance.params[name] = BlockParameter.new(
+              name: name,
+              type: nil,
+              optional: nil,
+              node: arg,
+              self_type: nil
+            )
+          end
+        end
+
+        instance
+      end
+    end
+  end
+end