steep 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1aa31e85a07f6ac87650d401444230861764800154bfe367724f5cd9f0813ea0
-  data.tar.gz: b7b38997f73d6ac3cf030e1114fb9f6d2c20afb9635a922fe86256ee6e5359b5
+  metadata.gz: 0c1966d8fc74abea789649fe945211c56d81da2fc655860d22849aacc7feae9f
+  data.tar.gz: f4b9793cb25421d5a9e031b78df1c29f1350f9d7cd184f12c772065607664afc
 SHA512:
-  metadata.gz: 805a6bcc465e951a41d7742fb3ff82f6c8ccedc137aa3be4969539f4610086c6949f6fc04ca461533847aa745464827f763fb1c1943d0f13e5f309e0414fd64a
-  data.tar.gz: 8677c727c5f7ffc4bb9994cc7eff5bf06c240df29d7fbbd8796a58666ac261a0137e206a397d5c0af0a7210ed12ef391019a0a209497520dc04a98d81948a63c
+  metadata.gz: 4d3309eb83780ad4f157a7c7cc9b4bfb1763aac6ff6a2f905838b5f9bebb462ff7fb7bb2d381af5dc6698287b57ee097301d60143e9385804ca2a4700b5f3466
+  data.tar.gz: 1e142225c3dfe0d2ed47831f97840ded1a24c5348e734b3767ce1784546a71bcf5bbb1fd57bfc0baad9ec51b6a3002dacc41535ae451a06b8d6a6e4931ec7e9d

data/.travis.yml

@@ -1,6 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.5.0
+  - 2.5.3
 before_install: gem install bundler -v 1.13.7
 script: bundle exec rake test smoke

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 0.7.1 (2018-10-22)
+
+* Rename *hash type* to *record type* (#60)
+* Fix keyword typing (#59)
+
 ## 0.7.0 (2018-09-24)
 
 * Add some builtin

data/lib/steep/ast/types/{hash.rb → record.rb}

@@ -1,7 +1,7 @@
 module Steep
   module AST
     module Types
-      class Hash
+      class Record
         attr_reader :location
         attr_reader :elements
 
@@ -11,7 +11,7 @@ module Steep
         end
 
         def ==(other)
-          other.is_a?(Hash) && other.elements == elements
+          other.is_a?(Record) && other.elements == elements
         end
 
         def hash

data/lib/steep/cli.rb

@@ -16,7 +16,7 @@ module Steep
     end
 
     def self.available_commands
-      [:check, :validate, :annotations, :scaffold, :interface]
+      [:check, :validate, :annotations, :scaffold, :interface, :version]
     end
 
     def setup_global_options
@@ -127,5 +127,9 @@ module Steep
 
       Drivers::PrintInterface.new(type_name: argv.first, signature_dirs: signature_dirs, stdout: stdout, stderr: stderr).run
     end
+
+    def process_version
+      stdout.puts Steep::VERSION
+    end
   end
 end

data/lib/steep/drivers/check.rb

@@ -65,8 +65,6 @@ module Steep
             Steep.logger.debug "Typechecking..."
             annotations = source.annotations(block: source.node, builder: check.builder, current_module: AST::Namespace.root)
 
-            pp annotations if verbose
-
             const_env = TypeInference::ConstantEnv.new(builder: check.builder, context: nil)
             type_env = TypeInference::TypeEnv.build(annotations: annotations,
                                                     subtyping: check,

data/lib/steep/drivers/print_interface.rb

@@ -29,7 +29,7 @@ module Steep
             builder = Interface::Builder.new(signatures: env)
             check = Subtyping::Check.new(builder: builder)
 
-            interface = check.resolve(type, with_initialize: true)
+            interface = check.resolve(type)
 
             stdout.puts "#{type}"
             stdout.puts "- Instance variables:"

data/lib/steep/errors.rb

@@ -503,5 +503,31 @@ module Steep
         "#{location_to_str}: IncompatibleTuple: expected_tuple=#{expected_tuple}"
       end
     end
+
+    class UnexpectedKeyword < Base
+      attr_reader :unexpected_keywords
+
+      def initialize(node:, unexpected_keywords:)
+        super(node: node)
+        @unexpected_keywords = unexpected_keywords
+      end
+
+      def to_s
+        "#{location_to_str}: UnexpectedKeyword: #{unexpected_keywords.join(", ")}"
+      end
+    end
+
+    class MissingKeyword < Base
+      attr_reader :missing_keywords
+
+      def initialize(node:, missing_keywords:)
+        super(node: node)
+        @missing_keywords = missing_keywords
+      end
+
+      def to_s
+        "#{location_to_str}: MissingKeyword: #{missing_keywords.join(", ")}"
+      end
+    end
   end
 end

data/lib/steep/interface/builder.rb

@@ -85,8 +85,8 @@ module Steep
             return_type: absolute_type(type.return_type, current: current),
             location: type.location
           )
-        when AST::Types::Hash
-          AST::Types::Hash.new(
+        when AST::Types::Record
+          AST::Types::Record.new(
             elements: type.elements.transform_values {|ty| absolute_type(ty, current: current) },
             location: type.location
           )

data/lib/steep/interface/method_type.rb

@@ -62,6 +62,35 @@ module Steep
         !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
       end
 
+      def without_keywords
+        self.class.new(
+          required: required,
+          optional: optional,
+          rest: rest,
+          required_keywords: {},
+          optional_keywords: {},
+          rest_keywords: nil
+        )
+      end
+
+      def drop_first
+        case
+        when required.any? || optional.any? || rest
+          self.class.new(
+            required: required.any? ? required.drop(1) : [],
+            optional: required.empty? && optional.any? ? optional.drop(1) : optional,
+            rest: required.empty? && optional.empty? ? nil : rest,
+            required_keywords: required_keywords,
+            optional_keywords: optional_keywords,
+            rest_keywords: rest_keywords
+          )
+        when has_keywords?
+          without_keywords
+        else
+          raise "Cannot drop from empty params"
+        end
+      end
+
       def each_missing_argument(args)
         required.size.times do |index|
           if index >= args.size
@@ -160,10 +189,6 @@ module Steep
         required.all?(&:closed?) && optional.all?(&:closed?) && (!rest || rest.closed?) && required_keywords.values.all?(&:closed?) && optional_keywords.values.all?(&:closed?) && (!rest_keywords || rest_keywords.closed?)
       end
 
-      def has_keyword?
-        required_keywords.any? || optional_keywords.any? || rest_keywords
-      end
-
       def subst(s)
         self.class.new(
           required: required.map {|t| t.subst(s) },
@@ -199,6 +224,10 @@ module Steep
           rest_keywords: rest_keywords && yield(rest_keywords)
         )
       end
+
+      def empty?
+        required.empty? && optional.empty? && !rest && !has_keywords?
+      end
     end
 
     class Block

data/lib/steep/parser.rb

@@ -1846,7 +1846,7 @@ module_eval(<<'.,.,', 'parser.y', 399)
 module_eval(<<'.,.,', 'parser.y', 403)
   def _reduce_76(val, _values, result)
                                       location = val[0].location + val[2].location
-                                  result = AST::Types::Hash.new(elements: val[1], location: location)
+                                  result = AST::Types::Record.new(elements: val[1], location: location)
                                 
     result
   end

data/lib/steep/parser.y

@@ -402,7 +402,7 @@ rule
                               | tLBRACE hash_elements tRBRACE
                                 {
                                   location = val[0].location + val[2].location
-                                  result = AST::Types::Hash.new(elements: val[1], location: location)
+                                  result = AST::Types::Record.new(elements: val[1], location: location)
                                 }
                               | simple_type
 

data/lib/steep/subtyping/check.rb

@@ -225,6 +225,25 @@ module Steep
                           trace: trace,
                           constraints: constraints)
 
+        when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
+          if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
+            keys = relation.super_type.elements.keys
+            type_pairs = keys.map {|key| [relation.sub_type.elements[key], relation.super_type.elements[key]] }
+            results = type_pairs.flat_map do |t1, t2|
+              relation = Relation.new(sub_type: t1, super_type: t2)
+              [check0(relation, assumption: assumption, trace: trace, constraints: constraints),
+               check0(relation.flip, assumption: assumption, trace: trace, constraints: constraints)]
+            end
+
+            if results.all?(&:success?)
+              success(constraints: constraints)
+            else
+              results.find(&:failure?)
+            end
+          else
+            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                    trace: trace)
+          end
         else
           failure(error: Result::Failure::UnknownPairError.new(relation: relation),
                   trace: trace)
@@ -575,51 +594,6 @@ module Steep
         end
       end
 
-      def module_type(type)
-        case type.name
-        when TypeName::Instance
-          case
-          when builder.signatures.class_name?(type.name.name)
-            type.class_type(constructor: nil)
-          when builder.signatures.module_name?(type.name.name)
-            type.module_type
-          end
-        else
-          nil
-        end
-      end
-
-      def compact(types)
-        types = types.reject {|type| type.is_a?(AST::Types::Any) }
-
-        if types.empty?
-          [AST::Types::Any.new]
-        else
-          compact0(types)
-        end
-      end
-
-      def compact0(types)
-        if types.size == 1
-          types
-        else
-          type, *types_ = types
-          compacted = compact0(types_)
-          compacted.flat_map do |type_|
-            case
-            when type == type_
-              [type]
-            when check(Relation.new(sub_type: type_, super_type: type), constraints: Constraints.empty).success?
-              [type]
-            when check(Relation.new(sub_type: type, super_type: type_), constraints: Constraints.empty).success?
-              [type_]
-            else
-              [type, type_]
-            end
-          end.uniq
-        end
-      end
-
       class CannotResolveError < StandardError
         attr_reader :type
 
@@ -892,7 +866,7 @@ module Steep
             array_interface
           end
 
-        when AST::Types::Hash
+        when AST::Types::Record
           yield_self do
             key_type = AST::Types::Union.build(types: type.elements.keys.map {|val| AST::Types::Literal.new(value: val) })
             value_type = AST::Types::Union.build(types: type.elements.values)

data/lib/steep/type_construction.rb

@@ -1555,13 +1555,13 @@ module Steep
       end
     end
 
-    def check(node, type)
+    def check(node, type, constraints: Subtyping::Constraints.empty)
       type_ = synthesize(node, hint: type)
 
       result = checker.check(
         Subtyping::Relation.new(sub_type: type_,
                                 super_type: type),
-        constraints: Subtyping::Constraints.empty
+        constraints: constraints
       )
       if result.failure?
         yield(type, type_, result)
@@ -1881,24 +1881,36 @@ module Steep
     def type_method_call(node, receiver_type:, method:, args:, block_params:, block_body:)
       results = method.types.map do |method_type|
         Steep.logger.tagged method_type.location&.source do
-          child_typing = typing.new_child
-          arg_pairs = args.zip(method_type.params, method_type.block&.type)
-
-          type_or_error = if arg_pairs
-                            self.with_new_typing(child_typing).try_method_type(
-                              node,
-                              receiver_type: receiver_type,
-                              method_type: method_type,
-                              args: args,
-                              arg_pairs: arg_pairs,
-                              block_params: block_params,
-                              block_body: block_body,
-                              child_typing: child_typing
-                            )
-                          else
-                            Steep.logger.debug(node.inspect)
-                            Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type)
-                          end
+          zips = args.zips(method_type.params, method_type.block&.type)
+
+          type_or_error, child_typing = if zips.any?
+                                          zips.map do |arg_pairs|
+                                            child_typing = typing.new_child
+
+                                            result = self.with_new_typing(child_typing).try_method_type(
+                                              node,
+                                              receiver_type: receiver_type,
+                                              method_type: method_type,
+                                              args: args,
+                                              arg_pairs: arg_pairs,
+                                              block_params: block_params,
+                                              block_body: block_body,
+                                              child_typing: child_typing
+                                            )
+
+                                            unless result.is_a?(Errors::Base)
+                                              break [[result, child_typing]]
+                                            end
+
+                                            [result, child_typing]
+                                          end.first
+                                        else
+                                          Steep.logger.debug(node.inspect)
+                                          [
+                                            Errors::IncompatibleArguments.new(node: node, receiver_type: receiver_type, method_type: method_type),
+                                            typing.new_child
+                                          ]
+                                        end
 
           [child_typing, type_or_error, method_type]
         end
@@ -1922,6 +1934,139 @@ module Steep
       end
     end
 
+    def check_keyword_arg(receiver_type:, node:, method_type:, constraints:)
+      params = method_type.params
+
+      case node.type
+      when :hash
+        keyword_hash_type = AST::Builtin::Hash.instance_type(AST::Builtin::Symbol.instance_type,
+                                                             AST::Builtin.any_type)
+        typing.add_typing node, keyword_hash_type
+
+        given_keys = Set.new()
+
+        node.children.each do |element|
+          case element.type
+          when :pair
+            key_node, value_node = element.children
+
+            case key_node.type
+            when :sym
+              key_symbol = key_node.children[0]
+              keyword_type = case
+                             when params.required_keywords.key?(key_symbol)
+                               params.required_keywords[key_symbol]
+                             when params.optional_keywords.key?(key_symbol)
+                               AST::Types::Union.build(
+                                 types: [params.optional_keywords[key_symbol],
+                                         AST::Builtin.nil_type]
+                               )
+                             when params.rest_keywords
+                               params.rest_keywords
+                             end
+
+              typing.add_typing key_node, AST::Builtin::Symbol.instance_type
+
+              given_keys << key_symbol
+
+              if keyword_type
+                check(value_node, keyword_type, constraints: constraints) do |expected, actual, result|
+                  return Errors::IncompatibleAssignment.new(
+                    node: value_node,
+                    lhs_type: expected,
+                    rhs_type: actual,
+                    result: result
+                  )
+                end
+              else
+                synthesize(value_node)
+              end
+
+            else
+              check(key_node, AST::Builtin::Symbol.instance_type, constraints: constraints) do |expected, actual, result|
+                return Errors::IncompatibleAssignment.new(
+                  node: key_node,
+                  lhs_type: expected,
+                  rhs_type: actual,
+                  result: result
+                )
+              end
+            end
+
+          when :kwsplat
+            Steep.logger.warn("Keyword arg with kwsplat(**) node are not supported.")
+
+            check(element.children[0], keyword_hash_type, constraints: constraints) do |expected, actual, result|
+              return Errors::IncompatibleAssignment.new(
+                node: node,
+                lhs_type: expected,
+                rhs_type: actual,
+                result: result
+              )
+            end
+
+            given_keys = true
+          end
+        end
+
+        case given_keys
+        when Set
+          missing_keywords = Set.new(params.required_keywords.keys) - given_keys
+          unless missing_keywords.empty?
+            return Errors::MissingKeyword.new(node: node,
+                                              missing_keywords: missing_keywords)
+          end
+
+          extra_keywords = given_keys - Set.new(params.required_keywords.keys) - Set.new(params.optional_keywords.keys)
+          if extra_keywords.any? && !params.rest_keywords
+            return Errors::UnexpectedKeyword.new(node: node,
+                                                 unexpected_keywords: extra_keywords)
+          end
+        end
+      else
+        if params.rest_keywords
+          Steep.logger.warn("Method call with rest keywords type is detected. Rough approximation to be improved.")
+
+          value_types = params.required_keywords.values +
+            params.optional_keywords.values.map {|type| AST::Types::Union.build(types: [type, AST::Builtin.nil_type]) } +
+            [params.rest_keywords]
+
+          hash_type = AST::Builtin::Hash.instance_type(
+            AST::Builtin::Symbol.instance_type,
+            AST::Types::Union.build(types: value_types,
+                                    location: method_type.location)
+          )
+        else
+          hash_elements = params.required_keywords.merge(
+            method_type.optional_keywords.transform_values do |type|
+              AST::Types::Union.build(types: [type, AST::Builtin.nil_type],
+                                      location: method_type.location)
+            end
+          )
+
+          hash_type = AST::Types::Record.new(elements: hash_elements)
+        end
+
+        node_type = synthesize(node, hint: hash_type)
+
+        relation = Subtyping::Relation.new(
+          sub_type: node_type,
+          super_type: hash_type
+        )
+
+        checker.check(relation, constraints: constraints).else do
+          return Errors::ArgumentTypeMismatch.new(
+            node: node,
+            receiver_type: receiver_type,
+            expected: relation.super_type,
+            actual: relation.sub_type
+          )
+        end
+      end
+
+      nil
+    end
+
     def try_method_type(node, receiver_type:, method_type:, args:, arg_pairs:, block_params:, block_body:, child_typing:)
       fresh_types = method_type.type_params.map {|x| AST::Types::Var.fresh(x) }
       fresh_vars = Set.new(fresh_types.map(&:name))
@@ -1945,28 +2090,43 @@ module Steep
         variance = Subtyping::VariableVariance.from_method_type(method_type)
         occurence = Subtyping::VariableOccurence.from_method_type(method_type)
 
-        arg_pairs.each do |(arg_node, param_type)|
-          param_type = param_type.subst(instantiation)
+        arg_pairs.each do |pair|
+          case pair
+          when Array
+            (arg_node, param_type) = pair
 
-          arg_type = if arg_node.type == :splat
-                       type = construction.synthesize(arg_node.children[0])
-                       child_typing.add_typing(arg_node, type)
-                     else
-                       construction.synthesize(arg_node, hint: param_type)
-                     end
+            param_type = param_type.subst(instantiation)
 
-          relation = Subtyping::Relation.new(
-            sub_type: arg_type,
-            super_type: param_type
-          )
+            arg_type = if arg_node.type == :splat
+                         type = construction.synthesize(arg_node.children[0])
+                         child_typing.add_typing(arg_node, type)
+                       else
+                         construction.synthesize(arg_node, hint: param_type)
+                       end
 
-          checker.check(relation, constraints: constraints).else do |result|
-            return Errors::ArgumentTypeMismatch.new(
-              node: arg_node,
-              receiver_type: receiver_type,
-              expected: relation.super_type,
-              actual: relation.sub_type
+            relation = Subtyping::Relation.new(
+              sub_type: arg_type,
+              super_type: param_type
             )
+
+            checker.check(relation, constraints: constraints).else do |result|
+              return Errors::ArgumentTypeMismatch.new(
+                node: arg_node,
+                receiver_type: receiver_type,
+                expected: relation.super_type,
+                actual: relation.sub_type
+              )
+            end
+          else
+            # keyword
+            result = check_keyword_arg(receiver_type: receiver_type,
+                                       node: pair,
+                                       method_type: method_type,
+                                       constraints: constraints)
+
+            if result.is_a?(Errors::Base)
+              return result
+            end
           end
         end
 
@@ -2496,10 +2656,10 @@ module Steep
     end
 
     def try_hash_type(node, hint)
-      if hint.is_a?(AST::Types::Hash)
+      if hint.is_a?(AST::Types::Record)
         typing.new_child do |child_typing|
           new_construction = with_new_typing(child_typing)
-          elem_types = hint.elements.dup
+          elements = {}
 
           each_child_node(node) do |child|
             case child.type
@@ -2513,22 +2673,28 @@ module Steep
                             return nil
                           end
 
-              return nil unless elem_types.key?(key_value)
-
               key_hint = AST::Types::Literal.new(value: key_value)
-              value_hint = elem_types.delete(key_value)
+              value_hint = hint.elements[key_value]
+
+              value_type = new_construction.synthesize(value, hint: value_hint)
+
+              if value_hint
+                relation = Subtyping::Relation.new(sub_type: value_type, super_type: value_hint)
+                if checker.check(relation, constraints: Subtyping::Constraints.empty).success?
+                  value_type = value_hint
+                end
+              end
 
-              new_construction.check(key, key_hint) { return nil }
-              new_construction.check(value, value_hint) { return nil }
+              elements[key_value] = value_type
             else
               return nil
             end
           end
 
-          return nil unless elem_types.empty?
-
           child_typing.save!
-          return typing.add_typing(node, hint)
+
+          hash = AST::Types::Record.new(elements: elements)
+          typing.add_typing(node, hash)
         end
       end
     end

data/lib/steep/type_inference/send_args.rb

@@ -2,12 +2,10 @@ module Steep
   module TypeInference
     class SendArgs
       attr_reader :args
-      attr_reader :kw_args
       attr_reader :block_pass_arg
 
-      def initialize(args:, kw_args:, block_pass_arg:)
+      def initialize(args:, block_pass_arg:)
         @args = args
-        @kw_args = kw_args
         @block_pass_arg = block_pass_arg
       end
 
@@ -15,7 +13,6 @@ module Steep
         nodes = nodes.dup
 
         args = []
-        last_hash = nil
         block_pass_arg = nil
 
         if nodes.last&.type == :block_pass
@@ -23,38 +20,20 @@ module Steep
         end
 
         nodes.each do |node|
-          if last_hash
-            args << last_hash
-            last_hash = nil
-          end
-
-          case node.type
-          when :hash
-            last_hash = node
-          else
-            args << node
-          end
+          args << node
         end
 
-        if last_hash
-          unless kw_args?(last_hash)
-            args << last_hash
-            last_hash = nil
-          end
-        end
+        new(args: args, block_pass_arg: block_pass_arg)
+      end
 
-        new(args: args, kw_args: last_hash, block_pass_arg: block_pass_arg)
+      def drop_first
+        raise "Cannot drop first from empty args" if args.empty?
+        self.class.new(args: args.drop(1), block_pass_arg: block_pass_arg)
       end
 
-      def self.kw_args?(node)
-        node.children.all? do |child|
-          case child.type
-          when :pair
-            child.children[0].type == :sym
-          when :kwsplat
-            true
-          end
-        end
+      def drop_last
+        raise "Cannot drop last from empty args" if args.empty?
+        self.class.new(args: args.take(args.size - 1), block_pass_arg: block_pass_arg)
       end
 
       def each_keyword_arg
@@ -81,146 +60,135 @@ module Steep
         end
       end
 
-      def zip(params, block)
-        Set.new(
-          [].tap do |pairs|
-            consumed_keywords = Set.new
-            rest_types = []
-
-            params.required_keywords.each do |name, type|
-              if (node = each_keyword_arg.find {|pair| pair.children[0].children[0] == name })
-                pairs << [node.children[1], type]
-                consumed_keywords << name
-              else
-                if kwsplat_nodes.any?
-                  rest_types << type
-                else
-                  return
-                end
-              end
-            end
+      def zips(params, block_type)
+        zip0(params, block_type).map do |pairs|
+          group_pairs(pairs)
+        end
+      end
 
-            params.optional_keywords.each do |name, type|
-              if (node = each_keyword_arg.find {|pair| pair.children[0].children[0] == name })
-                pairs << [node.children[1], type]
-                consumed_keywords << name
-              else
-                if kwsplat_nodes.any?
-                  rest_types << type
-                end
-              end
-            end
+      def group_pairs(pairs)
+        types = pairs.each_with_object({}) do |pair, hash|
+          case pair
+          when Array
+            node, type = pair
+            hash[node.__id__] ||= [node]
+            hash[node.__id__] << type
+          else
+            hash[node.__id__] = pair
+          end
+        end
 
-            if params.rest_keywords
-              each_keyword_arg do |pair|
-                name = pair.children[0].children[0]
-                node = pair.children[1]
+        types.map do |_, array|
+          case array
+          when Array
+            node, *types_ = array
+            [node, AST::Types::Intersection.build(types: types_)]
+          else
+            array
+          end
+        end
+      end
 
-                unless consumed_keywords.include?(name)
-                  pairs << [node, params.rest_keywords]
-                end
-              end
+      def add_pair(pairs, pair)
+        pairs.map do |ps|
+          if block_given?
+            yield ps, pair
+          else
+            [pair] + ps
+          end
+        end
+      end
 
-              if kwsplat_nodes.any?
-                pairs << [kw_args,
-                          AST::Builtin::Hash.instance_type(
-                            AST::Builtin::Symbol.instance_type,
-                            AST::Types::Union.build(types: rest_types + [params.rest_keywords])
-                          )]
-              end
-            end
+      def zip0(params, block_type)
+        case
+        when params.empty? && args.empty?
+          [[]]
 
-            if params.has_keyword?
-              if !params.rest_keywords
-                if kwsplat_nodes.empty?
-                  if each_keyword_arg.any? {|pair| !consumed_keywords.include?(pair.children[0].children[0]) }
-                    return
-                  end
-                end
-              end
-            end
+        when params.required.any?
+          if args.any?
+            first_arg = args[0]
 
-            args = self.args.dup
-            unless params.has_keyword?
-              args << kw_args if kw_args
+            case first_arg.type
+            when :splat
+              []
+            else
+              rest = drop_first.zip0(params.drop_first, block_type)
+              pair = [first_arg, params.required[0]]
+
+              add_pair(rest, pair)
             end
+          else
+            []
+          end
 
-            arg_types = {}
+        when params.has_keywords? && params.required_keywords.any?
+          if args.any?
+            rest = drop_last.zip0(params.without_keywords, block_type)
+            last_arg = args.last
 
-            params.required.each do |param|
-              if args.any?
-                next_arg(args) do |arg|
-                  save_arg_type(arg, param, arg_types)
-                end
-                consume_arg(args)
-              else
-                return
-              end
-            end
+            return [] if last_arg.type == :splat
 
-            params.optional.each do |param|
-              next_arg(args) do |arg|
-                save_arg_type(arg, param, arg_types)
-              end
-              consume_arg(args)
+            add_pair(rest, last_arg) do |ps, p|
+              ps + [p]
             end
+          else
+            []
+          end
 
-            if args.any?
-              if params.rest
-                args.each do |arg|
-                  save_arg_type(arg, params.rest, arg_types)
-                end
-              else
-                if args.none? {|arg| arg.type == :splat }
-                  return
-                end
-              end
-            end
+        when params.has_keywords? && params.required_keywords.empty?
+          if args.any?
+            rest = drop_last.zip0(params.without_keywords, block_type)
+            last_arg = args.last
 
-            (self.args + [kw_args].compact).each do |arg|
-              types = arg_types[arg.object_id]
+            no_keyword = zip0(params.without_keywords, block_type)
 
-              if types
-                if arg.type == :splat
-                  type = AST::Builtin::Array.instance_type(AST::Types::Union.build(types: types))
-                else
-                  type = AST::Types::Union.build(types: types)
-                end
-                pairs << [arg, type]
-              end
+            if last_arg.type == :splat
+              no_keyword
+            else
+              add_pair(rest, last_arg) do |ps, p|
+                ps + [p]
+              end + no_keyword
             end
+          else
+            zip0(params.without_keywords, block_type)
           end
-        )
-      end
 
-      def save_arg_type(arg, type, hash)
-        if hash.key?(arg.object_id)
-          types = hash[arg.object_id]
-        else
-          types = hash[arg.object_id] = []
-        end
-
-        types << type
-      end
-
-      def next_arg(args)
-        if args.any?
-          case args[0].type
-          when :splat
-            args.each do |arg|
-              yield arg
+        when params.optional.any?
+          if args.any?
+            first_arg = args[0]
+
+            case first_arg.type
+            when :splat
+              rest = zip0(params.drop_first, block_type)
+              pair = [args[0], AST::Builtin::Array.instance_type(params.optional[0])]
+            else
+              rest = drop_first.zip0(params.drop_first, block_type)
+              pair = [args[0], params.optional[0]]
             end
+
+            add_pair(rest, pair)
           else
-            yield args[0]
+            zip0(params.drop_first, block_type)
           end
-        end
-      end
 
-      def consume_arg(args)
-        if args.any?
-          unless args[0].type == :splat
-            args.shift
+        when params.rest
+          if args.any?
+            rest = drop_first.zip0(params, block_type)
+            first_arg = args[0]
+
+            case first_arg.type
+            when :splat
+              pair = [first_arg, AST::Builtin::Array.instance_type(params.rest)]
+            else
+              pair = [first_arg, params.rest]
+            end
+
+            add_pair(rest, pair)
+          else
+            zip0(params.drop_first, block_type)
           end
+        else
+          []
         end
       end
     end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/lib/steep.rb

@@ -28,7 +28,7 @@ require "steep/ast/types/literal"
 require "steep/ast/types/boolean"
 require "steep/ast/types/tuple"
 require "steep/ast/types/proc"
-require "steep/ast/types/hash"
+require "steep/ast/types/record"
 require "steep/ast/method_type"
 require "steep/ast/type_params"
 require "steep/ast/signature/class"

data/smoke/hash/d.rb

@@ -2,5 +2,5 @@
 
 params = { id: 30, name: "Matz" }
 
-# !expects IncompatibleAssignment: lhs_type={ :name => ::String, :id => ::Integer }, rhs_type=::Hash<::Symbol, ::String>
+# !expects IncompatibleAssignment: lhs_type={ :name => ::String, :id => ::Integer }, rhs_type={ :id => ::String, :name => ::String, :email => ::String }
 params = { id: "30", name: "foo", email: "matsumoto@soutaro.com" }

data/smoke/hash/e.rb

@@ -0,0 +1,2 @@
+# !expects NoMethodError: type=::Integer, method=fffffffffffff
+Foo.new.get({ foo: 3 }).fffffffffffff

data/smoke/hash/e.rbi

@@ -0,0 +1,3 @@
+class Foo
+  def get: <'a> ({ foo: 'a }) -> 'a
+end

data/smoke/literal/b.rb

@@ -5,5 +5,5 @@ l.foo(3)
 l.foo(4)
 
 l.bar(foo: :foo)
-# !expects ArgumentTypeMismatch: receiver=::LiteralMethods, expected=:foo, actual=::Symbol
+# !expects IncompatibleAssignment: lhs_type=:foo, rhs_type=::Symbol
 l.bar(foo: :bar)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-23 00:00:00.000000000 Z
+date: 2018-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,7 +169,6 @@ files:
 - lib/steep/ast/types/boolean.rb
 - lib/steep/ast/types/bot.rb
 - lib/steep/ast/types/class.rb
-- lib/steep/ast/types/hash.rb
 - lib/steep/ast/types/helper.rb
 - lib/steep/ast/types/instance.rb
 - lib/steep/ast/types/intersection.rb
@@ -177,6 +176,7 @@ files:
 - lib/steep/ast/types/name.rb
 - lib/steep/ast/types/nil.rb
 - lib/steep/ast/types/proc.rb
+- lib/steep/ast/types/record.rb
 - lib/steep/ast/types/self.rb
 - lib/steep/ast/types/top.rb
 - lib/steep/ast/types/tuple.rb
@@ -264,6 +264,8 @@ files:
 - smoke/hash/b.rb
 - smoke/hash/c.rb
 - smoke/hash/d.rb
+- smoke/hash/e.rb
+- smoke/hash/e.rbi
 - smoke/hello/hello.rb
 - smoke/hello/hello.rbi
 - smoke/if/a.rb