typeprof 0.5.4 → 0.9.0

data/smoke/array-replace.rb

@@ -8,5 +8,6 @@ foo([1, 2, 3])
 __END__
 # Classes
 class Object
-  def foo : ([Integer, Integer, Integer]) -> (Array[Integer | String])
+  private
+  def foo: ([Integer, Integer, Integer]) -> (Array[Integer | String])
 end

data/smoke/array-s-aref.rb

@@ -7,5 +7,6 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> (Array[Integer | String])
+  private
+  def foo: -> (Array[Integer | String])
 end

data/smoke/array1.rb

@@ -18,9 +18,10 @@ quux(a[n])
 __END__
 # Classes
 class Object
-  def foo : ([Integer, String]) -> Integer
-  def bar : (Integer) -> nil
-  def baz : (String) -> nil
-  def qux : (nil) -> nil
-  def quux : (Integer | String) -> nil
+  private
+  def foo: ([Integer, String]) -> Integer
+  def bar: (Integer) -> nil
+  def baz: (String) -> nil
+  def qux: (nil) -> nil
+  def quux: (Integer | String) -> nil
 end

data/smoke/array10.rb

@@ -10,5 +10,6 @@ foo([:a, :b, :c])
 __END__
 # Classes
 class Object
-  def foo : ([:a, :b, :c]) -> :a
+  private
+  def foo: ([:a, :b, :c]) -> :a
 end

data/smoke/array11.rb

@@ -9,5 +9,6 @@ array("foo")
 __END__
 # Classes
 class Object
-  def array : (Array[Integer] | Hash[Integer, Integer] | String) -> (Array[Hash[Integer, Integer] | Integer | String])
+  private
+  def array: (Array[Integer] | Hash[Integer, Integer] | String) -> (Array[Hash[Integer, Integer] | Integer | String])
 end

data/smoke/array12.rb

@@ -18,7 +18,8 @@ foo
 __END__
 # Classes
 class Object
-  def bar : ([Integer]) -> nil
-  def test_yield : { -> nil } -> nil
-  def foo : -> [Integer]
+  private
+  def bar: ([Integer]) -> nil
+  def test_yield: { -> nil } -> nil
+  def foo: -> [Integer]
 end

data/smoke/array13.rb

@@ -23,8 +23,9 @@ end
 __END__
 # Classes
 class Object
-  def tuple_set : -> [:a, :b, :z]
-  def tuple_get : -> :c
-  def seq_set : -> (Array[:a | :b | :c | :z])
-  def seq_get : -> (:a | :b | :c)
+  private
+  def tuple_set: -> [:a, :b, :z]
+  def tuple_get: -> :c
+  def seq_set: -> (Array[:a | :b | :c | :z])
+  def seq_get: -> (:a | :b | :c)
 end

data/smoke/array14.rb

@@ -9,5 +9,6 @@ f(:a, :b, :c)
 __END__
 # Classes
 class Object
-  def f : (:a, :b, :c) -> :c
+  private
+  def f: (:a, :b, :c) -> :c
 end

data/smoke/array15.rb

@@ -0,0 +1,16 @@
+class Foo
+  def []=(*args)
+    ary = []
+    val = args[-1]
+    ary[*args[0..-2]] = val # TODO: there is room to improve array_aset
+    ary                     # This should be Array[String]
+  end
+end
+
+Foo.new[1] = "str"
+
+__END__
+# Classes
+class Foo
+  def []=: (*Integer | String) -> Array[bot]
+end

data/smoke/array2.rb

@@ -21,7 +21,8 @@ log(a)
 __END__
 # Classes
 class Object
-  def foo : -> [[String]]
-  def bar : ([[Integer]]) -> [[String]]
-  def log : ([[Integer]]) -> nil
+  private
+  def foo: -> [[String]]
+  def bar: ([[Integer]]) -> [[String]]
+  def log: ([[Integer]]) -> nil
 end

data/smoke/array3.rb

@@ -18,8 +18,8 @@ Foo.new.bar
 __END__
 # Classes
 class Foo
-  @ary : [Integer, String?, :sym]
-  def initialize : -> [Integer, String, :sym]
-  def foo : -> String?
-  def bar : -> nil
+  @ary: [Integer, String?, :sym]
+  def initialize: -> [Integer, String, :sym]
+  def foo: -> String?
+  def bar: -> nil
 end

data/smoke/array4.rb

@@ -10,5 +10,6 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> [Integer]?
+  private
+  def foo: -> [Integer]?
 end

data/smoke/array5.rb

@@ -9,5 +9,6 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> [untyped]
+  private
+  def foo: -> [untyped]
 end

data/smoke/array6.rb

@@ -10,6 +10,7 @@ foo(1, "str")
 __END__
 # Classes
 class Object
-  ARY : Array[bot]
-  def foo : (Integer, String) -> Array[bot]
+  ARY: Array[bot]
+  private
+  def foo: (Integer, String) -> Array[bot]
 end

data/smoke/array7.rb

@@ -9,5 +9,6 @@ foo
 __END__
 # Classes
 class Object
-  def foo : -> (Array[Integer | String])
+  private
+  def foo: -> (Array[Integer | String])
 end

data/smoke/array8.rb

@@ -9,5 +9,5 @@ end
 __END__
 # Classes
 class Foo
-  def self.foo : (Array[bot]) -> Array[bot]
+  def self.foo: (Array[bot]) -> Array[bot]
 end

data/smoke/array9.rb

@@ -8,5 +8,6 @@ foo([:a])
 __END__
 # Classes
 class Object
-  def foo : (Array[:a | :b | :c]) -> nil
+  private
+  def foo: (Array[:a | :b | :c]) -> nil
 end

data/smoke/attr-module.rb

@@ -0,0 +1,26 @@
+module Foo
+  attr_accessor :foo
+  module_function :foo=, :foo
+end
+
+class Bar
+  include Foo
+end
+
+Foo.foo = 42
+Bar.new.foo = "str"
+
+# XXX: the output may be improved
+
+__END__
+# Classes
+module Foo
+  self.@foo: Integer
+  attr_accessor foo: untyped
+  attr_accessor self.foo: Integer
+end
+
+class Bar
+  include Foo
+  @foo: String
+end

data/smoke/attr.rb

@@ -20,9 +20,9 @@ foo.c = :ccc
 __END__
 # Classes
 class Foo
-  attr_reader a : :aaa
-  attr_writer b : :bbb
-  attr_accessor c : :ccc
-  def initialize : (:aaa) -> :aaa
-  def get_b : -> :bbb
+  attr_reader a: :aaa
+  attr_writer b: :bbb
+  attr_accessor c: :ccc
+  def initialize: (:aaa) -> :aaa
+  def get_b: -> :bbb
 end

data/smoke/autoload.rb

@@ -0,0 +1,14 @@
+autoload(:Pathname, "pathname")
+
+def foo
+  Pathname.new("foo")
+end
+
+foo
+
+__END__
+# Classes
+class Object
+  private
+  def foo: -> Pathname
+end

data/smoke/backtrace.rb

@@ -26,7 +26,8 @@ smoke/backtrace.rb:2: [error] undefined method: Object#unknown_method
 
 # Classes
 class Object
-  def foo : -> untyped
-  def bar : -> untyped
-  def baz : -> untyped
+  private
+  def foo: -> untyped
+  def bar: -> untyped
+  def baz: -> untyped
 end

data/smoke/block-ambiguous.rb

@@ -25,12 +25,13 @@ f4 {|x,| log4(x) }
 __END__
 # Classes
 class Object
-  def f1 : { (:a, :b, :c) -> nil } -> nil
-  def log1 : (:a) -> nil
-  def f2 : { (:a, :b, :c) -> nil } -> nil
-  def log2 : (:a) -> nil
-  def f3 : { ([:a, :b, :c]) -> nil } -> nil
-  def log3 : ([:a, :b, :c]) -> nil
-  def f4 : { ([:a, :b, :c]) -> nil } -> nil
-  def log4 : (:a) -> nil
+  private
+  def f1: { (:a, :b, :c) -> nil } -> nil
+  def log1: (:a) -> nil
+  def f2: { (:a, :b, :c) -> nil } -> nil
+  def log2: (:a) -> nil
+  def f3: { ([:a, :b, :c]) -> nil } -> nil
+  def log3: ([:a, :b, :c]) -> nil
+  def f4: { ([:a, :b, :c]) -> nil } -> nil
+  def log4: (:a) -> nil
 end

data/smoke/block-args1-rest.rb

@@ -48,15 +48,16 @@ end
 __END__
 # Classes
 class Object
-  StringArray : Array[String]
-  def f1 : { (*String) -> nil } -> (^(String, ?:opt | String, String) -> nil)
-  def log1 : (String, :opt | String, String) -> nil
-  def f2 : { (:a, *String) -> nil } -> (^(:a, ?:opt | String, String) -> nil)
-  def log2 : (:a, :opt | String, String) -> nil
-  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, :b | String) -> nil)
-  def log3 : (:a, :b | :opt, :b | String) -> nil
-  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
-  def log4 : (:a, :b | :opt, :b | :c) -> nil
-  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
-  def log5 : (:a, :b | :opt, :b | :c) -> nil
+  StringArray: Array[String]
+  private
+  def f1: { (*String) -> nil } -> (^(String, ?:opt | String, String) -> nil)
+  def log1: (String, :opt | String, String) -> nil
+  def f2: { (:a, *String) -> nil } -> (^(:a, ?:opt | String, String) -> nil)
+  def log2: (:a, :opt | String, String) -> nil
+  def f3: { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, :b | String) -> nil)
+  def log3: (:a, :b | :opt, :b | String) -> nil
+  def f4: { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
+  def log4: (:a, :b | :opt, :b | :c) -> nil
+  def f5: { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, :b | :c) -> nil)
+  def log5: (:a, :b | :opt, :b | :c) -> nil
 end

data/smoke/block-args1.rb

@@ -46,14 +46,15 @@ end
 __END__
 # Classes
 class Object
-  def f1 : { -> nil } -> ^(nil, ?:opt, nil) -> nil
-  def log1 : (nil, :opt, nil) -> nil
-  def f2 : { (:a) -> nil } -> ^(:a, ?:opt, nil) -> nil
-  def log2 : (:a, :opt, nil) -> nil
-  def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, :b) -> nil
-  def log3 : (:a, :opt, :b) -> nil
-  def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
-  def log4 : (:a, :b | :opt, :c) -> nil
-  def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
-  def log5 : (:a, :b | :opt, :c) -> nil
+  private
+  def f1: { -> nil } -> ^(nil, ?:opt, nil) -> nil
+  def log1: (nil, :opt, nil) -> nil
+  def f2: { (:a) -> nil } -> ^(:a, ?:opt, nil) -> nil
+  def log2: (:a, :opt, nil) -> nil
+  def f3: { (:a, :b) -> nil } -> ^(:a, ?:opt, :b) -> nil
+  def log3: (:a, :opt, :b) -> nil
+  def f4: { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
+  def log4: (:a, :b | :opt, :c) -> nil
+  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, :c) -> nil)
+  def log5: (:a, :b | :opt, :c) -> nil
 end

data/smoke/block-args2-rest.rb

@@ -48,15 +48,16 @@ end
 __END__
 # Classes
 class Object
-  StringArray : Array[String]
-  def f1 : { (*String) -> nil } -> ^(String, *String, String) -> nil
-  def log1 : (String, Array[String], String) -> nil
-  def f2 : { (:a, *String) -> nil } -> ^(:a, *String, String) -> nil
-  def log2 : (:a, Array[String], String) -> nil
-  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, *:b | String, :b | String) -> nil)
-  def log3 : (:a, Array[:b | String], :b | String) -> nil
-  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, *:b | :c | String, :c | String) -> nil)
-  def log4 : (:a, Array[:b | :c | String], :c | String) -> nil
-  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, *:b | :c | :d | String, :d | String) -> nil)
-  def log5 : (:a, Array[:b | :c | :d | String], :d | String) -> nil
+  StringArray: Array[String]
+  private
+  def f1: { (*String) -> nil } -> ^(String, *String, String) -> nil
+  def log1: (String, Array[String], String) -> nil
+  def f2: { (:a, *String) -> nil } -> ^(:a, *String, String) -> nil
+  def log2: (:a, Array[String], String) -> nil
+  def f3: { (:a, :b, *String) -> nil } -> (^(:a, *:b | String, :b | String) -> nil)
+  def log3: (:a, Array[:b | String], :b | String) -> nil
+  def f4: { (:a, :b, :c, *String) -> nil } -> (^(:a, *:b | :c | String, :c | String) -> nil)
+  def log4: (:a, Array[:b | :c | String], :c | String) -> nil
+  def f5: { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, *:b | :c | :d | String, :d | String) -> nil)
+  def log5: (:a, Array[:b | :c | :d | String], :d | String) -> nil
 end

data/smoke/block-args2.rb

@@ -46,14 +46,15 @@ end
 __END__
 # Classes
 class Object
-  def f1 : { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1 : (nil, Array[bot], nil) -> nil
-  def f2 : { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2 : (:a, Array[bot], nil) -> nil
-  def f3 : { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
-  def log3 : (:a, Array[bot], :b) -> nil
-  def f4 : { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
-  def log4 : (:a, [:b], :c) -> nil
-  def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)
-  def log5 : (:a, [:b, :c], :d) -> nil
+  private
+  def f1: { -> nil } -> ^(nil, *bot, nil) -> nil
+  def log1: (nil, Array[bot], nil) -> nil
+  def f2: { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
+  def log2: (:a, Array[bot], nil) -> nil
+  def f3: { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
+  def log3: (:a, Array[bot], :b) -> nil
+  def f4: { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
+  def log4: (:a, [:b], :c) -> nil
+  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)
+  def log5: (:a, [:b, :c], :d) -> nil
 end

data/smoke/block-args3-rest.rb

@@ -57,17 +57,18 @@ end
 __END__
 # Classes
 class Object
-  StringArray : Array[String]
-  def f1 : { (*String) -> nil } -> (^(String, ?:opt | String, *String, String) -> nil)
-  def log1 : (String, :opt | String, Array[String], String) -> nil
-  def f2 : { (:a, *String) -> nil } -> (^(:a, ?:opt | String, *String, String) -> nil)
-  def log2 : (:a, :opt | String, Array[String], String) -> nil
-  def f3 : { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, *String, :b | String) -> nil)
-  def log3 : (:a, :b | :opt, Array[String], :b | String) -> nil
-  def f4 : { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | String, :c | String) -> nil)
-  def log4 : (:a, :b | :opt, Array[:c | String], :c | String) -> nil
-  def f5 : { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | String, :d | String) -> nil)
-  def log5 : (:a, :b | :opt, Array[:c | :d | String], :d | String) -> nil
-  def f6 : { (:a, :b, :c, :d, :e, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | :e | String, :e | String) -> nil)
-  def log6 : (:a, :b | :opt, Array[:c | :d | :e | String], :e | String) -> nil
+  StringArray: Array[String]
+  private
+  def f1: { (*String) -> nil } -> (^(String, ?:opt | String, *String, String) -> nil)
+  def log1: (String, :opt | String, Array[String], String) -> nil
+  def f2: { (:a, *String) -> nil } -> (^(:a, ?:opt | String, *String, String) -> nil)
+  def log2: (:a, :opt | String, Array[String], String) -> nil
+  def f3: { (:a, :b, *String) -> nil } -> (^(:a, ?:b | :opt, *String, :b | String) -> nil)
+  def log3: (:a, :b | :opt, Array[String], :b | String) -> nil
+  def f4: { (:a, :b, :c, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | String, :c | String) -> nil)
+  def log4: (:a, :b | :opt, Array[:c | String], :c | String) -> nil
+  def f5: { (:a, :b, :c, :d, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | String, :d | String) -> nil)
+  def log5: (:a, :b | :opt, Array[:c | :d | String], :d | String) -> nil
+  def f6: { (:a, :b, :c, :d, :e, *String) -> nil } -> (^(:a, ?:b | :opt, *:c | :d | :e | String, :e | String) -> nil)
+  def log6: (:a, :b | :opt, Array[:c | :d | :e | String], :e | String) -> nil
 end

data/smoke/block-args3.rb

@@ -55,16 +55,17 @@ end
 __END__
 # Classes
 class Object
-  def f1 : { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1 : (nil, :opt, Array[bot], nil) -> nil
-  def f2 : { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
-  def log2 : (:a, :opt, Array[bot], nil) -> nil
-  def f3 : { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
-  def log3 : (:a, :opt, Array[bot], :b) -> nil
-  def f4 : { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
-  def log4 : (:a, :b | :opt, Array[bot], :c) -> nil
-  def f5 : { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
-  def log5 : (:a, :b | :opt, [:c], :d) -> nil
-  def f6 : { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)
-  def log6 : (:a, :b | :opt, [:c, :d], :e) -> nil
+  private
+  def f1: { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
+  def log1: (nil, :opt, Array[bot], nil) -> nil
+  def f2: { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
+  def log2: (:a, :opt, Array[bot], nil) -> nil
+  def f3: { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
+  def log3: (:a, :opt, Array[bot], :b) -> nil
+  def f4: { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
+  def log4: (:a, :b | :opt, Array[bot], :c) -> nil
+  def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
+  def log5: (:a, :b | :opt, [:c], :d) -> nil
+  def f6: { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)
+  def log6: (:a, :b | :opt, [:c, :d], :e) -> nil
 end