steep 0.4.0 → 0.5.0

data/lib/steep/type_inference/block_params.rb

@@ -15,7 +15,7 @@ module Steep
         end
 
         def ==(other)
-          other.is_a?(Param) && other.var == var && other.type == type && other.value == value && other.node == node
+          other.is_a?(self.class) && other.var == var && other.type == type && other.value == value && other.node == node
         end
 
         alias eql? ==
@@ -25,72 +25,223 @@ module Steep
         end
       end
 
-      attr_reader :params
-      attr_reader :rest
+      attr_reader :leading_params
+      attr_reader :optional_params
+      attr_reader :rest_param
+      attr_reader :trailing_params
 
-      def initialize(params:, rest:)
-        @params = params
-        @rest = rest
+      def initialize(leading_params:, optional_params:, rest_param:, trailing_params:)
+        @leading_params = leading_params
+        @optional_params = optional_params
+        @rest_param = rest_param
+        @trailing_params = trailing_params
+      end
+
+      def params
+        [].tap do |params|
+          params.push *leading_params
+          params.push *optional_params
+          params.push rest_param if rest_param
+          params.push *trailing_params
+        end
       end
 
       def self.from_node(node, annotations:)
-        params = []
-        rest = nil
+        leading_params = []
+        optional_params = []
+        rest_param = nil
+        trailing_params = []
+
+        default_params = leading_params
 
         node.children.each do |arg|
           var = arg.children.first
-          type = annotations.lookup_var_type(var.name)
+          type = annotations.var_type(lvar: var.name)
 
           case arg.type
           when :arg, :procarg0
-            params << Param.new(var: var, type: type, value: nil, node: arg)
+            default_params << Param.new(var: var, type: type, value: nil, node: arg)
           when :optarg
-            params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
+            default_params = trailing_params
+            optional_params << Param.new(var: var, type: type, value: arg.children.last, node: arg)
           when :restarg
-            rest = Param.new(var: var, type: type, value: nil, node: arg)
+            default_params = trailing_params
+            rest_param = Param.new(var: var, type: type, value: nil, node: arg)
           end
         end
 
         new(
-          params: params,
-          rest: rest
+          leading_params: leading_params,
+          optional_params: optional_params,
+          rest_param: rest_param,
+          trailing_params: trailing_params
+        )
+      end
+
+      def params_type(hint: nil)
+        params_type0(hint: hint) or params_type0(hint: nil)
+      end
+
+      def params_type0(hint:)
+        if hint
+          case
+          when leading_params.size == hint.required.size
+            leadings = leading_params.map.with_index do |param, index|
+              param.type || hint.required[index]
+            end
+          when !hint.rest && hint.optional.empty? && leading_params.size > hint.required.size
+            leadings = leading_params.take(hint.required.size).map.with_index do |param, index|
+              param.type || hint.required[index]
+            end
+          when !hint.rest && hint.optional.empty? && leading_params.size < hint.required.size
+            leadings = leading_params.map.with_index do |param, index|
+              param.type || hint.required[index]
+            end + hint.required.drop(leading_params.size)
+          else
+            return nil
+          end
+
+          case
+          when optional_params.size == hint.optional.size
+            optionals = optional_params.map.with_index do |param, index|
+              param.type || hint.optional[index]
+            end
+          when !hint.rest && optional_params.size > hint.optional.size
+            optionals = optional_params.take(hint.optional.size).map.with_index do |param, index|
+              param.type || hint.optional[index]
+            end
+          when !hint.rest && optional_params.size < hint.optional.size
+            optionals = optional_params.map.with_index do |param, index|
+              param.type || hint.optional[index]
+            end + hint.optional.drop(optional_params.size)
+          else
+            return nil
+          end
+
+          if rest_param && hint.rest
+            rest = rest_param.type&.yield_self {|ty| ty.args&.first } || hint.rest
+          else
+            rest = hint.rest
+          end
+        else
+          leadings = leading_params.map {|param| param.type || AST::Types::Any.new }
+          optionals = optional_params.map {|param| param.type || AST::Types::Any.new }
+          rest = rest_param&.yield_self {|param| param.type.args[0] }
+        end
+
+        Interface::Params.new(
+          required: leadings,
+          optional: optionals,
+          rest: rest,
+          required_keywords: {},
+          optional_keywords: {},
+          rest_keywords: nil
         )
       end
 
       def zip(params_type)
+        if trailing_params.any?
+          Steep.logger.error "Block definition with trailing required parameters are not supported yet"
+        end
+
         [].tap do |zip|
-          types = params_type.flat_unnamed_params
-          params.each do |param|
-            type = types.shift&.last || params_type.rest || AST::Types::Any.new
+          if expandable_params?(params_type) && expandable?
+            type = params_type.required[0]
+
+            case
+            when array?(type)
+              type_arg = type.args[0]
+              params.each do |param|
+                unless param == rest_param
+                  zip << [param, AST::Types::Union.build(types: [type_arg, AST::Types::Nil.new])]
+                else
+                  zip << [param, AST::Types::Name.new_instance(name: "::Array", args: [type_arg])]
+                end
+              end
+            when type.is_a?(AST::Types::Tuple)
+              types = type.types.dup
+              (leading_params + optional_params).each do |param|
+                ty = types.shift
+                if ty
+                  zip << [param, ty]
+                else
+                  zip << [param, AST::Types::Nil.new]
+                end
+              end
 
-            if type
-              zip << [param, type]
+              if rest_param
+                if types.any?
+                  union = AST::Types::Union.build(types: types)
+                  zip << [rest_param, AST::Types::Name.new_instance(name: "::Array", args: [union])]
+                else
+                  zip << [rest_param, AST::Types::Nil.new]
+                end
+              end
+            end
+          else
+            types = params_type.flat_unnamed_params
+
+            (leading_params + optional_params).each do |param|
+              type = types.shift&.last || params_type.rest
+
+              if type
+                zip << [param, type]
+              else
+                zip << [param, AST::Types::Nil.new]
+              end
             end
-          end
 
-          if rest
-            if types.empty?
-              array = AST::Types::Name.new_instance(
-                name: :Array,
-                args: [params_type.rest || AST::Types::Any.new]
-              )
-              zip << [rest, array]
-            else
-              union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
-              array = AST::Types::Name.new_instance(
-                name: :Array,
-                args: [union]
-              )
-              zip << [rest, array]
+            if rest_param
+              if types.empty?
+                array = AST::Types::Name.new_instance(
+                  name: "::Array",
+                  args: [params_type.rest || AST::Types::Any.new]
+                )
+                zip << [rest_param, array]
+              else
+                union = AST::Types::Union.build(types: types.map(&:last) + [params_type.rest])
+                array = AST::Types::Name.new_instance(
+                  name: "::Array",
+                  args: [union]
+                )
+                zip << [rest_param, array]
+              end
             end
           end
         end
       end
 
+      def array?(type)
+        type.is_a?(AST::Types::Name) &&
+          type.name.is_a?(TypeName::Instance) &&
+          type.name.name.name == "Array" && type.name.name.absolute?
+      end
+
+      def expandable_params?(params_type)
+        if params_type.flat_unnamed_params.size == 1
+          case (type = params_type.required.first)
+          when AST::Types::Tuple
+            true
+          when AST::Types::Name
+            array?(type)
+          end
+        end
+      end
+
+      def expandable?
+        case
+        when leading_params.size + trailing_params.size > 1
+          true
+        when (leading_params.any? || trailing_params.any?) && rest_param
+          true
+        when params.size == 1 && params[0].node.type == :arg
+          true
+        end
+      end
+
       def each(&block)
         if block_given?
           params.each &block
-          yield rest if rest
         else
           enum_for :each
         end

data/lib/steep/type_inference/send_args.rb

@@ -3,15 +3,24 @@ module Steep
     class SendArgs
       attr_reader :args
       attr_reader :kw_args
+      attr_reader :block_pass_arg
 
-      def initialize(args:, kw_args:)
+      def initialize(args:, kw_args:, block_pass_arg:)
         @args = args
         @kw_args = kw_args
+        @block_pass_arg = block_pass_arg
       end
 
       def self.from_nodes(nodes)
+        nodes = nodes.dup
+
         args = []
         last_hash = nil
+        block_pass_arg = nil
+
+        if nodes.last&.type == :block_pass
+          block_pass_arg = nodes.pop
+        end
 
         nodes.each do |node|
           if last_hash
@@ -34,7 +43,7 @@ module Steep
           end
         end
 
-        new(args: args, kw_args: last_hash)
+        new(args: args, kw_args: last_hash, block_pass_arg: block_pass_arg)
       end
 
       def self.kw_args?(node)
@@ -72,7 +81,7 @@ module Steep
         end
       end
 
-      def zip(params)
+      def zip(params, block)
         Set.new(
           [].tap do |pairs|
             consumed_keywords = Set.new

data/lib/steep/type_inference/type_env.rb

@@ -28,14 +28,14 @@ module Steep
 
       def self.build(annotations:, signatures:, subtyping:, const_env:)
         new(subtyping: subtyping, const_env: const_env).tap do |env|
-          annotations.var_types.each do |name, annot|
-            env.set(lvar: name, type: subtyping.builder.absolute_type(annot.type, current: const_env.current_namespace))
+          annotations.lvar_types.each do |name, type|
+            env.set(lvar: name, type: type)
           end
           annotations.ivar_types.each do |name, type|
-            env.set(ivar: name, type: subtyping.builder.absolute_type(type, current: const_env.current_namespace))
+            env.set(ivar: name, type: type)
           end
           annotations.const_types.each do |name, type|
-            env.set(const: name, type: subtyping.builder.absolute_type(type, current: const_env.current_namespace))
+            env.set(const: name, type: type)
           end
           signatures.globals.each do |name, annot|
             type = subtyping.builder.absolute_type(annot.type, current: nil)
@@ -195,6 +195,9 @@ module Steep
       end
 
       def assert_assign(var_type:, lhs_type:)
+        var_type = subtyping.expand_alias(var_type)
+        lhs_type = subtyping.expand_alias(lhs_type)
+
         relation = Subtyping::Relation.new(sub_type: lhs_type, super_type: var_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 
@@ -212,6 +215,9 @@ module Steep
       end
 
       def assert_annotation(name, annotated_type:, original_type:)
+        annotated_type = subtyping.expand_alias(annotated_type)
+        original_type = subtyping.expand_alias(original_type)
+
         relation = Subtyping::Relation.new(sub_type: annotated_type, super_type: original_type)
         constraints = Subtyping::Constraints.new(unknowns: Set.new)
 

data/lib/steep/type_name.rb

@@ -83,5 +83,11 @@ module Steep
     end
 
     class Instance < Base; end
+
+    class Alias < Base
+      def map_module_name
+        self
+      end
+    end
   end
 end

data/lib/steep/typing.rb

@@ -5,9 +5,15 @@ module Steep
     attr_reader :nodes
     attr_reader :var_typing
     attr_reader :parent
+    attr_reader :parent_last_update
+    attr_reader :last_update
+    attr_reader :should_update
 
-    def initialize(parent: nil)
+    def initialize(parent: nil, parent_last_update: parent&.last_update)
       @parent = parent
+      @parent_last_update = parent_last_update
+      @last_update = parent&.last_update || 0
+      @should_update = false
 
       @errors = []
       @nodes = {}
@@ -23,6 +29,11 @@ module Steep
       typing[node.__id__] = type
       nodes[node.__id__] = node
 
+      if should_update
+        @last_update += 1
+        @should_update = false
+      end
+
       type
     end
 
@@ -65,7 +76,14 @@ module Steep
     end
 
     def new_child
-      yield self.class.new(parent: self)
+      child = self.class.new(parent: self)
+      @should_update = true
+
+      if block_given?
+        yield child
+      else
+        child
+      end
     end
 
     def each_typing
@@ -76,6 +94,7 @@ module Steep
 
     def save!
       raise "Unexpected save!" unless parent
+      raise "Parent modified since new_child" unless parent.last_update == parent_last_update
 
       each_typing do |node, type|
         parent.add_typing(node, type)

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/steep.rb

@@ -25,6 +25,7 @@ require "steep/ast/types/nil"
 require "steep/ast/types/literal"
 require "steep/ast/types/boolean"
 require "steep/ast/types/tuple"
+require "steep/ast/types/proc"
 require "steep/ast/method_type"
 require "steep/ast/type_params"
 require "steep/ast/signature/class"
@@ -35,6 +36,7 @@ require "steep/ast/signature/interface"
 require "steep/ast/signature/env"
 require "steep/ast/signature/const"
 require "steep/ast/signature/gvar"
+require "steep/ast/signature/alias"
 require "steep/ast/annotation"
 require "steep/ast/annotation/collection"
 require "steep/ast/buffer"

data/smoke/alias/a.rb

@@ -0,0 +1,19 @@
+# @type var x: foo
+x = ""
+
+# !expects NoMethodError: type=foo, method=+
+x + 123
+
+# @type var y: bar<Integer>
+y = x
+y = []
+
+# @type var z: Symbol
+case x
+when String
+  # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::String
+  z = x
+when Integer
+  # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::Integer
+  z = x
+end

data/smoke/alias/a.rbi

@@ -0,0 +1,10 @@
+type foo = String | Integer
+type bar<'a> = Array<'a> | foo
+type baz = [String, Symbol]
+
+type name = :foo | :bar
+
+class AliasMethodArg
+  def foo: (name) -> Integer
+         | (Symbol) -> String
+end

data/smoke/alias/b.rb

@@ -0,0 +1,7 @@
+# @type var a: baz
+
+a = ["", :foo]
+
+# @type var x: Integer
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=String
+x = a[0]

data/smoke/alias/c.rb

@@ -0,0 +1,10 @@
+# @type var x: String
+
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
+x = AliasMethodArg.new.foo(:foo)
+
+# @type var name: name
+name = :bar
+
+# !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
+x = AliasMethodArg.new.foo(name)

data/smoke/array/c.rb

@@ -0,0 +1,7 @@
+# @type var x: Array<String?>
+
+x = ["foo"]
+x = [nil]
+
+# !expects IncompatibleAssignment: lhs_type=::Array<(::String | nil)>, rhs_type=::Array<::Integer>
+x = [1]

data/smoke/block/c.rb

@@ -0,0 +1,10 @@
+class OptionalBlock
+  def optional_block
+    yield
+    30
+  end
+end
+
+OptionalBlock.new.optional_block()
+OptionalBlock.new.optional_block() { :foo }
+

data/smoke/block/c.rbi

@@ -0,0 +1,3 @@
+class OptionalBlock
+  def optional_block: ?{ () -> void } -> Integer
+end

data/smoke/block/d.rb

@@ -0,0 +1,15 @@
+# @type var a: ^(Integer) -> String
+a = -> (x) { x.to_s }
+
+# @type var b: Array<Float>
+
+# !expects IncompatibleAssignment: lhs_type=::Array<::Float>, rhs_type=::Array<::String>
+b = [1,2,3].map(&a)
+
+# !expects IncompatibleAssignment: lhs_type=::Array<::Float>, rhs_type=::Array<::String>
+b = [1,2,3].map(&:to_s)
+
+# !expects* BlockTypeMismatch:
+[1,2,3].map(&:no_such_method)
+# !expects* BlockTypeMismatch:
+[1,2,3].map(&:floor)

data/smoke/class/c.rb

@@ -1,4 +1,4 @@
-# !expects UnexpectedDynamicMethod: module=B, method=type
+# !expects UnexpectedDynamicMethod: module=::B, method=type
 class B
   # @implements B
 

data/smoke/class/e.rb

@@ -6,7 +6,7 @@ class C
   end
 
   def bar
-    # !expects NoMethodError: type=C.class noconstructor, method=new
+    # !expects NoMethodError: type=::C.class noconstructor, method=new
     self.class.new
   end
 end

data/smoke/class/h.rb

@@ -0,0 +1,15 @@
+class WithSingletonConstructor
+  # @dynamic foo
+  attr_reader :foo
+
+  def initialize(foo:)
+    @foo = foo
+  end
+
+  def self.create()
+    new(foo: "hoge")
+  end
+
+  new(foo: "hoge")
+  create()
+end

data/smoke/class/h.rbi

@@ -0,0 +1,7 @@
+class WithSingletonConstructor
+  attr_reader foo: String
+
+  def initialize: (foo: String) -> any
+  def self.create: -> instance
+end
+

data/smoke/class/i.rb

@@ -0,0 +1,17 @@
+class IncompatibleChild
+  def foo(arg)
+    # @type var x: Symbol
+    # !expects IncompatibleAssignment: lhs_type=::Symbol, rhs_type=::Integer
+    x = super()
+
+    "123"
+  end
+
+  def initialize()
+    # !expects IncompatibleArguments: receiver=::IncompatibleChild, method_type=(name: ::String) -> any
+    super()
+
+    # !expects IncompatibleZuper: method=initialize
+    super
+  end
+end

data/smoke/class/i.rbi

@@ -0,0 +1,9 @@
+class IncompatibleSuper
+  def foo: () -> Integer
+  def initialize: (name: String) -> any
+end
+
+class IncompatibleChild <: IncompatibleSuper
+  def initialize: () -> any
+  def (incompatible) foo: (Object) -> String
+end

data/smoke/extension/a.rbi

@@ -3,6 +3,10 @@ extension Object (X)
   def f: -> Object
 end
 
+extension Kernel (X)
+  def self.new_module_method: () -> void
+end
+
 class Foo
   def f: -> String
 end

data/smoke/extension/d.rb

@@ -0,0 +1,2 @@
+Foo.new_module_method()
+Object.new_module_method()

data/smoke/hash/a.rb

@@ -0,0 +1,17 @@
+{ foo: "bar" }.each do |x, y|
+  # @type var x1: Symbol
+  # @type var y1: String
+
+  x1 = x
+  y1 = y
+end
+
+{ foo: "bar" }.each.with_index do |x, y|
+  # @type var a: Symbol
+  # @type var b: String
+  # @type var c: Integer
+
+  a = x[0]
+  b = x[1]
+  c = y
+end

data/smoke/hash/b.rb

@@ -0,0 +1,7 @@
+# @type var x: Hash<Symbol, String?>
+
+x = { foo: "foo" }
+x = { foo: nil }
+
+# !expects IncompatibleAssignment: lhs_type=::Hash<::Symbol, (::String | nil)>, rhs_type=::Hash<::Symbol, ::Integer>
+x = { foo: 3 }

data/smoke/implements/a.rb

@@ -1,5 +1,5 @@
-# !expects@+2 MethodDefinitionMissing: module=A, method=baz
-# !expects MethodDefinitionMissing: module=A, method=self.bar
+# !expects@+2 MethodDefinitionMissing: module=::A, method=baz
+# !expects MethodDefinitionMissing: module=::A, method=self.bar
 class A
   # @implements A
 

data/smoke/initialize/a.rb

@@ -6,7 +6,7 @@ class A
   end
 
   def foo()
-    # !expects NoMethodError: type=A, method=initialize
+    # !expects NoMethodError: type=::A, method=initialize
     initialize()
   end
 end

data/smoke/lambda/a.rb

@@ -0,0 +1,11 @@
+# @type var a: Integer
+
+# !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
+a = -> (x, y) do
+  # @type var x: String
+  # @type var y: String
+  x + y
+end["foo", "bar"]
+
+# !expects NoMethodError: type=::Object, method=lambda
+b = lambda {|x| x + 1 }