steep 0.6.0 → 0.7.0

data/lib/steep/parser.y

@@ -667,6 +667,15 @@ rule
                                     type: val[2]
                                   )
                                 }
+                              | kAT_TYPE tCOLON type
+                                {
+                                  loc = val.first.location + val.last.location
+                                  result = AST::Signature::Members::Ivar.new(
+                                    location: loc,
+                                    name: :"@type",
+                                    type: val[2]
+                                  )
+                                }
 
         instance_method_member: kDEF method_annotations method_name tCOLON method_type_union
                                 {
@@ -918,7 +927,7 @@ rule
                                                                         name: val[2].value,
                                                                         type: val[4])
                                 }
-                              | kAT_TYPE kMETHOD subject tCOLON method_type
+                              | kAT_TYPE kMETHOD method_name tCOLON method_type
                                 {
                                   loc = val.first.location + val.last.location
                                   result = AST::Annotation::MethodType.new(location: loc,
@@ -1212,10 +1221,6 @@ def next_token
     new_token(:kNOCONSTRUCTOR, :noconstructor)
   when input.scan(/\$\w+\b/)
     new_token(:tGVAR, input.matched.to_sym)
-  when input.scan(/::([A-Z]\w*::)*[A-Z]\w*/)
-    new_token(:tQUALIFIED_MODULE_NAME, Names::Module.parse(input.matched))
-  when input.scan(/([A-Z]\w*::)+[A-Z]\w*/)
-    new_token(:tQUALIFIED_MODULE_NAME, Names::Module.parse(input.matched))
   when input.scan(/::([A-Z]\w*::)*_\w+/)
     new_token(:tQUALIFIED_INTERFACE_NAME, Names::Interface.parse(input.matched))
   when input.scan(/([A-Z]\w*::)+_\w+/)
@@ -1224,6 +1229,10 @@ def next_token
     new_token(:tQUALIFIED_ALIAS_NAME, Names::Alias.parse(input.matched))
   when input.scan(/([A-Z]\w*::)+[a-z]\w*/)
     new_token(:tQUALIFIED_ALIAS_NAME, Names::Alias.parse(input.matched))
+  when input.scan(/::([A-Z]\w*::)*[A-Z]\w*/)
+    new_token(:tQUALIFIED_MODULE_NAME, Names::Module.parse(input.matched))
+  when input.scan(/([A-Z]\w*::)+[A-Z]\w*/)
+    new_token(:tQUALIFIED_MODULE_NAME, Names::Module.parse(input.matched))
   when input.scan(/[A-Z]\w*/)
     new_token(:tUIDENT, input.matched.to_sym)
   when input.scan(/_\w+/)

data/lib/steep/subtyping/check.rb

@@ -147,23 +147,17 @@ module Steep
             results.find(&:failure?)
           end
 
-        when relation.super_type.is_a?(AST::Types::Var)
-          if constraints.unknown?(relation.super_type.name)
-            constraints.add(relation.super_type.name, sub_type: relation.sub_type)
-            success(constraints: constraints)
-          else
-            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                    trace: trace)
-          end
+        when relation.super_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.super_type.name)
+          constraints.add(relation.super_type.name, sub_type: relation.sub_type)
+          success(constraints: constraints)
 
-        when relation.sub_type.is_a?(AST::Types::Var)
-          if constraints.unknown?(relation.sub_type.name)
-            constraints.add(relation.sub_type.name, super_type: relation.super_type)
-            success(constraints: constraints)
-          else
-            failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                    trace: trace)
-          end
+        when relation.sub_type.is_a?(AST::Types::Var) && constraints.unknown?(relation.sub_type.name)
+          constraints.add(relation.sub_type.name, super_type: relation.super_type)
+          success(constraints: constraints)
+
+        when relation.super_type.is_a?(AST::Types::Var) || relation.sub_type.is_a?(AST::Types::Var)
+          failure(error: Result::Failure::UnknownPairError.new(relation: relation),
+                  trace: trace)
 
         when relation.sub_type.is_a?(AST::Types::Name::Base) && relation.super_type.is_a?(AST::Types::Name::Base)
           if (pairs = extract_nominal_pairs(relation))

data/lib/steep/type_construction.rb

@@ -1129,10 +1129,19 @@ module Steep
         when :array
           yield_self do
             if node.children.empty?
-              unless hint
-                typing.add_error Errors::FallbackAny.new(node: node)
-              end
-              typing.add_typing(node, AST::Builtin::Array.instance_type(AST::Builtin.any_type))
+              typing.add_error Errors::FallbackAny.new(node: node) unless hint
+
+              array_type = if hint
+                             relation = Subtyping::Relation.new(
+                               sub_type: AST::Builtin::Array.instance_type(AST::Builtin.any_type),
+                               super_type: hint
+                             )
+                             if checker.check(relation, constraints: Subtyping::Constraints.empty).success?
+                               hint
+                             end
+                           end
+
+              typing.add_typing(node, array_type || AST::Builtin::Array.instance_type(AST::Builtin.any_type))
             else
               is_tuple = nil
 
@@ -1749,46 +1758,49 @@ module Steep
         receiver_type = unwrap(receiver_type)
       end
 
-      case receiver_type
-      when AST::Types::Any
-        typing.add_typing node, AST::Builtin.any_type
+      return_type = case receiver_type
+                    when AST::Types::Any
+                      typing.add_typing node, AST::Builtin.any_type
 
-      when nil
-        fallback_to_any node
+                    when nil
+                      fallback_to_any node
 
-      else
-        begin
-          interface = checker.resolve(receiver_type)
-
-          method = interface.methods[method_name]
-
-          if method
-            args = TypeInference::SendArgs.from_nodes(arguments)
-            return_type_or_error = type_method_call(node,
-                                                    method: method,
-                                                    args: args,
-                                                    block_params: block_params,
-                                                    block_body: block_body,
-                                                    receiver_type: receiver_type)
-
-            if return_type_or_error.is_a?(Errors::Base)
-              fallback_to_any node do
-                return_type_or_error
-              end
-            else
-              typing.add_typing node, return_type_or_error
-            end
-          else
-            fallback_to_any node do
-              Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
-            end
-          end
-        rescue Subtyping::Check::CannotResolveError
-          fallback_to_any node do
-            Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
-          end
-        end
-      end.tap do
+                    else
+                      begin
+                        interface = checker.resolve(receiver_type)
+
+                        method = interface.methods[method_name]
+
+                        if method
+                          args = TypeInference::SendArgs.from_nodes(arguments)
+                          return_type_or_error = type_method_call(node,
+                                                                  method: method,
+                                                                  args: args,
+                                                                  block_params: block_params,
+                                                                  block_body: block_body,
+                                                                  receiver_type: receiver_type)
+
+                          if return_type_or_error.is_a?(Errors::Base)
+                            fallback_to_any node do
+                              return_type_or_error
+                            end
+                          else
+                            typing.add_typing node, return_type_or_error
+                          end
+                        else
+                          fallback_to_any node do
+                            Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                          end
+                        end
+                      rescue Subtyping::Check::CannotResolveError
+                        fallback_to_any node do
+                          Errors::NoMethod.new(node: node, method: method_name, type: receiver_type)
+                        end
+                      end
+                    end
+
+      case return_type
+      when nil, Errors::Base
         arguments.each do |arg|
           unless typing.has_type?(arg)
             if arg.type == :splat
@@ -1814,6 +1826,8 @@ module Steep
             for_block.synthesize(block_body)
           end
         end
+      else
+        return_type
       end
     end
 
@@ -1932,6 +1946,8 @@ module Steep
         occurence = Subtyping::VariableOccurence.from_method_type(method_type)
 
         arg_pairs.each do |(arg_node, param_type)|
+          param_type = param_type.subst(instantiation)
+
           arg_type = if arg_node.type == :splat
                        type = construction.synthesize(arg_node.children[0])
                        child_typing.add_typing(arg_node, type)
@@ -1941,7 +1957,7 @@ module Steep
 
           relation = Subtyping::Relation.new(
             sub_type: arg_type,
-            super_type: param_type.subst(instantiation)
+            super_type: param_type
           )
 
           checker.check(relation, constraints: constraints).else do |result|
@@ -2167,123 +2183,6 @@ module Steep
       end
     end
 
-    def test_args(params:, arguments:)
-      params.each_missing_argument arguments do |_|
-        return nil
-      end
-
-      params.each_extra_argument arguments do |_|
-        return nil
-      end
-
-      params.each_missing_keyword arguments do |_|
-        return nil
-      end
-
-      params.each_extra_keyword arguments do |_|
-        return nil
-      end
-
-      self.class.argument_typing_pairs(params: params, arguments: arguments.dup)
-    end
-
-    def applicable_args?(params:, arguments:)
-      params.each_missing_argument arguments do |_|
-        return false
-      end
-
-      params.each_extra_argument arguments do |_|
-        return false
-      end
-
-      params.each_missing_keyword arguments do |_|
-        return false
-      end
-
-      params.each_extra_keyword arguments do |_|
-        return false
-      end
-
-      all_args = arguments.dup
-
-      self.class.argument_typing_pairs(params: params, arguments: arguments.dup).each do |(param_type, argument)|
-        all_args.delete_if {|a| a.equal?(argument) }
-
-        check(argument, param_type) do |_, _|
-          return false
-        end
-      end
-
-      all_args.each do |arg|
-        synthesize(arg)
-      end
-
-      true
-    end
-
-    def self.block_param_typing_pairs(param_types: , param_nodes:)
-      pairs = []
-
-      param_types.required.each.with_index do |type, index|
-        if (param = param_nodes[index])
-          pairs << [param, type]
-        end
-      end
-
-      pairs
-    end
-
-    def self.argument_typing_pairs(params:, arguments:)
-      keywords = {}
-      unless params.required_keywords.empty? && params.optional_keywords.empty? && !params.rest_keywords
-        # has keyword args
-        last_arg = arguments.last
-        if last_arg&.type == :hash
-          arguments.pop
-
-          last_arg.children.each do |elem|
-            case elem.type
-            when :pair
-              key, value = elem.children
-              if key.type == :sym
-                name = key.children[0]
-
-                keywords[name] = value
-              end
-            end
-          end
-        end
-      end
-
-      pairs = []
-
-      params.flat_unnamed_params.each do |param_type|
-        arg = arguments.shift
-        pairs << [param_type.last, arg] if arg
-      end
-
-      if params.rest
-        arguments.each do |arg|
-          pairs << [params.rest, arg]
-        end
-      end
-
-      params.flat_keywords.each do |name, type|
-        arg = keywords.delete(name)
-        if arg
-          pairs << [type, arg]
-        end
-      end
-
-      if params.rest_keywords
-        keywords.each_value do |arg|
-          pairs << [params.rest_keywords, arg]
-        end
-      end
-
-      pairs
-    end
-
     def self.parameter_types(nodes, type)
       nodes = nodes.dup
 

data/lib/steep/version.rb

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

data/stdlib/builtin.rbi

@@ -26,6 +26,10 @@ class Object < BasicObject
   def !: -> bool
   def Array: (any) -> Array<any>
   def Hash: (any) -> Hash<any, any>
+  def instance_eval: <'x> { (self) -> 'x } -> 'x
+                   | (String, ?String, ?Integer) -> any
+  def define_singleton_method: (Symbol | String, any) -> Symbol
+                             | (Symbol) { (*any) -> any } -> Symbol
 end
 
 class Module
@@ -234,6 +238,7 @@ class Hash<'key, 'value>
           | -> Enumerator<['key, 'value], self>
   def key?: ('key) -> bool
   def merge: (Hash<'key, 'value>) -> Hash<'key, 'value>
+  def delete: ('key) -> 'value?
 
   include Enumerable<['key, 'value], self>
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-22 00:00:00.000000000 Z
+date: 2018-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler