rspec-sorbet 1.8.0 → 1.8.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (119) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +14 -22
  3. data/.gitignore +2 -1
  4. data/CHANGELOG.md +4 -0
  5. data/Gemfile +1 -5
  6. data/bin/tapioca +29 -0
  7. data/lib/rspec/sorbet/doubles.rb +1 -1
  8. data/lib/rspec/sorbet/version.rb +1 -1
  9. data/nix/sources.json +14 -0
  10. data/nix/sources.nix +174 -0
  11. data/run_ci.sh +7 -0
  12. data/shell.nix +20 -0
  13. data/sorbet/config +2 -0
  14. data/sorbet/rbi/gems/{ast.rbi → ast@2.4.2.rbi} +28 -22
  15. data/sorbet/rbi/gems/byebug@11.1.3.rbi +1568 -0
  16. data/sorbet/rbi/gems/coderay@1.1.3.rbi +1005 -0
  17. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +9 -0
  18. data/sorbet/rbi/gems/docile@1.4.0.rbi +54 -0
  19. data/sorbet/rbi/gems/em-websocket@0.5.2.rbi +8 -0
  20. data/sorbet/rbi/gems/eventmachine@1.2.7.rbi +45 -0
  21. data/sorbet/rbi/gems/ffaker@2.20.0.rbi +3171 -0
  22. data/sorbet/rbi/gems/ffi@1.15.4.rbi +8 -0
  23. data/sorbet/rbi/gems/formatador@0.3.0.rbi +8 -0
  24. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +31 -0
  25. data/sorbet/rbi/gems/guard-livereload@2.5.2.rbi +8 -0
  26. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +211 -0
  27. data/sorbet/rbi/gems/guard@2.18.0.rbi +8 -0
  28. data/sorbet/rbi/gems/http_parser.rb@0.6.0.rbi +8 -0
  29. data/sorbet/rbi/gems/listen@3.7.0.rbi +8 -0
  30. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +8 -0
  31. data/sorbet/rbi/gems/method_source@1.0.0.rbi +72 -0
  32. data/sorbet/rbi/gems/multi_json@1.15.0.rbi +8 -0
  33. data/sorbet/rbi/gems/nenv@0.3.0.rbi +8 -0
  34. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +8 -0
  35. data/sorbet/rbi/gems/parallel@1.21.0.rbi +113 -0
  36. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +1189 -0
  37. data/sorbet/rbi/gems/pry-byebug@3.8.0.rbi +458 -0
  38. data/sorbet/rbi/gems/{pry.rbi → pry@0.14.1.rbi} +2264 -1727
  39. data/sorbet/rbi/gems/{rainbow.rbi → rainbow@3.0.0.rbi} +90 -55
  40. data/sorbet/rbi/gems/{rake.rbi → rake@13.0.6.rbi} +578 -431
  41. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +8 -0
  42. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +8 -0
  43. data/sorbet/rbi/gems/rbi@0.0.6.rbi +1405 -0
  44. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +1120 -0
  45. data/sorbet/rbi/gems/{rexml.rbi → rexml@3.2.5.rbi} +564 -497
  46. data/sorbet/rbi/gems/{rspec-core.rbi → rspec-core@3.10.1.rbi} +2308 -1766
  47. data/sorbet/rbi/gems/{rspec-expectations.rbi → rspec-expectations@3.10.1.rbi} +1149 -698
  48. data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi} +1299 -936
  49. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +509 -0
  50. data/sorbet/rbi/gems/rspec@3.10.0.rbi +38 -0
  51. data/sorbet/rbi/gems/rubocop-ast@1.12.0.rbi +1938 -0
  52. data/sorbet/rbi/gems/rubocop-rspec@2.5.0.rbi +1786 -0
  53. data/sorbet/rbi/gems/rubocop@1.22.1.rbi +13252 -0
  54. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +405 -0
  55. data/sorbet/rbi/gems/shellany@0.0.1.rbi +8 -0
  56. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +89 -0
  57. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +577 -0
  58. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +8 -0
  59. data/sorbet/rbi/gems/spoom@1.1.5.rbi +1241 -0
  60. data/sorbet/rbi/gems/stackprof@0.2.17.rbi +98 -0
  61. data/sorbet/rbi/gems/tapioca@0.5.2.rbi +949 -0
  62. data/sorbet/rbi/gems/thor@1.1.0.rbi +839 -0
  63. data/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi +26 -0
  64. data/sorbet/rbi/gems/unparser@0.6.0.rbi +8 -0
  65. data/sorbet/tapioca/require.rb +4 -0
  66. metadata +60 -64
  67. data/.reek.yml +0 -32
  68. data/.ruby-version +0 -1
  69. data/sorbet/rbi/gems/activesupport.rbi +0 -1722
  70. data/sorbet/rbi/gems/byebug.rbi +0 -1041
  71. data/sorbet/rbi/gems/coderay.rbi +0 -285
  72. data/sorbet/rbi/gems/concurrent-ruby.rbi +0 -1586
  73. data/sorbet/rbi/gems/docile.rbi +0 -32
  74. data/sorbet/rbi/gems/em-websocket.rbi +0 -225
  75. data/sorbet/rbi/gems/eventmachine.rbi +0 -489
  76. data/sorbet/rbi/gems/ffaker.rbi +0 -60
  77. data/sorbet/rbi/gems/guard.rbi +0 -397
  78. data/sorbet/rbi/gems/http_parser.rb.rbi +0 -37
  79. data/sorbet/rbi/gems/i18n.rbi +0 -133
  80. data/sorbet/rbi/gems/kwalify.rbi +0 -340
  81. data/sorbet/rbi/gems/listen.rbi +0 -324
  82. data/sorbet/rbi/gems/lumberjack.rbi +0 -300
  83. data/sorbet/rbi/gems/method_source.rbi +0 -64
  84. data/sorbet/rbi/gems/multi_json.rbi +0 -62
  85. data/sorbet/rbi/gems/nenv.rbi +0 -60
  86. data/sorbet/rbi/gems/notiffany.rbi +0 -215
  87. data/sorbet/rbi/gems/parallel.rbi +0 -82
  88. data/sorbet/rbi/gems/parser.rbi +0 -1846
  89. data/sorbet/rbi/gems/pry-byebug.rbi +0 -155
  90. data/sorbet/rbi/gems/rb-fsevent.rbi +0 -31
  91. data/sorbet/rbi/gems/rb-readline.rbi +0 -767
  92. data/sorbet/rbi/gems/reek.rbi +0 -1027
  93. data/sorbet/rbi/gems/regexp_parser.rbi +0 -913
  94. data/sorbet/rbi/gems/rspec-support.rbi +0 -280
  95. data/sorbet/rbi/gems/rspec.rbi +0 -15
  96. data/sorbet/rbi/gems/rubocop-ast.rbi +0 -1053
  97. data/sorbet/rbi/gems/rubocop-rspec.rbi +0 -937
  98. data/sorbet/rbi/gems/rubocop.rbi +0 -6841
  99. data/sorbet/rbi/gems/ruby-progressbar.rbi +0 -305
  100. data/sorbet/rbi/gems/shellany.rbi +0 -29
  101. data/sorbet/rbi/gems/shoulda-matchers.rbi +0 -1848
  102. data/sorbet/rbi/gems/simplecov-html.rbi +0 -35
  103. data/sorbet/rbi/gems/simplecov.rbi +0 -361
  104. data/sorbet/rbi/gems/sqlite3.rbi +0 -354
  105. data/sorbet/rbi/gems/stackprof.rbi +0 -52
  106. data/sorbet/rbi/gems/thor.rbi +0 -32
  107. data/sorbet/rbi/gems/thread_safe.rbi +0 -82
  108. data/sorbet/rbi/gems/timecop.rbi +0 -98
  109. data/sorbet/rbi/gems/tzinfo.rbi +0 -406
  110. data/sorbet/rbi/gems/unicode-display_width.rbi +0 -17
  111. data/sorbet/rbi/hidden-definitions/errors.txt +0 -7275
  112. data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -14595
  113. data/sorbet/rbi/sorbet-typed/lib/activesupport/>=6.0.0.rc1/activesupport.rbi +0 -23
  114. data/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi +0 -1431
  115. data/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi +0 -108
  116. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +0 -276
  117. data/sorbet/rbi/sorbet-typed/lib/rubocop/~>0.85/rubocop.rbi +0 -2072
  118. data/sorbet/rbi/sorbet-typed/lib/rubocop-rspec/~>1.39/rubocop-rspec.rbi +0 -398
  119. data/sorbet/rbi/todo.rbi +0 -9
@@ -0,0 +1,1405 @@
1
+ # DO NOT EDIT MANUALLY
2
+ # This is an autogenerated file for types exported from the `rbi` gem.
3
+ # Please instead update this file by running `bin/tapioca gem rbi`.
4
+
5
+ # typed: true
6
+
7
+ module RBI; end
8
+
9
+ class RBI::ASTVisitor
10
+ abstract!
11
+
12
+ def initialize(*args, &blk); end
13
+
14
+ sig { abstract.params(node: T.nilable(AST::Node)).void }
15
+ def visit(node); end
16
+
17
+ sig { params(nodes: T::Array[AST::Node]).void }
18
+ def visit_all(nodes); end
19
+
20
+ private
21
+
22
+ sig { params(node: AST::Node).returns(String) }
23
+ def parse_expr(node); end
24
+
25
+ sig { params(node: AST::Node).returns(String) }
26
+ def parse_name(node); end
27
+ end
28
+
29
+ class RBI::Attr < ::RBI::NodeWithComments
30
+ include ::RBI::Indexable
31
+
32
+ abstract!
33
+
34
+ sig { params(name: Symbol, names: T::Array[Symbol], visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
35
+ def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
36
+
37
+ sig { override.params(v: RBI::Printer).void }
38
+ def accept_printer(v); end
39
+
40
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
41
+ def compatible_with?(other); end
42
+
43
+ sig { abstract.returns(T::Array[String]) }
44
+ def fully_qualified_names; end
45
+
46
+ sig { override.returns(T::Array[String]) }
47
+ def index_ids; end
48
+
49
+ sig { override.params(other: RBI::Node).void }
50
+ def merge_with(other); end
51
+
52
+ sig { returns(T::Array[Symbol]) }
53
+ def names; end
54
+
55
+ def names=(_arg0); end
56
+
57
+ sig { override.returns(T::Boolean) }
58
+ def oneline?; end
59
+
60
+ sig { returns(T::Array[RBI::Sig]) }
61
+ def sigs; end
62
+
63
+ sig { returns(RBI::Visibility) }
64
+ def visibility; end
65
+
66
+ def visibility=(_arg0); end
67
+ end
68
+
69
+ class RBI::AttrAccessor < ::RBI::Attr
70
+ sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrAccessor).void)).void }
71
+ def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
72
+
73
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
74
+ def compatible_with?(other); end
75
+
76
+ sig { override.returns(T::Array[String]) }
77
+ def fully_qualified_names; end
78
+
79
+ sig { override.returns(String) }
80
+ def to_s; end
81
+ end
82
+
83
+ class RBI::AttrReader < ::RBI::Attr
84
+ sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrReader).void)).void }
85
+ def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
86
+
87
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
88
+ def compatible_with?(other); end
89
+
90
+ sig { override.returns(T::Array[String]) }
91
+ def fully_qualified_names; end
92
+
93
+ sig { override.returns(String) }
94
+ def to_s; end
95
+ end
96
+
97
+ class RBI::AttrWriter < ::RBI::Attr
98
+ sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrWriter).void)).void }
99
+ def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
100
+
101
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
102
+ def compatible_with?(other); end
103
+
104
+ sig { override.returns(T::Array[String]) }
105
+ def fully_qualified_names; end
106
+
107
+ sig { override.returns(String) }
108
+ def to_s; end
109
+ end
110
+
111
+ class RBI::BlockParam < ::RBI::Param
112
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::BlockParam).void)).void }
113
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
114
+
115
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
116
+ def ==(other); end
117
+
118
+ sig { override.params(v: RBI::Printer).void }
119
+ def accept_printer(v); end
120
+
121
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
122
+ def print_comment_leading_space(v, last:); end
123
+
124
+ sig { override.returns(String) }
125
+ def to_s; end
126
+ end
127
+
128
+ class RBI::Class < ::RBI::Scope
129
+ sig { params(name: String, superclass_name: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Class).void)).void }
130
+ def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
131
+
132
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
133
+ def compatible_with?(other); end
134
+
135
+ sig { override.returns(String) }
136
+ def fully_qualified_name; end
137
+
138
+ sig { returns(String) }
139
+ def name; end
140
+
141
+ def name=(_arg0); end
142
+
143
+ sig { override.params(v: RBI::Printer).void }
144
+ def print_header(v); end
145
+
146
+ sig { returns(T.nilable(String)) }
147
+ def superclass_name; end
148
+
149
+ def superclass_name=(_arg0); end
150
+ end
151
+
152
+ class RBI::Comment < ::RBI::Node
153
+ sig { params(text: String, loc: T.nilable(RBI::Loc)).void }
154
+ def initialize(text, loc: T.unsafe(nil)); end
155
+
156
+ sig { params(other: Object).returns(T::Boolean) }
157
+ def ==(other); end
158
+
159
+ sig { override.params(v: RBI::Printer).void }
160
+ def accept_printer(v); end
161
+
162
+ sig { returns(String) }
163
+ def text; end
164
+
165
+ def text=(_arg0); end
166
+ end
167
+
168
+ class RBI::ConflictTree < ::RBI::Tree
169
+ sig { params(left_name: String, right_name: String).void }
170
+ def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
171
+
172
+ sig { override.params(v: RBI::Printer).void }
173
+ def accept_printer(v); end
174
+
175
+ sig { returns(RBI::Tree) }
176
+ def left; end
177
+
178
+ def right; end
179
+ end
180
+
181
+ class RBI::Const < ::RBI::NodeWithComments
182
+ include ::RBI::Indexable
183
+
184
+ sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Const).void)).void }
185
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
186
+
187
+ sig { override.params(v: RBI::Printer).void }
188
+ def accept_printer(v); end
189
+
190
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
191
+ def compatible_with?(other); end
192
+
193
+ sig { returns(String) }
194
+ def fully_qualified_name; end
195
+
196
+ sig { override.returns(T::Array[String]) }
197
+ def index_ids; end
198
+
199
+ sig { returns(String) }
200
+ def name; end
201
+
202
+ sig { override.returns(String) }
203
+ def to_s; end
204
+
205
+ def value; end
206
+ end
207
+
208
+ class RBI::ConstBuilder < ::RBI::ASTVisitor
209
+ sig { void }
210
+ def initialize; end
211
+
212
+ sig { returns(T::Array[String]) }
213
+ def names; end
214
+
215
+ def names=(_arg0); end
216
+
217
+ sig { override.params(node: T.nilable(AST::Node)).void }
218
+ def visit(node); end
219
+
220
+ class << self
221
+ sig { params(node: T.nilable(AST::Node)).returns(T.nilable(String)) }
222
+ def visit(node); end
223
+ end
224
+ end
225
+
226
+ class RBI::EmptyComment < ::RBI::Comment
227
+ sig { params(loc: T.nilable(RBI::Loc)).void }
228
+ def initialize(loc: T.unsafe(nil)); end
229
+
230
+ sig { override.params(v: RBI::Printer).void }
231
+ def accept_printer(v); end
232
+ end
233
+
234
+ class RBI::Error < ::StandardError; end
235
+
236
+ class RBI::Extend < ::RBI::Mixin
237
+ include ::RBI::Indexable
238
+
239
+ sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Extend).void)).void }
240
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
241
+
242
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
243
+ def compatible_with?(other); end
244
+
245
+ sig { override.returns(T::Array[String]) }
246
+ def index_ids; end
247
+
248
+ sig { override.returns(String) }
249
+ def to_s; end
250
+ end
251
+
252
+ class RBI::File
253
+ sig { params(strictness: T.nilable(String), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(file: RBI::File).void)).void }
254
+ def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
255
+
256
+ sig { params(node: RBI::Node).void }
257
+ def <<(node); end
258
+
259
+ sig { params(v: RBI::Printer).void }
260
+ def accept_printer(v); end
261
+
262
+ sig { returns(T::Array[RBI::Comment]) }
263
+ def comments; end
264
+
265
+ def comments=(_arg0); end
266
+
267
+ sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
268
+ def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
269
+
270
+ sig { returns(RBI::Tree) }
271
+ def root; end
272
+
273
+ sig { returns(T.nilable(String)) }
274
+ def strictness; end
275
+
276
+ sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
277
+ def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
278
+ end
279
+
280
+ class RBI::Group < ::RBI::Tree
281
+ sig { params(kind: RBI::Group::Kind).void }
282
+ def initialize(kind); end
283
+
284
+ sig { override.params(v: RBI::Printer).void }
285
+ def accept_printer(v); end
286
+
287
+ sig { returns(RBI::Group::Kind) }
288
+ def kind; end
289
+ end
290
+
291
+ class RBI::Group::Kind < ::T::Enum
292
+ enums do
293
+ Mixins = new
294
+ Helpers = new
295
+ TypeMembers = new
296
+ MixesInClassMethods = new
297
+ TStructFields = new
298
+ TEnums = new
299
+ Inits = new
300
+ Methods = new
301
+ Consts = new
302
+ end
303
+ end
304
+
305
+ class RBI::Helper < ::RBI::NodeWithComments
306
+ include ::RBI::Indexable
307
+
308
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Helper).void)).void }
309
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
310
+
311
+ sig { override.params(v: RBI::Printer).void }
312
+ def accept_printer(v); end
313
+
314
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
315
+ def compatible_with?(other); end
316
+
317
+ sig { override.returns(T::Array[String]) }
318
+ def index_ids; end
319
+
320
+ sig { returns(String) }
321
+ def name; end
322
+
323
+ sig { override.returns(String) }
324
+ def to_s; end
325
+ end
326
+
327
+ class RBI::Include < ::RBI::Mixin
328
+ include ::RBI::Indexable
329
+
330
+ sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Include).void)).void }
331
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
332
+
333
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
334
+ def compatible_with?(other); end
335
+
336
+ sig { override.returns(T::Array[String]) }
337
+ def index_ids; end
338
+
339
+ sig { override.returns(String) }
340
+ def to_s; end
341
+ end
342
+
343
+ class RBI::Index < ::RBI::Visitor
344
+ sig { void }
345
+ def initialize; end
346
+
347
+ sig { params(id: String).returns(T::Array[RBI::Node]) }
348
+ def [](id); end
349
+
350
+ sig { params(node: T.all(RBI::Indexable, RBI::Node)).void }
351
+ def index(node); end
352
+
353
+ sig { returns(T::Array[String]) }
354
+ def keys; end
355
+
356
+ sig { override.params(node: T.nilable(RBI::Node)).void }
357
+ def visit(node); end
358
+
359
+ class << self
360
+ sig { params(node: RBI::Node).returns(RBI::Index) }
361
+ def index(*node); end
362
+ end
363
+ end
364
+
365
+ module RBI::Indexable
366
+ interface!
367
+
368
+ sig { abstract.returns(T::Array[String]) }
369
+ def index_ids; end
370
+ end
371
+
372
+ class RBI::KwOptParam < ::RBI::Param
373
+ sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwOptParam).void)).void }
374
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
375
+
376
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
377
+ def ==(other); end
378
+
379
+ sig { override.params(v: RBI::Printer).void }
380
+ def accept_printer(v); end
381
+
382
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
383
+ def print_comment_leading_space(v, last:); end
384
+
385
+ sig { override.returns(String) }
386
+ def to_s; end
387
+
388
+ sig { returns(String) }
389
+ def value; end
390
+ end
391
+
392
+ class RBI::KwParam < ::RBI::Param
393
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwParam).void)).void }
394
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
395
+
396
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
397
+ def ==(other); end
398
+
399
+ sig { override.params(v: RBI::Printer).void }
400
+ def accept_printer(v); end
401
+
402
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
403
+ def print_comment_leading_space(v, last:); end
404
+
405
+ sig { override.returns(String) }
406
+ def to_s; end
407
+ end
408
+
409
+ class RBI::KwRestParam < ::RBI::Param
410
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwRestParam).void)).void }
411
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
412
+
413
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
414
+ def ==(other); end
415
+
416
+ sig { override.params(v: RBI::Printer).void }
417
+ def accept_printer(v); end
418
+
419
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
420
+ def print_comment_leading_space(v, last:); end
421
+
422
+ sig { override.returns(String) }
423
+ def to_s; end
424
+ end
425
+
426
+ class RBI::Loc
427
+ sig { params(file: T.nilable(String), begin_line: T.nilable(Integer), end_line: T.nilable(Integer), begin_column: T.nilable(Integer), end_column: T.nilable(Integer)).void }
428
+ def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end
429
+
430
+ def begin_column; end
431
+
432
+ sig { returns(T.nilable(Integer)) }
433
+ def begin_line; end
434
+
435
+ def end_column; end
436
+ def end_line; end
437
+
438
+ sig { returns(T.nilable(String)) }
439
+ def file; end
440
+
441
+ sig { returns(String) }
442
+ def to_s; end
443
+
444
+ class << self
445
+ sig { params(file: String, ast_loc: T.any(Parser::Source::Map, Parser::Source::Range)).returns(RBI::Loc) }
446
+ def from_ast_loc(file, ast_loc); end
447
+ end
448
+ end
449
+
450
+ class RBI::Method < ::RBI::NodeWithComments
451
+ include ::RBI::Indexable
452
+
453
+ sig { params(name: String, params: T::Array[RBI::Param], is_singleton: T::Boolean, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Method).void)).void }
454
+ def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
455
+
456
+ sig { params(param: RBI::Param).void }
457
+ def <<(param); end
458
+
459
+ sig { override.params(v: RBI::Printer).void }
460
+ def accept_printer(v); end
461
+
462
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
463
+ def compatible_with?(other); end
464
+
465
+ sig { returns(String) }
466
+ def fully_qualified_name; end
467
+
468
+ sig { override.returns(T::Array[String]) }
469
+ def index_ids; end
470
+
471
+ sig { returns(T::Boolean) }
472
+ def inline_params?; end
473
+
474
+ sig { returns(T::Boolean) }
475
+ def is_singleton; end
476
+
477
+ def is_singleton=(_arg0); end
478
+
479
+ sig { override.params(other: RBI::Node).void }
480
+ def merge_with(other); end
481
+
482
+ sig { returns(String) }
483
+ def name; end
484
+
485
+ def name=(_arg0); end
486
+
487
+ sig { override.returns(T::Boolean) }
488
+ def oneline?; end
489
+
490
+ sig { returns(T::Array[RBI::Param]) }
491
+ def params; end
492
+
493
+ sig { returns(T::Array[RBI::Sig]) }
494
+ def sigs; end
495
+
496
+ def sigs=(_arg0); end
497
+
498
+ sig { override.returns(String) }
499
+ def to_s; end
500
+
501
+ sig { returns(RBI::Visibility) }
502
+ def visibility; end
503
+
504
+ def visibility=(_arg0); end
505
+ end
506
+
507
+ class RBI::MixesInClassMethods < ::RBI::Mixin
508
+ include ::RBI::Indexable
509
+
510
+ sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::MixesInClassMethods).void)).void }
511
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
512
+
513
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
514
+ def compatible_with?(other); end
515
+
516
+ sig { override.returns(T::Array[String]) }
517
+ def index_ids; end
518
+
519
+ sig { override.returns(String) }
520
+ def to_s; end
521
+ end
522
+
523
+ class RBI::Mixin < ::RBI::NodeWithComments
524
+ abstract!
525
+
526
+ sig { params(name: String, names: T::Array[String], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
527
+ def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
528
+
529
+ sig { override.params(v: RBI::Printer).void }
530
+ def accept_printer(v); end
531
+
532
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
533
+ def compatible_with?(other); end
534
+
535
+ sig { returns(T::Array[String]) }
536
+ def names; end
537
+
538
+ def names=(_arg0); end
539
+ end
540
+
541
+ class RBI::Module < ::RBI::Scope
542
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Module).void)).void }
543
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
544
+
545
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
546
+ def compatible_with?(other); end
547
+
548
+ sig { override.returns(String) }
549
+ def fully_qualified_name; end
550
+
551
+ sig { returns(String) }
552
+ def name; end
553
+
554
+ def name=(_arg0); end
555
+
556
+ sig { override.params(v: RBI::Printer).void }
557
+ def print_header(v); end
558
+ end
559
+
560
+ class RBI::Node
561
+ abstract!
562
+
563
+ sig { params(loc: T.nilable(RBI::Loc)).void }
564
+ def initialize(loc: T.unsafe(nil)); end
565
+
566
+ sig { abstract.params(v: RBI::Printer).void }
567
+ def accept_printer(v); end
568
+
569
+ sig { params(_other: RBI::Node).returns(T::Boolean) }
570
+ def compatible_with?(_other); end
571
+
572
+ sig { void }
573
+ def detach; end
574
+
575
+ sig { returns(RBI::Group::Kind) }
576
+ def group_kind; end
577
+
578
+ sig { returns(T.nilable(RBI::Loc)) }
579
+ def loc; end
580
+
581
+ def loc=(_arg0); end
582
+
583
+ sig { params(other: RBI::Node).void }
584
+ def merge_with(other); end
585
+
586
+ sig { returns(T::Boolean) }
587
+ def oneline?; end
588
+
589
+ sig { returns(T.nilable(RBI::ConflictTree)) }
590
+ def parent_conflict_tree; end
591
+
592
+ sig { returns(T.nilable(RBI::Scope)) }
593
+ def parent_scope; end
594
+
595
+ sig { returns(T.nilable(RBI::Tree)) }
596
+ def parent_tree; end
597
+
598
+ def parent_tree=(_arg0); end
599
+
600
+ sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
601
+ def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
602
+
603
+ sig { params(node: RBI::Node).void }
604
+ def replace(node); end
605
+
606
+ sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
607
+ def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
608
+ end
609
+
610
+ class RBI::NodeWithComments < ::RBI::Node
611
+ abstract!
612
+
613
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
614
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
615
+
616
+ sig { returns(T::Array[RBI::Comment]) }
617
+ def comments; end
618
+
619
+ def comments=(_arg0); end
620
+
621
+ sig { override.params(other: RBI::Node).void }
622
+ def merge_with(other); end
623
+
624
+ sig { override.returns(T::Boolean) }
625
+ def oneline?; end
626
+ end
627
+
628
+ class RBI::OptParam < ::RBI::Param
629
+ sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::OptParam).void)).void }
630
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
631
+
632
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
633
+ def ==(other); end
634
+
635
+ sig { override.params(v: RBI::Printer).void }
636
+ def accept_printer(v); end
637
+
638
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
639
+ def print_comment_leading_space(v, last:); end
640
+
641
+ sig { returns(String) }
642
+ def value; end
643
+ end
644
+
645
+ class RBI::Param < ::RBI::NodeWithComments
646
+ abstract!
647
+
648
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
649
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
650
+
651
+ sig { override.params(v: RBI::Printer).void }
652
+ def accept_printer(v); end
653
+
654
+ sig { returns(T::Array[String]) }
655
+ def comments_lines; end
656
+
657
+ sig { returns(String) }
658
+ def name; end
659
+
660
+ sig { params(v: RBI::Printer, last: T::Boolean).void }
661
+ def print_comment_leading_space(v, last:); end
662
+
663
+ sig { override.returns(String) }
664
+ def to_s; end
665
+ end
666
+
667
+ class RBI::ParseError < ::StandardError
668
+ sig { params(message: String, location: RBI::Loc).void }
669
+ def initialize(message, location); end
670
+
671
+ sig { returns(RBI::Loc) }
672
+ def location; end
673
+ end
674
+
675
+ class RBI::Parser
676
+ sig { void }
677
+ def initialize; end
678
+
679
+ sig { params(path: String).returns(RBI::Tree) }
680
+ def parse_file(path); end
681
+
682
+ sig { params(string: String).returns(RBI::Tree) }
683
+ def parse_string(string); end
684
+
685
+ private
686
+
687
+ sig { params(content: String, file: String).returns(RBI::Tree) }
688
+ def parse(content, file:); end
689
+
690
+ class << self
691
+ sig { params(path: String).returns(RBI::Tree) }
692
+ def parse_file(path); end
693
+
694
+ sig { params(string: String).returns(RBI::Tree) }
695
+ def parse_string(string); end
696
+ end
697
+ end
698
+
699
+ class RBI::Printer < ::RBI::Visitor
700
+ sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
701
+ def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
702
+
703
+ sig { void }
704
+ def dedent; end
705
+
706
+ def in_visibility_group; end
707
+ def in_visibility_group=(_arg0); end
708
+
709
+ sig { void }
710
+ def indent; end
711
+
712
+ sig { returns(T.nilable(RBI::Node)) }
713
+ def previous_node; end
714
+
715
+ sig { params(string: String).void }
716
+ def print(string); end
717
+
718
+ sig { returns(T::Boolean) }
719
+ def print_locs; end
720
+
721
+ def print_locs=(_arg0); end
722
+
723
+ sig { params(string: String).void }
724
+ def printl(string); end
725
+
726
+ sig { params(string: T.nilable(String)).void }
727
+ def printn(string = T.unsafe(nil)); end
728
+
729
+ sig { params(string: T.nilable(String)).void }
730
+ def printt(string = T.unsafe(nil)); end
731
+
732
+ sig { override.params(node: T.nilable(RBI::Node)).void }
733
+ def visit(node); end
734
+
735
+ sig { override.params(nodes: T::Array[RBI::Node]).void }
736
+ def visit_all(nodes); end
737
+
738
+ sig { params(file: RBI::File).void }
739
+ def visit_file(file); end
740
+ end
741
+
742
+ class RBI::Private < ::RBI::Visibility
743
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Private).void)).void }
744
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
745
+ end
746
+
747
+ class RBI::Protected < ::RBI::Visibility
748
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Protected).void)).void }
749
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
750
+ end
751
+
752
+ class RBI::Public < ::RBI::Visibility
753
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Public).void)).void }
754
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
755
+ end
756
+
757
+ class RBI::ReqParam < ::RBI::Param
758
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::ReqParam).void)).void }
759
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
760
+
761
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
762
+ def ==(other); end
763
+ end
764
+
765
+ class RBI::RestParam < ::RBI::Param
766
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::RestParam).void)).void }
767
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
768
+
769
+ sig { params(other: T.nilable(Object)).returns(T::Boolean) }
770
+ def ==(other); end
771
+
772
+ sig { override.params(v: RBI::Printer).void }
773
+ def accept_printer(v); end
774
+
775
+ sig { override.params(v: RBI::Printer, last: T::Boolean).void }
776
+ def print_comment_leading_space(v, last:); end
777
+
778
+ sig { override.returns(String) }
779
+ def to_s; end
780
+ end
781
+
782
+ module RBI::Rewriters; end
783
+
784
+ class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor
785
+ sig { params(with_todo_comment: T::Boolean).void }
786
+ def initialize(with_todo_comment: T.unsafe(nil)); end
787
+
788
+ sig { override.params(node: T.nilable(RBI::Node)).void }
789
+ def visit(node); end
790
+
791
+ private
792
+
793
+ sig { params(attr: RBI::Attr).void }
794
+ def add_attr_sig(attr); end
795
+
796
+ sig { params(method: RBI::Method).void }
797
+ def add_method_sig(method); end
798
+
799
+ sig { params(node: RBI::NodeWithComments).void }
800
+ def add_todo_comment(node); end
801
+ end
802
+
803
+ class RBI::Rewriters::GroupNodes < ::RBI::Visitor
804
+ sig { override.params(node: T.nilable(RBI::Node)).void }
805
+ def visit(node); end
806
+ end
807
+
808
+ class RBI::Rewriters::Merge
809
+ sig { params(left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).void }
810
+ def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
811
+
812
+ sig { params(tree: RBI::Tree).returns(T::Array[RBI::Rewriters::Merge::Conflict]) }
813
+ def merge(tree); end
814
+
815
+ sig { returns(RBI::Tree) }
816
+ def tree; end
817
+
818
+ class << self
819
+ sig { params(left: RBI::Tree, right: RBI::Tree, left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).returns(RBI::Tree) }
820
+ def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
821
+ end
822
+ end
823
+
824
+ class RBI::Rewriters::Merge::Conflict < ::T::Struct
825
+ const :left, RBI::Node
826
+ const :left_name, String
827
+ const :right, RBI::Node
828
+ const :right_name, String
829
+
830
+ sig { returns(String) }
831
+ def to_s; end
832
+
833
+ class << self
834
+ def inherited(s); end
835
+ end
836
+ end
837
+
838
+ class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
839
+ sig { override.params(node: T.nilable(RBI::Node)).void }
840
+ def visit(node); end
841
+
842
+ sig { override.params(nodes: T::Array[RBI::Node]).void }
843
+ def visit_all(nodes); end
844
+
845
+ private
846
+
847
+ sig { params(left: RBI::Tree, right: RBI::Tree).void }
848
+ def merge_conflict_trees(left, right); end
849
+ end
850
+
851
+ class RBI::Rewriters::Merge::Keep < ::T::Enum
852
+ enums do
853
+ NONE = new
854
+ LEFT = new
855
+ RIGHT = new
856
+ end
857
+ end
858
+
859
+ class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
860
+ sig { params(output: RBI::Tree, left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).void }
861
+ def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
862
+
863
+ sig { returns(T::Array[RBI::Rewriters::Merge::Conflict]) }
864
+ def conflicts; end
865
+
866
+ sig { override.params(node: T.nilable(RBI::Node)).void }
867
+ def visit(node); end
868
+
869
+ private
870
+
871
+ sig { returns(RBI::Tree) }
872
+ def current_scope; end
873
+
874
+ sig { params(left: RBI::Scope, right: RBI::Scope).void }
875
+ def make_conflict_scope(left, right); end
876
+
877
+ sig { params(left: RBI::Node, right: RBI::Node).void }
878
+ def make_conflict_tree(left, right); end
879
+
880
+ sig { params(node: RBI::Node).returns(T.nilable(RBI::Node)) }
881
+ def previous_definition(node); end
882
+
883
+ sig { params(left: RBI::Scope, right: RBI::Scope).returns(RBI::Scope) }
884
+ def replace_scope_header(left, right); end
885
+ end
886
+
887
+ class RBI::Rewriters::NestNonPublicMethods < ::RBI::Visitor
888
+ sig { override.params(node: T.nilable(RBI::Node)).void }
889
+ def visit(node); end
890
+ end
891
+
892
+ class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor
893
+ sig { override.params(node: T.nilable(RBI::Node)).void }
894
+ def visit(node); end
895
+ end
896
+
897
+ class RBI::Rewriters::SortNodes < ::RBI::Visitor
898
+ sig { override.params(node: T.nilable(RBI::Node)).void }
899
+ def visit(node); end
900
+
901
+ private
902
+
903
+ sig { params(kind: RBI::Group::Kind).returns(Integer) }
904
+ def group_rank(kind); end
905
+
906
+ sig { params(node: RBI::Node).returns(T.nilable(String)) }
907
+ def node_name(node); end
908
+
909
+ sig { params(node: RBI::Node).returns(Integer) }
910
+ def node_rank(node); end
911
+ end
912
+
913
+ class RBI::Scope < ::RBI::Tree
914
+ include ::RBI::Indexable
915
+
916
+ abstract!
917
+
918
+ def initialize(*args, &blk); end
919
+
920
+ sig { override.params(v: RBI::Printer).void }
921
+ def accept_printer(v); end
922
+
923
+ sig { returns(T.self_type) }
924
+ def dup_empty; end
925
+
926
+ sig { abstract.returns(String) }
927
+ def fully_qualified_name; end
928
+
929
+ sig { override.returns(T::Array[String]) }
930
+ def index_ids; end
931
+
932
+ sig { params(v: RBI::Printer).void }
933
+ def print_body(v); end
934
+
935
+ sig { abstract.params(v: RBI::Printer).void }
936
+ def print_header(v); end
937
+
938
+ sig { override.returns(String) }
939
+ def to_s; end
940
+ end
941
+
942
+ class RBI::ScopeConflict < ::RBI::Tree
943
+ sig { params(left: RBI::Scope, right: RBI::Scope, left_name: String, right_name: String).void }
944
+ def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
945
+
946
+ sig { override.params(v: RBI::Printer).void }
947
+ def accept_printer(v); end
948
+
949
+ sig { returns(RBI::Scope) }
950
+ def left; end
951
+
952
+ sig { override.returns(T::Boolean) }
953
+ def oneline?; end
954
+
955
+ def right; end
956
+ end
957
+
958
+ class RBI::Sig < ::RBI::Node
959
+ sig { params(params: T::Array[RBI::SigParam], return_type: T.nilable(String), is_abstract: T::Boolean, is_override: T::Boolean, is_overridable: T::Boolean, type_params: T::Array[String], checked: T.nilable(Symbol), loc: T.nilable(RBI::Loc), block: T.nilable(T.proc.params(node: RBI::Sig).void)).void }
960
+ def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), &block); end
961
+
962
+ sig { params(param: RBI::SigParam).void }
963
+ def <<(param); end
964
+
965
+ sig { params(other: Object).returns(T::Boolean) }
966
+ def ==(other); end
967
+
968
+ sig { override.params(v: RBI::Printer).void }
969
+ def accept_printer(v); end
970
+
971
+ sig { returns(T.nilable(Symbol)) }
972
+ def checked; end
973
+
974
+ def checked=(_arg0); end
975
+
976
+ sig { returns(T::Boolean) }
977
+ def inline_params?; end
978
+
979
+ sig { returns(T::Boolean) }
980
+ def is_abstract; end
981
+
982
+ def is_abstract=(_arg0); end
983
+ def is_overridable; end
984
+ def is_overridable=(_arg0); end
985
+ def is_override; end
986
+ def is_override=(_arg0); end
987
+
988
+ sig { override.returns(T::Boolean) }
989
+ def oneline?; end
990
+
991
+ sig { returns(T::Array[RBI::SigParam]) }
992
+ def params; end
993
+
994
+ sig { returns(T.nilable(String)) }
995
+ def return_type; end
996
+
997
+ def return_type=(_arg0); end
998
+
999
+ sig { returns(T::Array[String]) }
1000
+ def type_params; end
1001
+ end
1002
+
1003
+ class RBI::SigBuilder < ::RBI::ASTVisitor
1004
+ sig { void }
1005
+ def initialize; end
1006
+
1007
+ sig { returns(RBI::Sig) }
1008
+ def current; end
1009
+
1010
+ def current=(_arg0); end
1011
+
1012
+ sig { override.params(node: T.nilable(AST::Node)).void }
1013
+ def visit(node); end
1014
+
1015
+ sig { params(node: AST::Node).void }
1016
+ def visit_send(node); end
1017
+
1018
+ class << self
1019
+ sig { params(node: AST::Node).returns(RBI::Sig) }
1020
+ def build(node); end
1021
+ end
1022
+ end
1023
+
1024
+ class RBI::SigParam < ::RBI::NodeWithComments
1025
+ sig { params(name: String, type: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::SigParam).void)).void }
1026
+ def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1027
+
1028
+ sig { params(other: Object).returns(T::Boolean) }
1029
+ def ==(other); end
1030
+
1031
+ sig { override.params(v: RBI::Printer).void }
1032
+ def accept_printer(v); end
1033
+
1034
+ sig { returns(T::Array[String]) }
1035
+ def comments_lines; end
1036
+
1037
+ sig { returns(String) }
1038
+ def name; end
1039
+
1040
+ sig { params(v: RBI::Printer, last: T::Boolean).void }
1041
+ def print_comment_leading_space(v, last:); end
1042
+
1043
+ def type; end
1044
+ end
1045
+
1046
+ class RBI::SingletonClass < ::RBI::Scope
1047
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::SingletonClass).void)).void }
1048
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1049
+
1050
+ sig { override.returns(String) }
1051
+ def fully_qualified_name; end
1052
+
1053
+ sig { override.params(v: RBI::Printer).void }
1054
+ def print_header(v); end
1055
+ end
1056
+
1057
+ class RBI::Struct < ::RBI::Scope
1058
+ sig { params(name: String, members: T::Array[Symbol], keyword_init: T::Boolean, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(struct: RBI::Struct).void)).void }
1059
+ def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1060
+
1061
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
1062
+ def compatible_with?(other); end
1063
+
1064
+ sig { override.returns(String) }
1065
+ def fully_qualified_name; end
1066
+
1067
+ sig { returns(T::Boolean) }
1068
+ def keyword_init; end
1069
+
1070
+ def keyword_init=(_arg0); end
1071
+
1072
+ sig { returns(T::Array[Symbol]) }
1073
+ def members; end
1074
+
1075
+ def members=(_arg0); end
1076
+
1077
+ sig { returns(String) }
1078
+ def name; end
1079
+
1080
+ def name=(_arg0); end
1081
+
1082
+ sig { override.params(v: RBI::Printer).void }
1083
+ def print_header(v); end
1084
+ end
1085
+
1086
+ class RBI::TEnum < ::RBI::Class
1087
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(klass: RBI::TEnum).void)).void }
1088
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1089
+ end
1090
+
1091
+ class RBI::TEnumBlock < ::RBI::NodeWithComments
1092
+ include ::RBI::Indexable
1093
+
1094
+ sig { params(names: T::Array[String], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TEnumBlock).void)).void }
1095
+ def initialize(names = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1096
+
1097
+ sig { params(name: String).void }
1098
+ def <<(name); end
1099
+
1100
+ sig { override.params(v: RBI::Printer).void }
1101
+ def accept_printer(v); end
1102
+
1103
+ sig { returns(T::Boolean) }
1104
+ def empty?; end
1105
+
1106
+ sig { override.returns(T::Array[String]) }
1107
+ def index_ids; end
1108
+
1109
+ sig { override.params(other: RBI::Node).void }
1110
+ def merge_with(other); end
1111
+
1112
+ sig { returns(T::Array[String]) }
1113
+ def names; end
1114
+
1115
+ sig { override.returns(String) }
1116
+ def to_s; end
1117
+ end
1118
+
1119
+ class RBI::TStruct < ::RBI::Class
1120
+ sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(klass: RBI::TStruct).void)).void }
1121
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1122
+ end
1123
+
1124
+ class RBI::TStructConst < ::RBI::TStructField
1125
+ include ::RBI::Indexable
1126
+
1127
+ sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TStructConst).void)).void }
1128
+ def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1129
+
1130
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
1131
+ def compatible_with?(other); end
1132
+
1133
+ sig { override.returns(T::Array[String]) }
1134
+ def fully_qualified_names; end
1135
+
1136
+ sig { override.returns(T::Array[String]) }
1137
+ def index_ids; end
1138
+
1139
+ sig { override.returns(String) }
1140
+ def to_s; end
1141
+ end
1142
+
1143
+ class RBI::TStructField < ::RBI::NodeWithComments
1144
+ abstract!
1145
+
1146
+ sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
1147
+ def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
1148
+
1149
+ sig { override.params(v: RBI::Printer).void }
1150
+ def accept_printer(v); end
1151
+
1152
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
1153
+ def compatible_with?(other); end
1154
+
1155
+ sig { returns(T.nilable(String)) }
1156
+ def default; end
1157
+
1158
+ def default=(_arg0); end
1159
+
1160
+ sig { abstract.returns(T::Array[String]) }
1161
+ def fully_qualified_names; end
1162
+
1163
+ sig { returns(String) }
1164
+ def name; end
1165
+
1166
+ def name=(_arg0); end
1167
+ def type; end
1168
+ def type=(_arg0); end
1169
+ end
1170
+
1171
+ class RBI::TStructProp < ::RBI::TStructField
1172
+ include ::RBI::Indexable
1173
+
1174
+ sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TStructProp).void)).void }
1175
+ def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1176
+
1177
+ sig { override.params(other: RBI::Node).returns(T::Boolean) }
1178
+ def compatible_with?(other); end
1179
+
1180
+ sig { override.returns(T::Array[String]) }
1181
+ def fully_qualified_names; end
1182
+
1183
+ sig { override.returns(T::Array[String]) }
1184
+ def index_ids; end
1185
+
1186
+ sig { override.returns(String) }
1187
+ def to_s; end
1188
+ end
1189
+
1190
+ class RBI::Tree < ::RBI::NodeWithComments
1191
+ sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Tree).void)).void }
1192
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1193
+
1194
+ sig { params(node: RBI::Node).void }
1195
+ def <<(node); end
1196
+
1197
+ sig { override.params(v: RBI::Printer).void }
1198
+ def accept_printer(v); end
1199
+
1200
+ sig { params(with_todo_comment: T::Boolean).void }
1201
+ def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
1202
+
1203
+ sig { params(name: String, superclass_name: T.nilable(String), block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
1204
+ def create_class(name, superclass_name: T.unsafe(nil), &block); end
1205
+
1206
+ sig { params(name: String, value: String).void }
1207
+ def create_constant(name, value:); end
1208
+
1209
+ sig { params(name: String).void }
1210
+ def create_extend(name); end
1211
+
1212
+ sig { params(name: String).void }
1213
+ def create_include(name); end
1214
+
1215
+ sig { params(name: String, parameters: T::Array[RBI::TypedParam], return_type: String, class_method: T::Boolean).void }
1216
+ def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil)); end
1217
+
1218
+ sig { params(name: String).void }
1219
+ def create_mixes_in_class_methods(name); end
1220
+
1221
+ sig { params(name: String, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
1222
+ def create_module(name, &block); end
1223
+
1224
+ sig { params(constant: Module, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
1225
+ def create_path(constant, &block); end
1226
+
1227
+ sig { params(name: String, value: String).void }
1228
+ def create_type_member(name, value: T.unsafe(nil)); end
1229
+
1230
+ sig { returns(T::Boolean) }
1231
+ def empty?; end
1232
+
1233
+ sig { void }
1234
+ def group_nodes!; end
1235
+
1236
+ sig { returns(RBI::Index) }
1237
+ def index; end
1238
+
1239
+ sig { params(other: RBI::Tree).returns(RBI::Tree) }
1240
+ def merge(other); end
1241
+
1242
+ sig { void }
1243
+ def nest_non_public_methods!; end
1244
+
1245
+ sig { void }
1246
+ def nest_singleton_methods!; end
1247
+
1248
+ sig { returns(T::Array[RBI::Node]) }
1249
+ def nodes; end
1250
+
1251
+ sig { override.returns(T::Boolean) }
1252
+ def oneline?; end
1253
+
1254
+ sig { void }
1255
+ def sort_nodes!; end
1256
+
1257
+ private
1258
+
1259
+ sig { params(node: RBI::Node).returns(RBI::Node) }
1260
+ def create_node(node); end
1261
+
1262
+ sig { returns(T::Hash[String, RBI::Node]) }
1263
+ def nodes_cache; end
1264
+
1265
+ sig { params(name: String).returns(T::Boolean) }
1266
+ def valid_method_name?(name); end
1267
+ end
1268
+
1269
+ RBI::Tree::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
1270
+
1271
+ class RBI::TreeBuilder < ::RBI::ASTVisitor
1272
+ sig { params(file: String, comments: T::Hash[Parser::Source::Map, T::Array[Parser::Source::Comment]]).void }
1273
+ def initialize(file:, comments: T.unsafe(nil)); end
1274
+
1275
+ sig { params(comments: T::Array[Parser::Source::Comment]).void }
1276
+ def assoc_dangling_comments(comments); end
1277
+
1278
+ sig { void }
1279
+ def separate_header_comments; end
1280
+
1281
+ sig { returns(RBI::Tree) }
1282
+ def tree; end
1283
+
1284
+ sig { override.params(node: T.nilable(Object)).void }
1285
+ def visit(node); end
1286
+
1287
+ private
1288
+
1289
+ sig { returns(RBI::Tree) }
1290
+ def current_scope; end
1291
+
1292
+ sig { returns(T::Array[RBI::Sig]) }
1293
+ def current_sigs; end
1294
+
1295
+ sig { params(node: AST::Node).returns(T::Array[RBI::Comment]) }
1296
+ def node_comments(node); end
1297
+
1298
+ sig { params(node: AST::Node).returns(RBI::Loc) }
1299
+ def node_loc(node); end
1300
+
1301
+ sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
1302
+ def parse_block(node); end
1303
+
1304
+ sig { params(node: AST::Node).returns(RBI::Node) }
1305
+ def parse_const_assign(node); end
1306
+
1307
+ sig { params(node: AST::Node).returns(RBI::Method) }
1308
+ def parse_def(node); end
1309
+
1310
+ sig { params(node: AST::Node).returns(RBI::TEnumBlock) }
1311
+ def parse_enum(node); end
1312
+
1313
+ sig { params(node: AST::Node).returns(RBI::Param) }
1314
+ def parse_param(node); end
1315
+
1316
+ sig { params(node: AST::Node).returns(RBI::Scope) }
1317
+ def parse_scope(node); end
1318
+
1319
+ sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
1320
+ def parse_send(node); end
1321
+
1322
+ sig { params(node: AST::Node).returns(RBI::Sig) }
1323
+ def parse_sig(node); end
1324
+
1325
+ sig { params(node: AST::Node).returns(RBI::Struct) }
1326
+ def parse_struct(node); end
1327
+
1328
+ sig { params(node: AST::Node).returns([String, String, T.nilable(String)]) }
1329
+ def parse_tstruct_prop(node); end
1330
+
1331
+ sig { params(node: AST::Node).returns(T::Boolean) }
1332
+ def struct_definition?(node); end
1333
+ end
1334
+
1335
+ class RBI::TypeMember < ::RBI::NodeWithComments
1336
+ sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TypeMember).void)).void }
1337
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
1338
+
1339
+ sig { override.params(v: RBI::Printer).void }
1340
+ def accept_printer(v); end
1341
+
1342
+ sig { returns(String) }
1343
+ def fully_qualified_name; end
1344
+
1345
+ sig { returns(String) }
1346
+ def name; end
1347
+
1348
+ sig { override.returns(String) }
1349
+ def to_s; end
1350
+
1351
+ def value; end
1352
+ end
1353
+
1354
+ RBI::VERSION = T.let(T.unsafe(nil), String)
1355
+
1356
+ class RBI::Visibility < ::RBI::NodeWithComments
1357
+ abstract!
1358
+
1359
+ sig { params(visibility: Symbol, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
1360
+ def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
1361
+
1362
+ sig { params(other: RBI::Visibility).returns(T::Boolean) }
1363
+ def ==(other); end
1364
+
1365
+ sig { override.params(v: RBI::Printer).void }
1366
+ def accept_printer(v); end
1367
+
1368
+ sig { returns(T::Boolean) }
1369
+ def private?; end
1370
+
1371
+ sig { returns(T::Boolean) }
1372
+ def protected?; end
1373
+
1374
+ sig { returns(T::Boolean) }
1375
+ def public?; end
1376
+
1377
+ sig { returns(Symbol) }
1378
+ def visibility; end
1379
+ end
1380
+
1381
+ class RBI::VisibilityGroup < ::RBI::Tree
1382
+ sig { params(visibility: RBI::Visibility).void }
1383
+ def initialize(visibility); end
1384
+
1385
+ sig { override.params(v: RBI::Printer).void }
1386
+ def accept_printer(v); end
1387
+
1388
+ sig { override.returns(T::Boolean) }
1389
+ def oneline?; end
1390
+
1391
+ sig { returns(RBI::Visibility) }
1392
+ def visibility; end
1393
+ end
1394
+
1395
+ class RBI::Visitor
1396
+ abstract!
1397
+
1398
+ def initialize(*args, &blk); end
1399
+
1400
+ sig { abstract.params(node: T.nilable(RBI::Node)).void }
1401
+ def visit(node); end
1402
+
1403
+ sig { params(nodes: T::Array[RBI::Node]).void }
1404
+ def visit_all(nodes); end
1405
+ end