steep 0.1.0.pre2 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (119) hide show
  1. checksums.yaml +5 -5
  2. data/.travis.yml +1 -1
  3. data/README.md +146 -33
  4. data/bin/smoke_runner.rb +43 -10
  5. data/lib/steep/ast/annotation/collection.rb +93 -0
  6. data/lib/steep/ast/annotation.rb +131 -0
  7. data/lib/steep/ast/buffer.rb +47 -0
  8. data/lib/steep/ast/location.rb +82 -0
  9. data/lib/steep/ast/method_type.rb +116 -0
  10. data/lib/steep/ast/signature/class.rb +33 -0
  11. data/lib/steep/ast/signature/const.rb +17 -0
  12. data/lib/steep/ast/signature/env.rb +123 -0
  13. data/lib/steep/ast/signature/extension.rb +21 -0
  14. data/lib/steep/ast/signature/gvar.rb +17 -0
  15. data/lib/steep/ast/signature/interface.rb +31 -0
  16. data/lib/steep/ast/signature/members.rb +71 -0
  17. data/lib/steep/ast/signature/module.rb +21 -0
  18. data/lib/steep/ast/type_params.rb +13 -0
  19. data/lib/steep/ast/types/any.rb +39 -0
  20. data/lib/steep/ast/types/bot.rb +39 -0
  21. data/lib/steep/ast/types/class.rb +35 -0
  22. data/lib/steep/ast/types/helper.rb +21 -0
  23. data/lib/steep/ast/types/instance.rb +39 -0
  24. data/lib/steep/ast/types/intersection.rb +74 -0
  25. data/lib/steep/ast/types/name.rb +124 -0
  26. data/lib/steep/ast/types/self.rb +39 -0
  27. data/lib/steep/ast/types/top.rb +39 -0
  28. data/lib/steep/ast/types/union.rb +74 -0
  29. data/lib/steep/ast/types/var.rb +57 -0
  30. data/lib/steep/ast/types/void.rb +35 -0
  31. data/lib/steep/cli.rb +28 -1
  32. data/lib/steep/drivers/annotations.rb +32 -0
  33. data/lib/steep/drivers/check.rb +53 -77
  34. data/lib/steep/drivers/scaffold.rb +303 -0
  35. data/lib/steep/drivers/utils/each_signature.rb +66 -0
  36. data/lib/steep/drivers/utils/validator.rb +115 -0
  37. data/lib/steep/drivers/validate.rb +39 -0
  38. data/lib/steep/errors.rb +291 -19
  39. data/lib/steep/interface/abstract.rb +44 -0
  40. data/lib/steep/interface/builder.rb +470 -0
  41. data/lib/steep/interface/instantiated.rb +126 -0
  42. data/lib/steep/interface/ivar_chain.rb +26 -0
  43. data/lib/steep/interface/method.rb +60 -0
  44. data/lib/steep/{interface.rb → interface/method_type.rb} +111 -100
  45. data/lib/steep/interface/substitution.rb +65 -0
  46. data/lib/steep/module_name.rb +116 -0
  47. data/lib/steep/parser.rb +1314 -814
  48. data/lib/steep/parser.y +536 -175
  49. data/lib/steep/source.rb +220 -25
  50. data/lib/steep/subtyping/check.rb +673 -0
  51. data/lib/steep/subtyping/constraints.rb +275 -0
  52. data/lib/steep/subtyping/relation.rb +41 -0
  53. data/lib/steep/subtyping/result.rb +126 -0
  54. data/lib/steep/subtyping/trace.rb +48 -0
  55. data/lib/steep/subtyping/variable_occurrence.rb +49 -0
  56. data/lib/steep/subtyping/variable_variance.rb +69 -0
  57. data/lib/steep/type_construction.rb +1630 -524
  58. data/lib/steep/type_inference/block_params.rb +100 -0
  59. data/lib/steep/type_inference/constant_env.rb +55 -0
  60. data/lib/steep/type_inference/send_args.rb +222 -0
  61. data/lib/steep/type_inference/type_env.rb +226 -0
  62. data/lib/steep/type_name.rb +27 -7
  63. data/lib/steep/typing.rb +4 -0
  64. data/lib/steep/version.rb +1 -1
  65. data/lib/steep.rb +71 -16
  66. data/smoke/and/a.rb +4 -2
  67. data/smoke/array/a.rb +4 -5
  68. data/smoke/array/b.rb +4 -4
  69. data/smoke/block/a.rb +2 -2
  70. data/smoke/block/a.rbi +2 -0
  71. data/smoke/block/b.rb +15 -0
  72. data/smoke/case/a.rb +3 -3
  73. data/smoke/class/a.rb +3 -3
  74. data/smoke/class/b.rb +0 -2
  75. data/smoke/class/d.rb +2 -2
  76. data/smoke/class/e.rb +1 -1
  77. data/smoke/class/f.rb +2 -2
  78. data/smoke/class/g.rb +8 -0
  79. data/smoke/const/a.rb +3 -3
  80. data/smoke/dstr/a.rb +1 -1
  81. data/smoke/ensure/a.rb +22 -0
  82. data/smoke/enumerator/a.rb +6 -6
  83. data/smoke/enumerator/b.rb +22 -0
  84. data/smoke/extension/a.rb +2 -2
  85. data/smoke/extension/b.rb +3 -3
  86. data/smoke/extension/c.rb +1 -1
  87. data/smoke/hello/hello.rb +2 -2
  88. data/smoke/if/a.rb +4 -2
  89. data/smoke/kwbegin/a.rb +8 -0
  90. data/smoke/literal/a.rb +5 -5
  91. data/smoke/method/a.rb +5 -5
  92. data/smoke/method/a.rbi +4 -0
  93. data/smoke/method/b.rb +29 -0
  94. data/smoke/module/a.rb +3 -3
  95. data/smoke/module/a.rbi +9 -0
  96. data/smoke/module/b.rb +2 -2
  97. data/smoke/module/c.rb +1 -1
  98. data/smoke/module/d.rb +5 -0
  99. data/smoke/module/e.rb +13 -0
  100. data/smoke/module/f.rb +13 -0
  101. data/smoke/rescue/a.rb +62 -0
  102. data/smoke/super/a.rb +2 -2
  103. data/smoke/type_case/a.rb +35 -0
  104. data/smoke/yield/a.rb +2 -2
  105. data/stdlib/builtin.rbi +463 -24
  106. data/steep.gemspec +3 -2
  107. metadata +91 -29
  108. data/lib/steep/annotation.rb +0 -223
  109. data/lib/steep/signature/class.rb +0 -450
  110. data/lib/steep/signature/extension.rb +0 -51
  111. data/lib/steep/signature/interface.rb +0 -49
  112. data/lib/steep/types/any.rb +0 -31
  113. data/lib/steep/types/class.rb +0 -27
  114. data/lib/steep/types/instance.rb +0 -27
  115. data/lib/steep/types/merge.rb +0 -32
  116. data/lib/steep/types/name.rb +0 -57
  117. data/lib/steep/types/union.rb +0 -42
  118. data/lib/steep/types/var.rb +0 -38
  119. data/lib/steep/types.rb +0 -4
data/smoke/module/f.rb ADDED
@@ -0,0 +1,13 @@
1
+ # !expects@+2 MethodDefinitionMissing: module=::Palette, method=self.nestopia_palette
2
+ # !expects@+1 UnexpectedDynamicMethod: module=::Palette, method=nestopia_palette
3
+ module Palette
4
+ module_function
5
+
6
+ # @dynamic self.defacto_palette
7
+
8
+ def defacto_palette
9
+ []
10
+ end
11
+
12
+ # @dynamic nestopia_palette
13
+ end
data/smoke/rescue/a.rb ADDED
@@ -0,0 +1,62 @@
1
+ # @type var a: Integer
2
+
3
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String)
4
+ a = begin
5
+ 'foo'
6
+ rescue
7
+ 1
8
+ end
9
+
10
+ # @type var b: Integer
11
+
12
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String)
13
+ b = 'foo' rescue 1
14
+
15
+ # @type var c: Integer
16
+
17
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Integer | ::String | ::Symbol)
18
+ c = begin
19
+ 'foo'
20
+ rescue RuntimeError
21
+ :sym
22
+ rescue StandardError
23
+ 1
24
+ end
25
+
26
+ # @type var d: Integer
27
+
28
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
29
+ d = begin
30
+ 1
31
+ else
32
+ 'foo'
33
+ end
34
+
35
+ # @type var e: Integer
36
+
37
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=(::Array<::Integer> | ::Integer | ::String | ::Symbol)
38
+ e = begin
39
+ 'foo'
40
+ rescue RuntimeError
41
+ :sym
42
+ rescue StandardError
43
+ 1
44
+ else
45
+ [1]
46
+ end
47
+
48
+ # @type method foo: (String) -> String
49
+
50
+ # !expects MethodBodyTypeMismatch: method=foo, expected=::String, actual=(::Integer | ::String)
51
+ def foo(a)
52
+ 10
53
+ rescue
54
+ 'foo'
55
+ end
56
+
57
+ # when empty
58
+ begin
59
+ rescue
60
+ else
61
+ ensure
62
+ end
data/smoke/super/a.rb CHANGED
@@ -3,9 +3,9 @@ class A
3
3
  # @type self: A
4
4
 
5
5
  # @type var a: Integer
6
- # !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=Object
6
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Object
7
7
  a = super(x)
8
- # !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=Object
8
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::Object
9
9
  a = super
10
10
 
11
11
  # @type var b: Object
@@ -0,0 +1,35 @@
1
+ # @type var x: Integer | String | Symbol
2
+
3
+ x = (_ = nil)
4
+
5
+ case x
6
+ when Integer, String
7
+ # !expects NoMethodError: type=(::Integer | ::String), method=foobar
8
+ x.foobar()
9
+ end
10
+
11
+ case x == 1
12
+ when Integer
13
+ # !expects NoMethodError: type=(::Integer | ::String | ::Symbol), method=foobar
14
+ x.foobar
15
+ end
16
+
17
+ case x
18
+ when 1
19
+ # !expects NoMethodError: type=(::Integer | ::String | ::Symbol), method=foobar
20
+ x.foobar
21
+ end
22
+
23
+ case x
24
+ when String
25
+ # !expects@+2 IncompatibleAnnotation: var_name=x, ::Integer <: ::String
26
+ # @type var x: Integer
27
+ x + 1
28
+ end
29
+
30
+ case x
31
+ when Object
32
+ # !expects@+2 IncompatibleTypeCase: var_name=x, ::Object <: (::Integer | ::String | ::Symbol)
33
+ # !expects NoMethodError: type=::Object, method=foobar
34
+ x.foobar
35
+ end
data/smoke/yield/a.rb CHANGED
@@ -3,10 +3,10 @@ class A
3
3
  def foo()
4
4
  # @type var x: String
5
5
 
6
- # !expects IncompatibleAssignment: lhs_type=String, rhs_type=Integer
6
+ # !expects IncompatibleAssignment: lhs_type=::String, rhs_type=::Integer
7
7
  x = yield(3)
8
8
 
9
- # !expects IncompatibleAssignment: lhs_type=Integer, rhs_type=String
9
+ # !expects IncompatibleAssignment: lhs_type=::Integer, rhs_type=::String
10
10
  yield(x)
11
11
  end
12
12
 
data/stdlib/builtin.rbi CHANGED
@@ -4,7 +4,7 @@ end
4
4
 
5
5
  class Object <: BasicObject
6
6
  include Kernel
7
- def tap: { (instance) -> any } -> instance
7
+ def tap: { (self) -> any } -> self
8
8
  def to_s: -> String
9
9
  def hash: -> Integer
10
10
  def eql?: (any) -> _Boolean
@@ -15,61 +15,230 @@ class Object <: BasicObject
15
15
  def to_i: -> Integer
16
16
  def is_a?: (Module) -> _Boolean
17
17
  def inspect: -> String
18
+ def freeze: -> self
19
+ def method: (Symbol) -> Method
20
+ def yield_self: <'a>{ (self) -> 'a } -> 'a
21
+ def dup: -> self
22
+ def send: (Symbol, *any) -> any
23
+ def instance_variable_get: (Symbol) -> any
18
24
  end
19
25
 
20
26
  class Module
21
27
  def attr_reader: (*any) -> any
22
- def class: -> Class<Module>
23
- def tap: { (Module) -> any } -> Module
28
+ def class: -> any
29
+ def module_function: (*Symbol) -> any
30
+ | -> any
31
+ def extend: (Module) -> any
32
+ def attr_accessor: (*Symbol) -> any
33
+ def attr_writer: (*Symbol) -> any
34
+ def include: (Module) -> _Boolean
35
+ def prepend: (Module) -> _Boolean
36
+ end
37
+
38
+ class Method
24
39
  end
25
40
 
26
41
  class Class<'instance> <: Module
27
- def allocate: -> 'instance
28
- def tap: { (any) -> any } -> any
29
- def class: -> any
42
+ def new: (*any, **any) -> 'instance
43
+ def class: -> Class.class
44
+ def allocate: -> any
30
45
  end
31
46
 
32
47
  module Kernel
33
48
  def raise: () -> any
34
49
  | (String) -> any
50
+ | (*any) -> any
35
51
 
36
52
  def block_given?: -> _Boolean
37
- def include: (Module) -> _Boolean
38
- def prepend: (Module) -> _Boolean
39
53
  def enum_for: (Symbol, *any) -> any
54
+ def require_relative: (*String) -> void
55
+ def require: (*String) -> void
56
+ def loop: { () -> void } -> void
57
+ def puts: (*any) -> void
58
+ def eval: (String, ? Integer | nil, ?String) -> any
40
59
  end
41
60
 
42
61
  class Array<'a>
62
+ include Enumerable<'a, self>
63
+
64
+ def initialize: (?Integer, ?'a) -> any
65
+ | (self) -> any
66
+ | (Integer) { (Integer) -> 'a } -> any
67
+
68
+ def *: (Integer) -> self
69
+ | (String) -> String
70
+ def -: (self) -> self
71
+ def +: (self) -> self
72
+ def <<: ('a) -> self
73
+
43
74
  def []: (Integer) -> 'a
75
+ | (Range<Integer>) -> (self | nil)
76
+ | (Integer, Integer) -> (self | nil)
77
+ def at: (Integer) -> 'a
78
+ | (Range<Integer>) -> (self | nil)
79
+ | (Integer, Integer) -> (self | nil)
44
80
  def []=: (Integer, 'a) -> 'a
81
+ | (Integer, Integer, 'a) -> 'a
82
+ | (Integer, Integer, self) -> self
83
+ | (Range<Integer>, 'a) -> 'a
84
+ | (Range<Integer>, self) -> self
85
+
86
+ def push: (*'a) -> self
87
+ def append: (*'a) -> self
88
+
89
+ def clear: -> self
90
+
91
+ def collect!: { ('a) -> 'a } -> self
92
+ | -> Enumerator<'a, self>
93
+ def map!: { ('a) -> 'a } -> self
94
+ | -> Enumerator<'a, self>
95
+
96
+ def combination: (?Integer) { (self) -> any } -> Array<self>
97
+ | (?Integer) -> Enumerator<self, Array<self>>
98
+
45
99
  def empty?: -> _Boolean
46
- def size: -> Integer
47
- def map: <'b> { ('a) -> 'b } -> Array<'b>
100
+ def compact: -> self
101
+ def compact!: -> (self | nil)
102
+ def concat: (*Array<'a>) -> self
103
+ | (*'a) -> self
104
+ def delete: ('a) -> ('a | nil)
105
+ | <'x> ('a) { ('a) -> any } -> ('a | 'x)
106
+ def delete_at: (Integer) -> ('a | nil)
107
+ def delete_if: { ('a) -> any } -> self
108
+ | -> Enumerator<'a, self>
109
+ def reject!: { ('a) -> any } -> (self | nil)
110
+ | -> Enumerator<'a, self | nil>
111
+ def dig: (Integer, any) -> any
112
+ def each: { ('a) -> any } -> self
113
+ | -> Enumerator<'a, self>
114
+ def each_index: { (Integer) -> any } -> self
115
+ | -> Enumerator<Integer, self>
116
+ def fetch: (Integer) -> 'a
117
+ | (Integer, 'a) -> 'a
118
+ | (Integer) { (Integer) -> 'a } -> 'a
119
+ def fill: ('a) -> self
120
+ | { (Integer) -> 'a } -> self
121
+ | ('a, Integer, ?Integer|nil) -> self
122
+ | ('a, Range<Integer>) -> self
123
+ | (Integer, ?Integer|nil) { (Integer) -> 'a} -> self
124
+ | (Range<Integer>) { (Integer) -> 'a } -> self
125
+
126
+ def find_index: ('a) -> (Integer | nil)
127
+ | { ('a) -> any } -> (Integer | nil)
128
+ | -> Enumerator<'a, Integer | nil>
129
+
130
+ def index: ('a) -> (Integer | nil)
131
+ | { ('a) -> any } -> (Integer | nil)
132
+ | -> Enumerator<'a, Integer | nil>
133
+
134
+ def flatten: (?Integer | nil) -> Array<any>
135
+ def flatten!: (?Integer | nil) -> (self | nil)
136
+
137
+ def insert: (Integer, *'a) -> self
138
+
48
139
  def join: (any) -> String
49
- def all?: { (any) -> any } -> _Boolean
50
- def sort_by: { ('a) -> any } -> Array<'a>
51
- def zip: <'b> (Array<'b>) -> Array<any>
52
- def each: { ('a) -> any } -> instance
53
- | -> Enumerator<'a, instance>
54
- def select: { ('a) -> any } -> Array<'a>
55
- def <<: ('a) -> instance
56
- def filter: { ('a) -> any } -> Array<'a>
140
+
141
+ def keep_if: { ('a) -> any } -> self
142
+ | -> Enumerator<'a, self>
143
+
144
+ def last: -> ('a | nil)
145
+ | (Integer) -> self
146
+
147
+ def length: -> Integer
148
+ def size: -> Integer
149
+
150
+ def pack: (String, ?buffer: String) -> String
151
+
152
+ def permutation: (?Integer) { (self) -> any } -> Array<self>
153
+ | (?Integer) -> Enumerator<self, Array<self>>
154
+
155
+ def pop: -> ('a | nil)
156
+ | (Integer) -> self
157
+
158
+ def unshift: (*'a) -> self
159
+ def prepend: (*'a) -> self
160
+
161
+ def product: (*Array<'a>) -> Array<Array<'a>>
162
+ | (*Array<'a>) { (Array<'a>) -> any } -> self
163
+
164
+ def rassoc: (any) -> any
165
+
166
+ def repeated_combination: (Integer) { (self) -> any } -> self
167
+ | (Integer) -> Enumerator<self, self>
168
+
169
+ def repeated_permutation: (Integer) { (self) -> any } -> self
170
+ | (Integer) -> Enumerator<self, self>
171
+
172
+ def replace: (self) -> self
173
+
174
+ def reverse: -> self
175
+ def reverse!: -> self
176
+
177
+ def rindex: ('a) -> (Integer | nil)
178
+ | { ('a) -> any } -> (Integer | nil)
179
+ | -> Enumerator<'a, Integer | nil>
180
+
181
+ def rotate: (?Integer) -> self
182
+
183
+ def rotate!: (?Integer) -> self
184
+
185
+ def sample: (?random: any) -> ('a | nil)
186
+ | (Integer, ?random: any) -> self
187
+
188
+ def select!: -> Enumerator<'a, self>
189
+ | { ('a) -> any } -> self
190
+
191
+ def shift: -> ('a | nil)
192
+ | (Integer) -> self
193
+
194
+ def shuffle: (?random: any) -> self
195
+
196
+ def shuffle!: (?random: any) -> self
197
+
198
+ def slice: (Integer) -> ('a | nil)
199
+ | (Integer, Integer) -> (self | nil)
200
+ | (Range<Integer>) -> (self | nil)
201
+
202
+ def slice!: (Integer) -> ('a | nil)
203
+ | (Integer, Integer) -> (self | nil)
204
+ | (Range<Integer>) -> (self | nil)
205
+
206
+ def to_h: -> Hash<any, any>
207
+
208
+ def transpose: -> self
209
+
210
+ def uniq!: -> (self | nil)
211
+ | { ('a) -> any } -> (self | nil)
212
+
213
+ def values_at: (*Integer | Range<Integer>) -> self
214
+
215
+ def zip: <'x> (Array<'x>) -> Array<any>
216
+ | <'x, 'y> (Array<'x>) { ('a, 'x) -> 'y }-> Array<'y>
57
217
  end
58
218
 
59
219
  class Hash<'key, 'value>
60
- def []: ('key) -> 'value
220
+ def []: ('key) -> ('value | nil)
61
221
  def []=: ('key, 'value) -> 'value
62
222
  def size: -> Integer
63
223
  def transform_values: <'a> { ('value) -> 'a } -> Hash<'key, 'a>
64
224
  def each_key: { ('key) -> any } -> instance
65
- | -> Enumerator<'a, instance>
225
+ | -> Enumerator<'a, self>
66
226
  def self.[]: (Array<any>) -> Hash<'key, 'value>
227
+ def keys: () -> Array<'key>
67
228
  end
68
229
 
69
230
  class Symbol
231
+ def self.all_symbols: -> Array<Symbol>
232
+ end
233
+
234
+ interface _ToS
235
+ def to_s: -> String
70
236
  end
71
237
 
72
238
  interface _Boolean
239
+ def !: -> _Boolean
240
+ def to_s: -> String
241
+ def ==: (any) -> _Boolean
73
242
  end
74
243
 
75
244
  class NilClass
@@ -77,28 +246,298 @@ end
77
246
 
78
247
  class Numeric
79
248
  def +: (Numeric) -> Numeric
249
+ def /: (Numeric) -> Numeric
250
+ def <=: (any) -> _Boolean
251
+ def >=: (any) -> _Boolean
252
+ def < : (any) -> _Boolean
253
+ def >: (any) -> _Boolean
80
254
  end
81
255
 
82
256
  class Integer <: Numeric
83
257
  def to_int: -> Integer
84
- def +: (Numeric) -> Integer
258
+ def +: (Integer) -> Integer
85
259
  | (Numeric) -> Numeric
86
260
  def ^: (Numeric) -> Integer
261
+ def *: (Integer) -> Integer
262
+ | (Float) -> Float
263
+ | (Numeric) -> Numeric
264
+ def >>: (Integer) -> Integer
265
+ def step: (Integer, ?Integer) { (Integer) -> any } -> self
266
+ | (Integer, ?Integer) -> Enumerator<Integer, self>
267
+ def times: { (Integer) -> any } -> self
268
+ def %: (Integer) -> Integer
269
+ def -: (Integer) -> Integer
270
+ | (Float) -> Float
271
+ | (Numeric) -> Numeric
272
+ def &: (Integer) -> Integer
273
+ def |: (Integer) -> Integer
274
+ def []: (Integer) -> Integer
275
+ def <<: (Integer) -> Integer
276
+ def floor: (Integer) -> Integer
277
+ def **: (Integer) -> Integer
278
+ def /: (Integer) -> Integer
279
+ | (Float) -> Float
280
+ | (Numeric) -> Numeric
281
+ def ~: () -> Integer
87
282
  end
88
283
 
89
284
  class Float <: Numeric
285
+ def *: (Float) -> Float
286
+ | (Integer) -> Float
287
+ | (Numeric) -> Numeric
288
+ def -: (Float) -> Float
289
+ def +: (Float) -> Float
290
+ | (Numeric) -> Numeric
291
+ def round: (Integer) -> (Float | Integer)
292
+ | () -> Integer
293
+ def floor: -> Integer
294
+ def /: (Float) -> Float
295
+ | (Integer) -> Float
296
+ | (Numeric) -> Numeric
297
+ end
298
+
299
+ Math::PI: Float
300
+
301
+ class Complex <: Numeric
302
+ def self.polar: (Numeric, Numeric) -> instance
303
+ def +: (Complex) -> Complex
304
+ | (Numeric) -> Numeric
305
+ def conjugate: -> Complex
306
+ def *: (Complex) -> Complex
307
+ | (Numeric) -> Numeric
308
+ def real: -> Float
90
309
  end
91
310
 
92
311
  class Range<'a>
312
+ def begin: -> 'a
313
+ def end: -> 'a
314
+ def map: <'b> { ('a) -> 'b } -> Array<'b>
315
+ def all?: { ('a) -> any } -> any
316
+ def max_by: { ('a) -> any } -> 'a
317
+ def to_a: -> Array<'a>
93
318
  end
94
319
 
95
320
  class String
321
+ def []: (Range<Integer>) -> String
322
+ def to_sym: -> Symbol
96
323
  def +: (String) -> String
97
324
  def to_str: -> String
98
325
  def size: -> Integer
326
+ def bytes: -> Array<Integer>
327
+ def %: (any) -> String
328
+ def <<: (String) -> self
329
+ def chars: -> Array<String>
330
+ def slice!: (Integer) -> String
331
+ | (Integer, Integer) -> String
332
+ | (String) -> String
333
+ | (Regexp, ?Integer) -> String
334
+ | (Range<Integer>) -> String
335
+ def unpack: (String) -> Array<any>
336
+ def b: -> String
337
+ def downcase: -> String
338
+ def bytes: -> Array<Integer>
339
+ def split: (String) -> Array<String>
340
+ | (Regexp) -> Array<String>
341
+ def gsub: (Regexp, String) -> self
342
+ | (String, String) -> self
343
+ | (Regexp) { (String) -> _ToS } -> String
344
+ def gsub!: (Regexp, String) -> self
345
+ | (String, String) -> self
346
+ | (Regexp) { (String) -> _ToS } -> String
347
+ def sub: (Regexp | String, String) -> self
348
+ | (Regexp | String) { (String) -> _ToS } -> String
349
+ def chomp: -> String
350
+ def *: (Integer) -> String
351
+ def scan: (Regexp) { (Array<String>) -> void } -> String
352
+ | (Regexp) -> Array<String>
353
+ end
354
+
355
+ interface _Iteratable<'a, 'b>
356
+ def each: () { ('a) -> void } -> 'b
357
+ end
358
+
359
+ module Enumerable<'a, 'b> : _Iteratable<'a, 'b>
360
+ def all?: -> _Boolean
361
+ | { ('a) -> any } -> _Boolean
362
+ | (any) -> _Boolean
363
+
364
+ def any?: -> _Boolean
365
+ | { ('a) -> any } -> _Boolean
366
+ | (any) -> _Boolean
367
+
368
+ def chunk: { ('a) -> any } -> Enumerator<'a, self>
369
+
370
+ def chunk_while: { ('a, 'a) -> any } -> Enumerator<'a, 'b>
371
+
372
+ def collect: <'x> { ('a) -> 'x } -> Array<'x>
373
+ | <'x> -> Enumerator<'a, Array<'x>>
374
+
375
+ def map: <'x> { ('a) -> 'x } -> Array<'x>
376
+ | <'x> -> Enumerator<'a, Array<'x>>
377
+
378
+ def flat_map: <'x> { ('a) -> Array<'x> } -> Array<'x>
379
+ | <'x> -> Enumerator<'a, Array<'x>>
380
+
381
+ def collect_concat: <'x> { ('a) -> Array<'x> } -> Array<'x>
382
+ | <'x> -> Enumerator<'a, Array<'x>>
383
+
384
+ def count: -> Integer
385
+ | (any) -> Integer
386
+ | { ('a) -> any } -> Integer
387
+
388
+ def cycle: (?Integer) -> Enumerator<'a, nil>
389
+ | (?Integer) { ('a) -> any } -> nil
390
+
391
+ def detect: ('a) { ('a) -> any } -> 'a
392
+ | { ('a) -> any } -> ('a | nil)
393
+ | -> Enumerator<'a, 'a | nil>
394
+ | ('a) -> Enumerator<'a, 'a>
395
+
396
+ def find: ('a) { ('a) -> any } -> 'a
397
+ | { ('a) -> any } -> ('a | nil)
398
+ | -> Enumerator<'a, 'a | nil>
399
+ | ('a) -> Enumerator<'a, 'a>
400
+
401
+ def drop: (Integer) -> Array<'a>
402
+
403
+ def drop_while: -> Enumerator<'a, Array<'a>>
404
+ | { ('a) -> any } -> Array<'a>
405
+
406
+ def each_cons: (Integer) -> Enumerator<Array<'a>, nil>
407
+ | (Integer) { (Array<'a>) -> any } -> nil
408
+
409
+ def each_entry: -> Enumerator<'a, self>
410
+ | { ('a) -> any } -> self
411
+
412
+ def each_slice: (Integer) -> Enumerator<Array<'a>, nil>
413
+ | (Integer) { (Array<'a>) -> any } -> nil
414
+
415
+ def each_with_index: { ('a, Integer) -> any } -> self
416
+
417
+ def each_with_object: <'x> ('x) { ('a, 'x) -> any } -> 'x
418
+
419
+ def to_a: -> Array<'a>
420
+ def entries: -> Array<'a>
421
+
422
+ def find_all: -> Enumerator<'a, Array<'a>>
423
+ | { ('a) -> any } -> Array<'a>
424
+ def select: -> Enumerator<'a, Array<'a>>
425
+ | { ('a) -> any } -> Array<'a>
426
+
427
+ def find_index: (any) -> (Integer | nil)
428
+ | { ('a) -> any } -> (Integer | nil)
429
+ | -> Enumerator<'a, Integer | nil>
430
+
431
+ def first: () -> ('a | nil)
432
+ | (Integer) -> Array<'a>
433
+
434
+ def grep: (any) -> Array<'a>
435
+ | <'x> (any) { ('a) -> 'x } -> Array<'x>
436
+
437
+ def grep_v: (any) -> Array<'a>
438
+ | <'x> (any) { ('a) -> 'x } -> Array<'x>
439
+
440
+ def group_by: <'x> { ('a) -> 'x } -> Hash<'x, Array<'a>>
441
+
442
+ def member?: (any) -> _Boolean
443
+ def include?: (any) -> _Boolean
444
+
445
+ def inject: <'x> ('x) { ('x, 'a) -> 'x } -> 'x
446
+ | (Symbol) -> any
447
+ | (any, Symbol) -> any
448
+ | { ('a, 'a) -> 'a } -> 'a
449
+
450
+
451
+ def reduce: <'x> ('x) { ('x, 'a) -> 'x } -> 'x
452
+ | (Symbol) -> any
453
+ | (any, Symbol) -> any
454
+ | { ('a, 'a) -> 'a } -> 'a
455
+
456
+ def max: -> ('a | nil)
457
+ | (Integer) -> Array<'a>
458
+ | { ('a, 'a) -> Integer } -> ('a | nil)
459
+ | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
460
+
461
+ def max_by: { ('a, 'a) -> Integer } -> ('a | nil)
462
+ | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
463
+
464
+ def min: -> ('a | nil)
465
+ | (Integer) -> Array<'a>
466
+ | { ('a, 'a) -> Integer } -> ('a | nil)
467
+ | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
468
+
469
+ def min_by: { ('a, 'a) -> Integer } -> ('a | nil)
470
+ | (Integer) { ('a, 'a) -> Integer } -> Array<'a>
471
+
472
+ def min_max: -> Array<'a>
473
+ | { ('a, 'a) -> Integer } -> Array<'a>
474
+
475
+ def min_max_by: { ('a, 'a) -> Integer } -> Array<'a>
476
+
477
+ def none?: -> _Boolean
478
+ | { ('a) -> any } -> _Boolean
479
+ | (any) -> _Boolean
480
+
481
+ def one?: -> _Boolean
482
+ | { ('a) -> any } -> _Boolean
483
+ | (any) -> _Boolean
484
+
485
+ def partition: { ('a) -> any } -> Array<Array<'a>>
486
+ | -> Enumerator<'a, Array<Array<'a>>>
487
+
488
+ def reject: { ('a) -> any } -> Array<'a>
489
+ | -> Enumerator<'a, Array<'a>>
490
+
491
+ def reverse_each: { ('a) -> void } -> self
492
+ | -> Enumerator<'a, self>
493
+
494
+ def slice_after: (any) -> Enumerator<Array<'a>, nil>
495
+ | { ('a) -> any } -> Enumerator<Array<'a>, nil>
496
+
497
+ def slice_before: (any) -> Enumerator<Array<'a>, nil>
498
+ | { ('a) -> any } -> Enumerator<Array<'a>, nil>
499
+
500
+ def slice_when: { ('a, 'a) -> any } -> Enumerator<Array<'a>, nil>
501
+
502
+ def sort: -> Array<'a>
503
+ | { ('a, 'a) -> Integer } -> Array<'a>
504
+
505
+ def sort_by: { ('a) -> any } -> Array<'a>
506
+ | -> Enumerator<'a, Array<'a>>
507
+
508
+ def sum: () -> Numeric
509
+ | (Numeric) -> Numeric
510
+ | (any) -> any
511
+ | (?any) { ('a) -> any } -> any
512
+
513
+ def take: (Integer) -> Array<'a>
514
+
515
+ def take_while: { ('a) -> any } -> Array<'a>
516
+ | -> Enumerator<'a, Array<'a>>
517
+
518
+
519
+ def to_h: -> Hash<any, any>
520
+
521
+ def uniq: -> Array<'a>
522
+ | { ('a) -> any } -> Array<'a>
523
+ end
524
+
525
+ class Enumerator<'a, 'b>
526
+ include Enumerable<'a, 'b>
527
+ def each: { ('a) -> any } -> 'b
528
+ def with_object: <'x> ('x) { ('a, 'x) -> any } -> 'x
529
+ def with_index: { ('a, Integer) -> any } -> 'b
530
+ end
531
+
532
+ class Regexp
99
533
  end
100
534
 
101
- class Enumerator<'a, 'this>
102
- def with_object: <'b> ('b) { ('a, 'b) -> any } -> 'b
103
- def with_index: { ('a, Integer) -> any } -> 'this
535
+ class File
536
+ def self.binread: (String) -> String
537
+ def self.extname: (String) -> String
538
+ def self.basename: (String) -> String
539
+ def self.readable?: (String) -> _Boolean
540
+ def self.binwrite: (String, String) -> void
541
+ def self.read: (String) -> String
542
+ | (String, Integer | nil) -> (String | nil)
104
543
  end