muina 0.2.8 → 0.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (161) hide show
  1. checksums.yaml +4 -4
  2. data/LICENSE +25 -0
  3. data/README.md +0 -35
  4. data/lib/muina/maybe/none.rb +61 -0
  5. data/lib/muina/maybe/some.rb +62 -0
  6. data/lib/muina/maybe.rb +13 -0
  7. data/lib/muina/result/failure.rb +7 -18
  8. data/lib/muina/result/success.rb +7 -18
  9. data/lib/muina/result.rb +6 -8
  10. data/lib/muina/version.rb +1 -2
  11. data/lib/muina.rb +0 -32
  12. metadata +24 -225
  13. data/.github/workflows/main.yml +0 -16
  14. data/.gitignore +0 -5
  15. data/.mutant.yml +0 -38
  16. data/.rspec +0 -4
  17. data/.rubocop.yml +0 -181
  18. data/.ruby-version +0 -1
  19. data/.simplecov +0 -14
  20. data/CHANGELOG.md +0 -38
  21. data/Gemfile +0 -34
  22. data/Gemfile.lock +0 -265
  23. data/Guardfile +0 -24
  24. data/Rakefile +0 -13
  25. data/SECURITY.md +0 -14
  26. data/bin/bundle +0 -114
  27. data/bin/console +0 -15
  28. data/bin/flay +0 -29
  29. data/bin/flog +0 -29
  30. data/bin/guard +0 -29
  31. data/bin/irb +0 -29
  32. data/bin/lefthook +0 -29
  33. data/bin/mutant +0 -29
  34. data/bin/parlour +0 -29
  35. data/bin/rake +0 -29
  36. data/bin/rspec +0 -29
  37. data/bin/rubocop +0 -29
  38. data/bin/setup +0 -8
  39. data/bin/srb +0 -29
  40. data/bin/srb-rbi +0 -29
  41. data/bin/tapioca +0 -29
  42. data/exe/muina +0 -11
  43. data/lefthook.yml +0 -39
  44. data/lib/muina/action/params_factory.rb +0 -17
  45. data/lib/muina/action/step/command.rb +0 -33
  46. data/lib/muina/action/step/failure.rb +0 -18
  47. data/lib/muina/action/step/query.rb +0 -35
  48. data/lib/muina/action/step/result.rb +0 -56
  49. data/lib/muina/action/step.rb +0 -13
  50. data/lib/muina/action.rb +0 -73
  51. data/lib/muina/any.rb +0 -7
  52. data/lib/muina/classes.rb +0 -7
  53. data/lib/muina/deprecator.rb +0 -93
  54. data/lib/muina/entity.rb +0 -20
  55. data/lib/muina/module.rb +0 -6
  56. data/lib/muina/parameters.rb +0 -7
  57. data/lib/muina/params.rb +0 -19
  58. data/lib/muina/private_creation.rb +0 -12
  59. data/lib/muina/result/factory.rb +0 -37
  60. data/lib/muina/result/null.rb +0 -25
  61. data/lib/muina/service.rb +0 -25
  62. data/lib/muina/symbol_hash.rb +0 -7
  63. data/lib/muina/unit.rb +0 -10
  64. data/lib/muina/untyped_array.rb +0 -7
  65. data/lib/muina/untyped_hash.rb +0 -7
  66. data/lib/muina/value.rb +0 -24
  67. data/muina.gemspec +0 -35
  68. data/rbi/muina.rbi +0 -311
  69. data/sorbet/config +0 -2
  70. data/sorbet/rbi/gems/actionpack@6.1.4.rbi +0 -5045
  71. data/sorbet/rbi/gems/actionview@6.1.4.rbi +0 -2416
  72. data/sorbet/rbi/gems/activesupport@6.1.4.rbi +0 -3778
  73. data/sorbet/rbi/gems/ast@2.4.2.rbi +0 -54
  74. data/sorbet/rbi/gems/awesome_print@1.9.2.rbi +0 -322
  75. data/sorbet/rbi/gems/builder@3.2.4.rbi +0 -8
  76. data/sorbet/rbi/gems/byebug@11.1.3.rbi +0 -18
  77. data/sorbet/rbi/gems/coderay@1.1.3.rbi +0 -8
  78. data/sorbet/rbi/gems/colorize@0.8.1.rbi +0 -39
  79. data/sorbet/rbi/gems/commander@4.6.0.rbi +0 -8
  80. data/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi +0 -2403
  81. data/sorbet/rbi/gems/crass@1.0.6.rbi +0 -123
  82. data/sorbet/rbi/gems/diff-lcs@1.4.4.rbi +0 -185
  83. data/sorbet/rbi/gems/docile@1.4.0.rbi +0 -54
  84. data/sorbet/rbi/gems/erubi@1.10.0.rbi +0 -36
  85. data/sorbet/rbi/gems/erubis@2.7.0.rbi +0 -8
  86. data/sorbet/rbi/gems/faker@2.18.0.rbi +0 -2469
  87. data/sorbet/rbi/gems/ffi@1.15.3.rbi +0 -8
  88. data/sorbet/rbi/gems/flay@2.12.1.rbi +0 -178
  89. data/sorbet/rbi/gems/flog@4.6.4.rbi +0 -70
  90. data/sorbet/rbi/gems/formatador@0.3.0.rbi +0 -8
  91. data/sorbet/rbi/gems/guard-compat@1.2.1.rbi +0 -49
  92. data/sorbet/rbi/gems/guard-rspec@4.7.3.rbi +0 -233
  93. data/sorbet/rbi/gems/guard-rubocop@1.4.0.rbi +0 -66
  94. data/sorbet/rbi/gems/guard-shell@0.7.2.rbi +0 -69
  95. data/sorbet/rbi/gems/guard@2.18.0.rbi +0 -617
  96. data/sorbet/rbi/gems/highline@2.0.3.rbi +0 -8
  97. data/sorbet/rbi/gems/i18n@1.8.10.rbi +0 -616
  98. data/sorbet/rbi/gems/io-console@0.5.9.rbi +0 -8
  99. data/sorbet/rbi/gems/irb@1.3.6.rbi +0 -452
  100. data/sorbet/rbi/gems/lefthook@0.7.6.rbi +0 -8
  101. data/sorbet/rbi/gems/listen@3.6.0.rbi +0 -476
  102. data/sorbet/rbi/gems/loofah@2.10.0.rbi +0 -223
  103. data/sorbet/rbi/gems/lumberjack@1.2.8.rbi +0 -431
  104. data/sorbet/rbi/gems/method_source@1.0.0.rbi +0 -8
  105. data/sorbet/rbi/gems/minitest@5.14.4.rbi +0 -344
  106. data/sorbet/rbi/gems/mutant-license@0.1.1.1.4043027289354708743625974235631451632228.0.rbi +0 -8
  107. data/sorbet/rbi/gems/mutant-rspec@0.10.32.rbi +0 -8
  108. data/sorbet/rbi/gems/mutant@0.10.32.rbi +0 -4154
  109. data/sorbet/rbi/gems/nenv@0.3.0.rbi +0 -88
  110. data/sorbet/rbi/gems/nokogiri@1.11.7.rbi +0 -1422
  111. data/sorbet/rbi/gems/notiffany@0.1.3.rbi +0 -331
  112. data/sorbet/rbi/gems/parallel@1.20.1.rbi +0 -113
  113. data/sorbet/rbi/gems/parlour@6.0.1.rbi +0 -1726
  114. data/sorbet/rbi/gems/parser@3.0.2.0.rbi +0 -1683
  115. data/sorbet/rbi/gems/path_expander@1.1.0.rbi +0 -24
  116. data/sorbet/rbi/gems/polyfill@1.9.0.rbi +0 -393
  117. data/sorbet/rbi/gems/pry@0.14.1.rbi +0 -8
  118. data/sorbet/rbi/gems/racc@1.5.2.rbi +0 -47
  119. data/sorbet/rbi/gems/rack-test@1.1.0.rbi +0 -272
  120. data/sorbet/rbi/gems/rack@2.2.3.rbi +0 -1618
  121. data/sorbet/rbi/gems/rails-dom-testing@2.0.3.rbi +0 -92
  122. data/sorbet/rbi/gems/rails-html-sanitizer@1.3.0.rbi +0 -183
  123. data/sorbet/rbi/gems/rainbow@3.0.0.rbi +0 -153
  124. data/sorbet/rbi/gems/rake@13.0.6.rbi +0 -808
  125. data/sorbet/rbi/gems/rb-fsevent@0.11.0.rbi +0 -8
  126. data/sorbet/rbi/gems/rb-inotify@0.10.1.rbi +0 -8
  127. data/sorbet/rbi/gems/regexp_parser@2.1.1.rbi +0 -1120
  128. data/sorbet/rbi/gems/reline@0.2.6.rbi +0 -662
  129. data/sorbet/rbi/gems/rexml@3.2.5.rbi +0 -672
  130. data/sorbet/rbi/gems/rspec-core@3.10.1.rbi +0 -2509
  131. data/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi +0 -1574
  132. data/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi +0 -1462
  133. data/sorbet/rbi/gems/rspec-support@3.10.2.rbi +0 -509
  134. data/sorbet/rbi/gems/rspec@3.10.0.rbi +0 -38
  135. data/sorbet/rbi/gems/rubocop-ast@1.8.0.rbi +0 -2194
  136. data/sorbet/rbi/gems/rubocop-performance@1.11.4.rbi +0 -899
  137. data/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi +0 -118
  138. data/sorbet/rbi/gems/rubocop-rspec@2.4.0.rbi +0 -1805
  139. data/sorbet/rbi/gems/rubocop-sorbet@0.6.2.rbi +0 -288
  140. data/sorbet/rbi/gems/rubocop@1.18.4.rbi +0 -13197
  141. data/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi +0 -405
  142. data/sorbet/rbi/gems/ruby_parser@3.16.0.rbi +0 -4528
  143. data/sorbet/rbi/gems/safe_type@1.1.1.rbi +0 -157
  144. data/sorbet/rbi/gems/sexp_processor@4.15.3.rbi +0 -359
  145. data/sorbet/rbi/gems/shellany@0.0.1.rbi +0 -28
  146. data/sorbet/rbi/gems/simplecov-html@0.12.3.rbi +0 -89
  147. data/sorbet/rbi/gems/simplecov@0.21.2.rbi +0 -577
  148. data/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi +0 -8
  149. data/sorbet/rbi/gems/sorbet-coerce@0.5.0.rbi +0 -42
  150. data/sorbet/rbi/gems/sorbet-rails@0.7.4.rbi +0 -8
  151. data/sorbet/rbi/gems/sorbet-struct-comparable@1.1.0.rbi +0 -17
  152. data/sorbet/rbi/gems/spoom@1.1.1.rbi +0 -1193
  153. data/sorbet/rbi/gems/tapioca@0.4.23.rbi +0 -1826
  154. data/sorbet/rbi/gems/thor@1.1.0.rbi +0 -838
  155. data/sorbet/rbi/gems/tzinfo@2.0.4.rbi +0 -856
  156. data/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi +0 -26
  157. data/sorbet/rbi/gems/unparser@0.6.0.rbi +0 -2037
  158. data/sorbet/rbi/gems/zeitwerk@2.4.2.rbi +0 -173
  159. data/sorbet/rbi/todo.rbi +0 -8
  160. data/sorbet/rbi/typed_params.rbi +0 -7
  161. data/sorbet/tapioca/require.rb +0 -16
@@ -1,2194 +0,0 @@
1
- # DO NOT EDIT MANUALLY
2
- # This is an autogenerated file for types exported from the `rubocop-ast` gem.
3
- # Please instead update this file by running `bin/tapioca sync`.
4
-
5
- # typed: true
6
-
7
- class AST::Node
8
- def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
9
-
10
- def +(array); end
11
- def <<(element); end
12
- def ==(other); end
13
- def append(element); end
14
- def children; end
15
- def clone; end
16
- def concat(array); end
17
- def deconstruct; end
18
- def dup; end
19
- def eql?(other); end
20
- def hash; end
21
- def inspect(indent = T.unsafe(nil)); end
22
- def to_a; end
23
- def to_ast; end
24
- def to_s(indent = T.unsafe(nil)); end
25
- def to_sexp(indent = T.unsafe(nil)); end
26
- def to_sexp_array; end
27
- def type; end
28
- def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
29
-
30
- protected
31
-
32
- def assign_properties(properties); end
33
- def fancy_type; end
34
-
35
- private
36
-
37
- def original_dup; end
38
- end
39
-
40
- class Parser::AST::Node < ::AST::Node
41
- def assign_properties(properties); end
42
- def loc; end
43
- def location; end
44
- end
45
-
46
- class Parser::Builders::Default
47
- def initialize; end
48
-
49
- def __ENCODING__(__ENCODING__t); end
50
- def __FILE__(__FILE__t); end
51
- def __LINE__(__LINE__t); end
52
- def accessible(node); end
53
- def alias(alias_t, to, from); end
54
- def arg(name_t); end
55
- def arg_expr(expr); end
56
- def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
57
- def array(begin_t, elements, end_t); end
58
- def array_pattern(lbrack_t, elements, rbrack_t); end
59
- def assign(lhs, eql_t, rhs); end
60
- def assignable(node); end
61
- def associate(begin_t, pairs, end_t); end
62
- def attr_asgn(receiver, dot_t, selector_t); end
63
- def back_ref(token); end
64
- def begin(begin_t, body, end_t); end
65
- def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
66
- def begin_keyword(begin_t, body, end_t); end
67
- def binary_op(receiver, operator_t, arg); end
68
- def block(method_call, begin_t, args, body, end_t); end
69
- def block_pass(amper_t, arg); end
70
- def blockarg(amper_t, name_t); end
71
- def blockarg_expr(amper_t, expr); end
72
- def call_lambda(lambda_t); end
73
- def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
74
- def call_type_for_dot(dot_t); end
75
- def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
76
- def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
77
- def character(char_t); end
78
- def complex(complex_t); end
79
- def compstmt(statements); end
80
- def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
81
- def condition_mod(if_true, if_false, cond_t, cond); end
82
- def const(name_t); end
83
- def const_fetch(scope, t_colon2, name_t); end
84
- def const_global(t_colon3, name_t); end
85
- def const_op_assignable(node); end
86
- def const_pattern(const, ldelim_t, pattern, rdelim_t); end
87
- def cvar(token); end
88
- def dedent_string(node, dedent_level); end
89
- def def_class(class_t, name, lt_t, superclass, body, end_t); end
90
- def def_endless_method(def_t, name_t, args, assignment_t, body); end
91
- def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
92
- def def_method(def_t, name_t, args, body, end_t); end
93
- def def_module(module_t, name, body, end_t); end
94
- def def_sclass(class_t, lshft_t, expr, body, end_t); end
95
- def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
96
- def emit_file_line_as_literals; end
97
- def emit_file_line_as_literals=(_arg0); end
98
- def false(false_t); end
99
- def find_pattern(lbrack_t, elements, rbrack_t); end
100
- def float(float_t); end
101
- def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
102
- def forward_arg(dots_t); end
103
- def forward_only_args(begin_t, dots_t, end_t); end
104
- def forwarded_args(dots_t); end
105
- def gvar(token); end
106
- def hash_pattern(lbrace_t, kwargs, rbrace_t); end
107
- def ident(token); end
108
- def if_guard(if_t, if_body); end
109
- def in_match(lhs, in_t, rhs); end
110
- def in_pattern(in_t, pattern, guard, then_t, body); end
111
- def index(receiver, lbrack_t, indexes, rbrack_t); end
112
- def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
113
- def integer(integer_t); end
114
- def ivar(token); end
115
- def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
116
- def kwarg(name_t); end
117
- def kwnilarg(dstar_t, nil_t); end
118
- def kwoptarg(name_t, value); end
119
- def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
120
- def kwsplat(dstar_t, arg); end
121
- def logical_op(type, lhs, op_t, rhs); end
122
- def loop(type, keyword_t, cond, do_t, body, end_t); end
123
- def loop_mod(type, body, keyword_t, cond); end
124
- def match_alt(left, pipe_t, right); end
125
- def match_as(value, assoc_t, as); end
126
- def match_hash_var(name_t); end
127
- def match_hash_var_from_str(begin_t, strings, end_t); end
128
- def match_label(label_type, label); end
129
- def match_nil_pattern(dstar_t, nil_t); end
130
- def match_op(receiver, match_t, arg); end
131
- def match_pair(label_type, label, value); end
132
- def match_pattern(lhs, match_t, rhs); end
133
- def match_pattern_p(lhs, match_t, rhs); end
134
- def match_rest(star_t, name_t = T.unsafe(nil)); end
135
- def match_var(name_t); end
136
- def match_with_trailing_comma(match, comma_t); end
137
- def multi_assign(lhs, eql_t, rhs); end
138
- def multi_lhs(begin_t, items, end_t); end
139
- def nil(nil_t); end
140
- def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
141
- def nth_ref(token); end
142
- def numargs(max_numparam); end
143
- def objc_kwarg(kwname_t, assoc_t, name_t); end
144
- def objc_restarg(star_t, name = T.unsafe(nil)); end
145
- def objc_varargs(pair, rest_of_varargs); end
146
- def op_assign(lhs, op_t, rhs); end
147
- def optarg(name_t, eql_t, value); end
148
- def pair(key, assoc_t, value); end
149
- def pair_keyword(key_t, value); end
150
- def pair_list_18(list); end
151
- def pair_quoted(begin_t, parts, end_t, value); end
152
- def parser; end
153
- def parser=(_arg0); end
154
- def pin(pin_t, var); end
155
- def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
156
- def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
157
- def procarg0(arg); end
158
- def range_exclusive(lhs, dot3_t, rhs); end
159
- def range_inclusive(lhs, dot2_t, rhs); end
160
- def rational(rational_t); end
161
- def regexp_compose(begin_t, parts, end_t, options); end
162
- def regexp_options(regopt_t); end
163
- def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
164
- def restarg(star_t, name_t = T.unsafe(nil)); end
165
- def restarg_expr(star_t, expr = T.unsafe(nil)); end
166
- def self(token); end
167
- def shadowarg(name_t); end
168
- def splat(star_t, arg = T.unsafe(nil)); end
169
- def string(string_t); end
170
- def string_compose(begin_t, parts, end_t); end
171
- def string_internal(string_t); end
172
- def symbol(symbol_t); end
173
- def symbol_compose(begin_t, parts, end_t); end
174
- def symbol_internal(symbol_t); end
175
- def symbols_compose(begin_t, parts, end_t); end
176
- def ternary(cond, question_t, if_true, colon_t, if_false); end
177
- def true(true_t); end
178
- def unary_num(unary_t, numeric); end
179
- def unary_op(op_t, receiver); end
180
- def undef_method(undef_t, names); end
181
- def unless_guard(unless_t, unless_body); end
182
- def when(when_t, patterns, then_t, body); end
183
- def word(parts); end
184
- def words_compose(begin_t, parts, end_t); end
185
- def xstring_compose(begin_t, parts, end_t); end
186
-
187
- private
188
-
189
- def arg_name_collides?(this_name, that_name); end
190
- def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
191
- def binary_op_map(left_e, op_t, right_e); end
192
- def block_map(receiver_l, begin_t, end_t); end
193
- def check_assignment_to_numparam(name, loc); end
194
- def check_condition(cond); end
195
- def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
196
- def check_duplicate_args(args, map = T.unsafe(nil)); end
197
- def check_duplicate_pattern_key(name, loc); end
198
- def check_duplicate_pattern_variable(name, loc); end
199
- def check_lvar_name(name, loc); end
200
- def check_reserved_for_numparam(name, loc); end
201
- def collapse_string_parts?(parts); end
202
- def collection_map(begin_t, parts, end_t); end
203
- def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
204
- def constant_map(scope, colon2_t, name_t); end
205
- def definition_map(keyword_t, operator_t, name_t, end_t); end
206
- def delimited_string_map(string_t); end
207
- def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
208
- def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
209
- def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
210
- def expr_map(loc); end
211
- def for_map(keyword_t, in_t, begin_t, end_t); end
212
- def guard_map(keyword_t, guard_body_e); end
213
- def index_map(receiver_e, lbrack_t, rbrack_t); end
214
- def join_exprs(left_expr, right_expr); end
215
- def keyword_map(keyword_t, begin_t, args, end_t); end
216
- def keyword_mod_map(pre_e, keyword_t, post_e); end
217
- def kwarg_map(name_t, value_e = T.unsafe(nil)); end
218
- def kwargs?(node); end
219
- def loc(token); end
220
- def module_definition_map(keyword_t, name_e, operator_t, end_t); end
221
- def n(type, children, source_map); end
222
- def n0(type, source_map); end
223
- def numeric(kind, token); end
224
- def pair_keyword_map(key_t, value_e); end
225
- def pair_quoted_map(begin_t, end_t, value_e); end
226
- def prefix_string_map(symbol); end
227
- def range_map(start_e, op_t, end_e); end
228
- def regexp_map(begin_t, end_t, options_e); end
229
- def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
230
- def rewrite_hash_args_to_kwargs(args); end
231
- def send_binary_op_map(lhs_e, selector_t, rhs_e); end
232
- def send_index_map(receiver_e, lbrack_t, rbrack_t); end
233
- def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
234
- def send_unary_op_map(selector_t, arg_e); end
235
- def static_regexp(parts, options); end
236
- def static_regexp_node(node); end
237
- def static_string(nodes); end
238
- def string_map(begin_t, parts, end_t); end
239
- def string_value(token); end
240
- def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
241
- def token_map(token); end
242
- def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
243
- def unquoted_map(token); end
244
- def validate_definee(definee); end
245
- def value(token); end
246
- def var_send_map(variable_e); end
247
- def variable_map(name_t); end
248
-
249
- class << self
250
- def emit_arg_inside_procarg0; end
251
- def emit_arg_inside_procarg0=(_arg0); end
252
- def emit_encoding; end
253
- def emit_encoding=(_arg0); end
254
- def emit_forward_arg; end
255
- def emit_forward_arg=(_arg0); end
256
- def emit_index; end
257
- def emit_index=(_arg0); end
258
- def emit_kwargs; end
259
- def emit_kwargs=(_arg0); end
260
- def emit_lambda; end
261
- def emit_lambda=(_arg0); end
262
- def emit_match_pattern; end
263
- def emit_match_pattern=(_arg0); end
264
- def emit_procarg0; end
265
- def emit_procarg0=(_arg0); end
266
- def modernize; end
267
- end
268
- end
269
-
270
- module RuboCop; end
271
-
272
- module RuboCop::AST
273
- extend ::RuboCop::AST::RuboCopCompatibility
274
- end
275
-
276
- class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
277
- def new_identifier; end
278
- def old_identifier; end
279
- end
280
-
281
- class RuboCop::AST::AndNode < ::RuboCop::AST::Node
282
- include ::RuboCop::AST::BinaryOperatorNode
283
- include ::RuboCop::AST::PredicateOperatorNode
284
-
285
- def alternate_operator; end
286
- def inverse_operator; end
287
- end
288
-
289
- class RuboCop::AST::ArgNode < ::RuboCop::AST::Node
290
- def default?; end
291
- def default_value; end
292
- def name; end
293
- end
294
-
295
- class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
296
- include ::RuboCop::AST::CollectionNode
297
-
298
- def argument_list; end
299
- def empty_and_without_delimiters?; end
300
- end
301
-
302
- class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
303
- def bracketed?; end
304
- def each_value(&block); end
305
- def percent_literal?(type = T.unsafe(nil)); end
306
- def square_brackets?; end
307
- def values; end
308
- end
309
-
310
- RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
311
-
312
- module RuboCop::AST::BasicLiteralNode
313
- def value; end
314
- end
315
-
316
- module RuboCop::AST::BinaryOperatorNode
317
- def conditions; end
318
- def lhs; end
319
- def rhs; end
320
- end
321
-
322
- class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
323
- include ::RuboCop::AST::MethodIdentifierPredicates
324
-
325
- def argument_list; end
326
- def arguments; end
327
- def arguments?; end
328
- def body; end
329
- def braces?; end
330
- def closing_delimiter; end
331
- def delimiters; end
332
- def keywords?; end
333
- def lambda?; end
334
- def method_name; end
335
- def multiline?; end
336
- def opening_delimiter; end
337
- def send_node; end
338
- def single_line?; end
339
- def void_context?; end
340
-
341
- private
342
-
343
- def numbered_arguments; end
344
- end
345
-
346
- RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
347
-
348
- class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
349
- include ::RuboCop::AST::ParameterizedNode
350
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
351
- end
352
-
353
- class RuboCop::AST::Builder < ::Parser::Builders::Default
354
- def n(type, children, source_map); end
355
- def string_value(token); end
356
-
357
- private
358
-
359
- def node_klass(type); end
360
- end
361
-
362
- RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
363
-
364
- class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
365
- include ::RuboCop::AST::ConditionalNode
366
-
367
- def branches; end
368
- def each_in_pattern(&block); end
369
- def else?; end
370
- def else_branch; end
371
- def in_pattern_branches; end
372
- def keyword; end
373
- end
374
-
375
- class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
376
- include ::RuboCop::AST::ConditionalNode
377
-
378
- def branches; end
379
- def each_when(&block); end
380
- def else?; end
381
- def else_branch; end
382
- def keyword; end
383
- def when_branches; end
384
- end
385
-
386
- class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
387
- def body; end
388
- def identifier; end
389
- def parent_class; end
390
- end
391
-
392
- module RuboCop::AST::CollectionNode
393
- extend ::Forwardable
394
-
395
- def &(*args, &block); end
396
- def *(*args, &block); end
397
- def +(*args, &block); end
398
- def -(*args, &block); end
399
- def <<(*args, &block); end
400
- def [](*args, &block); end
401
- def []=(*args, &block); end
402
- def all?(*args, &block); end
403
- def any?(*args, &block); end
404
- def append(*args, &block); end
405
- def assoc(*args, &block); end
406
- def at(*args, &block); end
407
- def bsearch(*args, &block); end
408
- def bsearch_index(*args, &block); end
409
- def chain(*args, &block); end
410
- def chunk(*args, &block); end
411
- def chunk_while(*args, &block); end
412
- def clear(*args, &block); end
413
- def collect(*args, &block); end
414
- def collect!(*args, &block); end
415
- def collect_concat(*args, &block); end
416
- def combination(*args, &block); end
417
- def compact(*args, &block); end
418
- def compact!(*args, &block); end
419
- def concat(*args, &block); end
420
- def count(*args, &block); end
421
- def cycle(*args, &block); end
422
- def delete(*args, &block); end
423
- def delete_at(*args, &block); end
424
- def delete_eql(*args, &block); end
425
- def delete_if(*args, &block); end
426
- def detect(*args, &block); end
427
- def difference(*args, &block); end
428
- def dig(*args, &block); end
429
- def drop(*args, &block); end
430
- def drop_while(*args, &block); end
431
- def each(*args, &block); end
432
- def each_cons(*args, &block); end
433
- def each_entry(*args, &block); end
434
- def each_index(*args, &block); end
435
- def each_slice(*args, &block); end
436
- def each_with_index(*args, &block); end
437
- def each_with_object(*args, &block); end
438
- def empty?(*args, &block); end
439
- def entries(*args, &block); end
440
- def extract_options!(*args, &block); end
441
- def fetch(*args, &block); end
442
- def fill(*args, &block); end
443
- def filter(*args, &block); end
444
- def filter!(*args, &block); end
445
- def find(*args, &block); end
446
- def find_all(*args, &block); end
447
- def find_index(*args, &block); end
448
- def first(*args, &block); end
449
- def flat_map(*args, &block); end
450
- def flatten(*args, &block); end
451
- def flatten!(*args, &block); end
452
- def grep(*args, &block); end
453
- def grep_v(*args, &block); end
454
- def group_by(*args, &block); end
455
- def include?(*args, &block); end
456
- def index(*args, &block); end
457
- def inject(*args, &block); end
458
- def insert(*args, &block); end
459
- def join(*args, &block); end
460
- def keep_if(*args, &block); end
461
- def last(*args, &block); end
462
- def lazy(*args, &block); end
463
- def length(*args, &block); end
464
- def map(*args, &block); end
465
- def map!(*args, &block); end
466
- def max(*args, &block); end
467
- def max_by(*args, &block); end
468
- def member?(*args, &block); end
469
- def min(*args, &block); end
470
- def min_by(*args, &block); end
471
- def minmax(*args, &block); end
472
- def minmax_by(*args, &block); end
473
- def none?(*args, &block); end
474
- def one?(*args, &block); end
475
- def pack(*args, &block); end
476
- def partition(*args, &block); end
477
- def permutation(*args, &block); end
478
- def pop(*args, &block); end
479
- def prepend(*args, &block); end
480
- def product(*args, &block); end
481
- def push(*args, &block); end
482
- def rassoc(*args, &block); end
483
- def reduce(*args, &block); end
484
- def reject(*args, &block); end
485
- def reject!(*args, &block); end
486
- def repeated_combination(*args, &block); end
487
- def repeated_permutation(*args, &block); end
488
- def replace(*args, &block); end
489
- def reverse(*args, &block); end
490
- def reverse!(*args, &block); end
491
- def reverse_each(*args, &block); end
492
- def rindex(*args, &block); end
493
- def rotate(*args, &block); end
494
- def rotate!(*args, &block); end
495
- def sample(*args, &block); end
496
- def select(*args, &block); end
497
- def select!(*args, &block); end
498
- def shelljoin(*args, &block); end
499
- def shift(*args, &block); end
500
- def shuffle(*args, &block); end
501
- def shuffle!(*args, &block); end
502
- def size(*args, &block); end
503
- def slice(*args, &block); end
504
- def slice!(*args, &block); end
505
- def slice_after(*args, &block); end
506
- def slice_before(*args, &block); end
507
- def slice_when(*args, &block); end
508
- def sort(*args, &block); end
509
- def sort!(*args, &block); end
510
- def sort_by(*args, &block); end
511
- def sort_by!(*args, &block); end
512
- def sum(*args, &block); end
513
- def take(*args, &block); end
514
- def take_while(*args, &block); end
515
- def to_ary(*args, &block); end
516
- def to_h(*args, &block); end
517
- def to_set(*args, &block); end
518
- def transpose(*args, &block); end
519
- def union(*args, &block); end
520
- def uniq(*args, &block); end
521
- def uniq!(*args, &block); end
522
- def unshift(*args, &block); end
523
- def values_at(*args, &block); end
524
- def zip(*args, &block); end
525
- def |(*args, &block); end
526
- end
527
-
528
- RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
529
-
530
- module RuboCop::AST::ConditionalNode
531
- def body; end
532
- def condition; end
533
- def multiline_condition?; end
534
- def single_line_condition?; end
535
- end
536
-
537
- class RuboCop::AST::ConstNode < ::RuboCop::AST::Node
538
- def absolute?; end
539
- def class_name?; end
540
- def each_path(&block); end
541
- def module_name?; end
542
- def namespace; end
543
- def relative?; end
544
- def short_name; end
545
- end
546
-
547
- class RuboCop::AST::DefNode < ::RuboCop::AST::Node
548
- include ::RuboCop::AST::ParameterizedNode
549
- include ::RuboCop::AST::MethodIdentifierPredicates
550
-
551
- def argument_forwarding?; end
552
- def arguments; end
553
- def body; end
554
- def endless?; end
555
- def method_name; end
556
- def receiver; end
557
- def void_context?; end
558
- end
559
-
560
- class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
561
- include ::RuboCop::AST::ParameterizedNode
562
- include ::RuboCop::AST::MethodIdentifierPredicates
563
- include ::RuboCop::AST::MethodDispatchNode
564
-
565
- def arguments; end
566
- def node_parts; end
567
- end
568
-
569
- module RuboCop::AST::Descendence
570
- def child_nodes; end
571
- def descendants; end
572
- def each_child_node(*types); end
573
- def each_descendant(*types, &block); end
574
- def each_node(*types, &block); end
575
-
576
- protected
577
-
578
- def visit_descendants(types, &block); end
579
- end
580
-
581
- class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
582
- def value; end
583
- end
584
-
585
- class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
586
- def body; end
587
- end
588
-
589
- module RuboCop::AST::Ext; end
590
-
591
- module RuboCop::AST::Ext::Range
592
- def line_span(exclude_end: T.unsafe(nil)); end
593
- end
594
-
595
- module RuboCop::AST::Ext::RangeMinMax; end
596
-
597
- class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
598
- include ::RuboCop::AST::BasicLiteralNode
599
- include ::RuboCop::AST::NumericNode
600
- end
601
-
602
- class RuboCop::AST::ForNode < ::RuboCop::AST::Node
603
- def body; end
604
- def collection; end
605
- def do?; end
606
- def keyword; end
607
- def variable; end
608
- def void_context?; end
609
- end
610
-
611
- class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
612
- include ::RuboCop::AST::CollectionNode
613
-
614
- def to_a; end
615
- end
616
-
617
- module RuboCop::AST::HashElementNode
618
- def delimiter_delta(other); end
619
- def key; end
620
- def key_delta(other, alignment = T.unsafe(nil)); end
621
- def same_line?(other); end
622
- def value; end
623
- def value_delta(other); end
624
- end
625
-
626
- class RuboCop::AST::HashElementNode::HashElementDelta
627
- def initialize(first, second); end
628
-
629
- def delimiter_delta; end
630
- def key_delta(alignment = T.unsafe(nil)); end
631
- def value_delta; end
632
-
633
- private
634
-
635
- def delta(first, second, alignment = T.unsafe(nil)); end
636
- def first; end
637
- def keyword_splat?; end
638
- def second; end
639
- def valid_argument_types?; end
640
- end
641
-
642
- class RuboCop::AST::HashNode < ::RuboCop::AST::Node
643
- def braces?; end
644
- def each_key(&block); end
645
- def each_pair; end
646
- def each_value(&block); end
647
- def empty?; end
648
- def keys; end
649
- def mixed_delimiters?; end
650
- def pairs; end
651
- def pairs_on_same_line?; end
652
- def values; end
653
- end
654
-
655
- class RuboCop::AST::IfNode < ::RuboCop::AST::Node
656
- include ::RuboCop::AST::ConditionalNode
657
- include ::RuboCop::AST::ModifierNode
658
-
659
- def branches; end
660
- def each_branch(&block); end
661
- def else?; end
662
- def else_branch; end
663
- def elsif?; end
664
- def elsif_conditional?; end
665
- def if?; end
666
- def if_branch; end
667
- def inverse_keyword; end
668
- def keyword; end
669
- def modifier_form?; end
670
- def nested_conditional?; end
671
- def node_parts; end
672
- def ternary?; end
673
- def unless?; end
674
- end
675
-
676
- class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node
677
- def body; end
678
- def branch_index; end
679
- def pattern; end
680
- def then?; end
681
- end
682
-
683
- class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
684
- include ::RuboCop::AST::ParameterizedNode
685
- include ::RuboCop::AST::ParameterizedNode::RestArguments
686
- include ::RuboCop::AST::MethodIdentifierPredicates
687
- include ::RuboCop::AST::MethodDispatchNode
688
-
689
- def assignment_method?; end
690
- def attribute_accessor?; end
691
- def method_name; end
692
-
693
- private
694
-
695
- def first_argument_index; end
696
- end
697
-
698
- class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
699
- include ::RuboCop::AST::ParameterizedNode
700
- include ::RuboCop::AST::ParameterizedNode::RestArguments
701
- include ::RuboCop::AST::MethodIdentifierPredicates
702
- include ::RuboCop::AST::MethodDispatchNode
703
-
704
- def assignment_method?; end
705
- def attribute_accessor?; end
706
- def method_name; end
707
-
708
- private
709
-
710
- def first_argument_index; end
711
- end
712
-
713
- class RuboCop::AST::IntNode < ::RuboCop::AST::Node
714
- include ::RuboCop::AST::BasicLiteralNode
715
- include ::RuboCop::AST::NumericNode
716
- end
717
-
718
- class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
719
- include ::RuboCop::AST::HashElementNode
720
-
721
- def colon?; end
722
- def hash_rocket?; end
723
- def node_parts; end
724
- def operator; end
725
- end
726
-
727
- RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
728
-
729
- class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
730
- include ::RuboCop::AST::ParameterizedNode
731
- include ::RuboCop::AST::ParameterizedNode::RestArguments
732
- include ::RuboCop::AST::MethodIdentifierPredicates
733
- include ::RuboCop::AST::MethodDispatchNode
734
-
735
- def assignment_method?; end
736
- def attribute_accessor?; end
737
- def lambda?; end
738
- def lambda_literal?; end
739
- def method_name; end
740
- def receiver; end
741
-
742
- private
743
-
744
- def first_argument_index; end
745
- end
746
-
747
- module RuboCop::AST::MethodDispatchNode
748
- include ::RuboCop::AST::MethodIdentifierPredicates
749
- extend ::RuboCop::AST::NodePattern::Macros
750
-
751
- def access_modifier?; end
752
- def adjacent_def_modifier?(param0 = T.unsafe(nil)); end
753
- def arithmetic_operation?; end
754
- def assignment?; end
755
- def bare_access_modifier?; end
756
- def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
757
- def binary_operation?; end
758
- def block_literal?; end
759
- def block_node; end
760
- def command?(name); end
761
- def const_receiver?; end
762
- def def_modifier(node = T.unsafe(nil)); end
763
- def def_modifier?(node = T.unsafe(nil)); end
764
- def dot?; end
765
- def double_colon?; end
766
- def implicit_call?; end
767
- def in_macro_scope?(param0 = T.unsafe(nil)); end
768
- def lambda?; end
769
- def lambda_literal?; end
770
- def macro?; end
771
- def method_name; end
772
- def non_bare_access_modifier?; end
773
- def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
774
- def receiver; end
775
- def safe_navigation?; end
776
- def self_receiver?; end
777
- def setter_method?; end
778
- def special_modifier?; end
779
- def unary_operation?; end
780
- end
781
-
782
- RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
783
- RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
784
-
785
- module RuboCop::AST::MethodIdentifierPredicates
786
- def assignment_method?; end
787
- def bang_method?; end
788
- def camel_case_method?; end
789
- def comparison_method?; end
790
- def const_receiver?; end
791
- def enumerable_method?; end
792
- def enumerator_method?; end
793
- def method?(name); end
794
- def negation_method?; end
795
- def nonmutating_array_method?; end
796
- def nonmutating_binary_operator_method?; end
797
- def nonmutating_hash_method?; end
798
- def nonmutating_operator_method?; end
799
- def nonmutating_string_method?; end
800
- def nonmutating_unary_operator_method?; end
801
- def operator_method?; end
802
- def predicate_method?; end
803
- def prefix_bang?; end
804
- def prefix_not?; end
805
- def self_receiver?; end
806
- end
807
-
808
- RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)
809
- RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)
810
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)
811
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
812
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)
813
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
814
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)
815
- RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
816
- RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
817
-
818
- module RuboCop::AST::ModifierNode
819
- def modifier_form?; end
820
- end
821
-
822
- class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
823
- def body; end
824
- def identifier; end
825
- end
826
-
827
- class RuboCop::AST::NextNode < ::RuboCop::AST::Node
828
- include ::RuboCop::AST::ParameterizedNode
829
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
830
- end
831
-
832
- class RuboCop::AST::Node < ::Parser::AST::Node
833
- include ::RuboCop::AST::Sexp
834
- include ::RuboCop::AST::Descendence
835
- include ::RuboCop::RSpec::Node
836
- extend ::RuboCop::AST::NodePattern::Macros
837
-
838
- def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
839
-
840
- def __ENCODING___type?; end
841
- def __FILE___type?; end
842
- def __LINE___type?; end
843
- def alias_type?; end
844
- def ancestors; end
845
- def and_asgn_type?; end
846
- def and_type?; end
847
- def arg_expr_type?; end
848
- def arg_type?; end
849
- def args_type?; end
850
- def argument?; end
851
- def argument_type?; end
852
- def array_pattern_type?; end
853
- def array_pattern_with_tail_type?; end
854
- def array_type?; end
855
- def assignment?; end
856
- def assignment_or_similar?(param0 = T.unsafe(nil)); end
857
- def back_ref_type?; end
858
- def basic_conditional?; end
859
- def basic_literal?; end
860
- def begin_type?; end
861
- def block_pass_type?; end
862
- def block_type?; end
863
- def blockarg_expr_type?; end
864
- def blockarg_type?; end
865
- def boolean_type?; end
866
- def break_type?; end
867
- def call_type?; end
868
- def case_match_type?; end
869
- def case_type?; end
870
- def casgn_type?; end
871
- def cbase_type?; end
872
- def chained?; end
873
- def class_constructor?(param0 = T.unsafe(nil)); end
874
- def class_definition?(param0 = T.unsafe(nil)); end
875
- def class_type?; end
876
- def complete!; end
877
- def complete?; end
878
- def complex_type?; end
879
- def conditional?; end
880
- def const_name; end
881
- def const_pattern_type?; end
882
- def const_type?; end
883
- def csend_type?; end
884
- def cvar_type?; end
885
- def cvasgn_type?; end
886
- def def_type?; end
887
- def defined_module; end
888
- def defined_module_name; end
889
- def defined_type?; end
890
- def defs_type?; end
891
- def dstr_type?; end
892
- def dsym_type?; end
893
- def each_ancestor(*types, &block); end
894
- def eflipflop_type?; end
895
- def empty_else_type?; end
896
- def empty_source?; end
897
- def ensure_type?; end
898
- def equals_asgn?; end
899
- def erange_type?; end
900
- def false_type?; end
901
- def falsey_literal?; end
902
- def find_pattern_type?; end
903
- def first_line; end
904
- def float_type?; end
905
- def for_type?; end
906
- def forward_arg_type?; end
907
- def forward_args_type?; end
908
- def forwarded_args_type?; end
909
- def global_const?(param0 = T.unsafe(nil), param1); end
910
- def guard_clause?; end
911
- def gvar_type?; end
912
- def gvasgn_type?; end
913
- def hash_pattern_type?; end
914
- def hash_type?; end
915
- def ident_type?; end
916
- def if_guard_type?; end
917
- def if_type?; end
918
- def iflipflop_type?; end
919
- def immutable_literal?; end
920
- def in_match_type?; end
921
- def in_pattern_type?; end
922
- def index_type?; end
923
- def indexasgn_type?; end
924
- def int_type?; end
925
- def irange_type?; end
926
- def ivar_type?; end
927
- def ivasgn_type?; end
928
- def keyword?; end
929
- def kwarg_type?; end
930
- def kwargs_type?; end
931
- def kwbegin_type?; end
932
- def kwnilarg_type?; end
933
- def kwoptarg_type?; end
934
- def kwrestarg_type?; end
935
- def kwsplat_type?; end
936
- def lambda?(param0 = T.unsafe(nil)); end
937
- def lambda_or_proc?(param0 = T.unsafe(nil)); end
938
- def lambda_type?; end
939
- def last_line; end
940
- def left_sibling; end
941
- def left_siblings; end
942
- def line_count; end
943
- def literal?; end
944
- def loop_keyword?; end
945
- def lvar_type?; end
946
- def lvasgn_type?; end
947
- def masgn_type?; end
948
- def match_alt_type?; end
949
- def match_as_type?; end
950
- def match_current_line_type?; end
951
- def match_guard_clause?(param0 = T.unsafe(nil)); end
952
- def match_nil_pattern_type?; end
953
- def match_pattern_p_type?; end
954
- def match_pattern_type?; end
955
- def match_rest_type?; end
956
- def match_var_type?; end
957
- def match_with_lvasgn_type?; end
958
- def match_with_trailing_comma_type?; end
959
- def mlhs_type?; end
960
- def module_definition?(param0 = T.unsafe(nil)); end
961
- def module_type?; end
962
- def multiline?; end
963
- def mutable_literal?; end
964
- def new_class_or_module_block?(param0 = T.unsafe(nil)); end
965
- def next_type?; end
966
- def nil_type?; end
967
- def node_parts; end
968
- def nonempty_line_count; end
969
- def not_type?; end
970
- def nth_ref_type?; end
971
- def numargs_type?; end
972
- def numblock_type?; end
973
- def numeric_type?; end
974
- def objc_kwarg_type?; end
975
- def objc_restarg_type?; end
976
- def objc_varargs_type?; end
977
- def op_asgn_type?; end
978
- def operator_keyword?; end
979
- def optarg_type?; end
980
- def or_asgn_type?; end
981
- def or_type?; end
982
- def pair_type?; end
983
- def parent; end
984
- def parent?; end
985
- def parent_module_name; end
986
- def parenthesized_call?; end
987
- def pin_type?; end
988
- def post_condition_loop?; end
989
- def postexe_type?; end
990
- def preexe_type?; end
991
- def proc?(param0 = T.unsafe(nil)); end
992
- def procarg0_type?; end
993
- def pure?; end
994
- def range_type?; end
995
- def rational_type?; end
996
- def receiver(param0 = T.unsafe(nil)); end
997
- def recursive_basic_literal?; end
998
- def recursive_literal?; end
999
- def redo_type?; end
1000
- def reference?; end
1001
- def regexp_type?; end
1002
- def regopt_type?; end
1003
- def resbody_type?; end
1004
- def rescue_type?; end
1005
- def restarg_expr_type?; end
1006
- def restarg_type?; end
1007
- def retry_type?; end
1008
- def return_type?; end
1009
- def right_sibling; end
1010
- def right_siblings; end
1011
- def root?; end
1012
- def sclass_type?; end
1013
- def self_type?; end
1014
- def send_type?; end
1015
- def shadowarg_type?; end
1016
- def shorthand_asgn?; end
1017
- def sibling_index; end
1018
- def single_line?; end
1019
- def source; end
1020
- def source_length; end
1021
- def source_range; end
1022
- def special_keyword?; end
1023
- def splat_type?; end
1024
- def str_content(param0 = T.unsafe(nil)); end
1025
- def str_type?; end
1026
- def struct_constructor?(param0 = T.unsafe(nil)); end
1027
- def super_type?; end
1028
- def sym_type?; end
1029
- def true_type?; end
1030
- def truthy_literal?; end
1031
- def undef_type?; end
1032
- def unless_guard_type?; end
1033
- def until_post_type?; end
1034
- def until_type?; end
1035
- def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
1036
- def value_used?; end
1037
- def variable?; end
1038
- def when_type?; end
1039
- def while_post_type?; end
1040
- def while_type?; end
1041
- def xstr_type?; end
1042
- def yield_type?; end
1043
- def zsuper_type?; end
1044
-
1045
- protected
1046
-
1047
- def parent=(node); end
1048
-
1049
- private
1050
-
1051
- def begin_value_used?; end
1052
- def case_if_value_used?; end
1053
- def defined_module0(param0 = T.unsafe(nil)); end
1054
- def for_value_used?; end
1055
- def parent_module_name_for_block(ancestor); end
1056
- def parent_module_name_for_sclass(sclass_node); end
1057
- def parent_module_name_part(node); end
1058
- def visit_ancestors(types); end
1059
- def while_until_value_used?; end
1060
- end
1061
-
1062
- RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
1063
- RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
1064
- RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
1065
- RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
1066
- RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
1067
- RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
1068
- RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
1069
- RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
1070
- RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
1071
- RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
1072
- RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
1073
- RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
1074
- RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
1075
- RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
1076
- RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
1077
- RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
1078
- RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
1079
- RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
1080
- RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
1081
- RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
1082
- RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
1083
- RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
1084
- RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
1085
-
1086
- class RuboCop::AST::NodePattern
1087
- include ::RuboCop::AST::NodePattern::MethodDefiner
1088
- extend ::Forwardable
1089
-
1090
- def initialize(str, compiler: T.unsafe(nil)); end
1091
-
1092
- def ==(other); end
1093
- def as_json(_options = T.unsafe(nil)); end
1094
- def ast; end
1095
- def captures(*args, &block); end
1096
- def encode_with(coder); end
1097
- def eql?(other); end
1098
- def freeze; end
1099
- def init_with(coder); end
1100
- def marshal_dump; end
1101
- def marshal_load(pattern); end
1102
- def match(*args, **rest, &block); end
1103
- def match_code; end
1104
- def named_parameters(*args, &block); end
1105
- def pattern; end
1106
- def positional_parameters(*args, &block); end
1107
- def to_s; end
1108
-
1109
- class << self
1110
- def descend(element, &block); end
1111
- end
1112
- end
1113
-
1114
- class RuboCop::AST::NodePattern::Builder
1115
- def emit_atom(type, value); end
1116
- def emit_call(type, selector, args = T.unsafe(nil)); end
1117
- def emit_capture(capture_token, node); end
1118
- def emit_list(type, _begin, children, _end); end
1119
- def emit_subsequence(node_list); end
1120
- def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
1121
- def emit_union(begin_t, pattern_lists, end_t); end
1122
-
1123
- private
1124
-
1125
- def n(type, *args); end
1126
- def optimizable_as_set?(children); end
1127
- def union_children(pattern_lists); end
1128
- end
1129
-
1130
- class RuboCop::AST::NodePattern::Comment
1131
- def initialize(range); end
1132
-
1133
- def ==(other); end
1134
- def inspect; end
1135
- def loc; end
1136
- def location; end
1137
- def text; end
1138
- end
1139
-
1140
- class RuboCop::AST::NodePattern::Compiler
1141
- extend ::Forwardable
1142
-
1143
- def initialize; end
1144
-
1145
- def bind(*args, &block); end
1146
- def binding; end
1147
- def captures; end
1148
- def compile_as_atom(node); end
1149
- def compile_as_node_pattern(node, **options); end
1150
- def compile_sequence(sequence, var:); end
1151
- def each_union(enum, &block); end
1152
- def freeze; end
1153
- def named_parameter(name); end
1154
- def named_parameters; end
1155
- def next_capture; end
1156
- def parser; end
1157
- def positional_parameter(number); end
1158
- def positional_parameters; end
1159
- def with_temp_variables(*names, &block); end
1160
-
1161
- private
1162
-
1163
- def enforce_same_captures(enum); end
1164
- def new_capture; end
1165
- end
1166
-
1167
- class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
1168
- private
1169
-
1170
- def visit_const; end
1171
- def visit_named_parameter; end
1172
- def visit_number; end
1173
- def visit_other_type; end
1174
- def visit_positional_parameter; end
1175
- def visit_regexp; end
1176
- def visit_set; end
1177
- def visit_string; end
1178
- def visit_symbol; end
1179
- def visit_unify; end
1180
- end
1181
-
1182
- class RuboCop::AST::NodePattern::Compiler::Binding
1183
- def initialize; end
1184
-
1185
- def bind(name); end
1186
- def union_bind(enum); end
1187
-
1188
- private
1189
-
1190
- def forbid(names); end
1191
- end
1192
-
1193
- class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
1194
- def initialize; end
1195
-
1196
- def comments(*args, &block); end
1197
- def named_parameters; end
1198
- def node_ids; end
1199
- def parser; end
1200
- def tokens(*args, &block); end
1201
- end
1202
-
1203
- class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
1204
- def initialize(pattern, compiler: T.unsafe(nil)); end
1205
-
1206
- def compiler; end
1207
- def node_pattern; end
1208
- def pattern; end
1209
- def test(ruby, trace: T.unsafe(nil)); end
1210
-
1211
- private
1212
-
1213
- def ruby_ast(ruby); end
1214
- def ruby_parser; end
1215
- end
1216
-
1217
- RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
1218
- RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
1219
-
1220
- class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
1221
- def color_map(color_scheme = T.unsafe(nil)); end
1222
- def colorize(color_scheme = T.unsafe(nil)); end
1223
- def colorizer; end
1224
- def colorizer=(_); end
1225
- def match_map; end
1226
- def matched?(node); end
1227
- def returned; end
1228
- def returned=(_); end
1229
- def ruby_ast; end
1230
- def ruby_ast=(_); end
1231
- def trace; end
1232
- def trace=(_); end
1233
-
1234
- private
1235
-
1236
- def ast; end
1237
- def color_map_for(node, color); end
1238
-
1239
- class << self
1240
- def [](*_arg0); end
1241
- def inspect; end
1242
- def members; end
1243
- def new(*_arg0); end
1244
- end
1245
- end
1246
-
1247
- module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1248
- def do_compile; end
1249
-
1250
- private
1251
-
1252
- def node_id; end
1253
- def tracer(kind); end
1254
- end
1255
-
1256
- class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
1257
- include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1258
- end
1259
-
1260
- class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
1261
- include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
1262
- end
1263
-
1264
- class RuboCop::AST::NodePattern::Compiler::Debug::Trace
1265
- def initialize; end
1266
-
1267
- def enter(node_id); end
1268
- def matched?(node_id); end
1269
- def success(node_id); end
1270
- end
1271
-
1272
- class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
1273
- def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
1274
-
1275
- def access; end
1276
- def seq_head; end
1277
-
1278
- private
1279
-
1280
- def access_element; end
1281
- def access_node; end
1282
- def compile_args(arg_list, first: T.unsafe(nil)); end
1283
- def compile_guard_clause; end
1284
- def compile_value_match(value); end
1285
- def multiple_access(kind); end
1286
- def visit_ascend; end
1287
- def visit_capture; end
1288
- def visit_descend; end
1289
- def visit_function_call; end
1290
- def visit_intersection; end
1291
- def visit_negation; end
1292
- def visit_node_type; end
1293
- def visit_other_type; end
1294
- def visit_predicate; end
1295
- def visit_sequence; end
1296
- def visit_unify; end
1297
- def visit_union; end
1298
- def visit_wildcard; end
1299
- end
1300
-
1301
- class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
1302
- def initialize(compiler, sequence:, var:); end
1303
-
1304
- def compile_sequence; end
1305
- def in_sync; end
1306
-
1307
- protected
1308
-
1309
- def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
1310
- def cur_index; end
1311
- def sync; end
1312
-
1313
- private
1314
-
1315
- def compile_and_advance(term); end
1316
- def compile_any_order_branches(matched_var); end
1317
- def compile_any_order_else; end
1318
- def compile_captured_repetition(child_code, child_captures); end
1319
- def compile_case(when_branches, else_code); end
1320
- def compile_child_nb_guard(arity_range); end
1321
- def compile_cur_index; end
1322
- def compile_index(cur = T.unsafe(nil)); end
1323
- def compile_loop(term); end
1324
- def compile_loop_advance(to = T.unsafe(nil)); end
1325
- def compile_matched(kind); end
1326
- def compile_max_matched; end
1327
- def compile_min_check; end
1328
- def compile_remaining; end
1329
- def compile_union_forks; end
1330
- def empty_loop; end
1331
- def handle_prev; end
1332
- def merge_forks!(forks); end
1333
- def preserve_union_start(forks); end
1334
- def remaining_arities(children, last_arity); end
1335
- def use_index_from_end; end
1336
- def visit_any_order; end
1337
- def visit_capture; end
1338
- def visit_other_type; end
1339
- def visit_repetition; end
1340
- def visit_rest; end
1341
- def visit_union; end
1342
- def within_loop; end
1343
- end
1344
-
1345
- RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
1346
- RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
1347
-
1348
- class RuboCop::AST::NodePattern::Compiler::Subcompiler
1349
- def initialize(compiler); end
1350
-
1351
- def compile(node); end
1352
- def compiler; end
1353
-
1354
- private
1355
-
1356
- def do_compile; end
1357
- def node; end
1358
-
1359
- class << self
1360
- def inherited(base); end
1361
- def method_added(method); end
1362
- def registry; end
1363
- end
1364
- end
1365
-
1366
- class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
1367
-
1368
- class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
1369
- def initialize(source); end
1370
-
1371
- def comments; end
1372
- def source_buffer; end
1373
- def tokens; end
1374
-
1375
- private
1376
-
1377
- def do_parse; end
1378
- def emit(type); end
1379
- def emit_comment; end
1380
- def emit_regexp; end
1381
- def token(type, value); end
1382
- end
1383
-
1384
- RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
1385
- RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
1386
-
1387
- class RuboCop::AST::NodePattern::LexerRex
1388
- def action; end
1389
- def filename; end
1390
- def filename=(_arg0); end
1391
- def location; end
1392
- def match; end
1393
- def matches; end
1394
- def next_token; end
1395
- def parse(str); end
1396
- def parse_file(path); end
1397
- def scanner_class; end
1398
- def ss; end
1399
- def ss=(_arg0); end
1400
- def state; end
1401
- def state=(_arg0); end
1402
- end
1403
-
1404
- RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
1405
- RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
1406
- RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
1407
- class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
1408
- RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
1409
- RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
1410
- RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
1411
- RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
1412
- class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end
1413
-
1414
- module RuboCop::AST::NodePattern::Macros
1415
- def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
1416
- def def_node_search(method_name, pattern_str, **keyword_defaults); end
1417
- end
1418
-
1419
- module RuboCop::AST::NodePattern::MethodDefiner
1420
- def as_lambda; end
1421
- def compile_as_lambda; end
1422
- def def_node_matcher(base, method_name, **defaults); end
1423
- def def_node_search(base, method_name, **defaults); end
1424
-
1425
- private
1426
-
1427
- def compile_init; end
1428
- def def_helper(base, method_name, **defaults); end
1429
- def emit_keyword_list(forwarding: T.unsafe(nil)); end
1430
- def emit_lambda_code; end
1431
- def emit_method_code; end
1432
- def emit_node_search(method_name); end
1433
- def emit_node_search_body(method_name, prelude:, on_match:); end
1434
- def emit_param_list; end
1435
- def emit_params(*first, forwarding: T.unsafe(nil)); end
1436
- def emit_retval; end
1437
- def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
1438
- def wrapping_block(method_name, **defaults); end
1439
- end
1440
-
1441
- class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
1442
- include ::RuboCop::AST::Descendence
1443
- extend ::Forwardable
1444
-
1445
- def arity; end
1446
- def arity_range; end
1447
- def capture?; end
1448
- def child; end
1449
- def children_nodes; end
1450
- def in_sequence_head; end
1451
- def matches_within_set?; end
1452
- def nb_captures; end
1453
- def rest?; end
1454
- def variadic?; end
1455
- def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
1456
- end
1457
-
1458
- class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
1459
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1460
-
1461
- def arity; end
1462
- def ends_with_rest?; end
1463
- def rest_node; end
1464
- def term_nodes; end
1465
- end
1466
-
1467
- RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
1468
-
1469
- class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
1470
- def arity(*args, &block); end
1471
- def capture?; end
1472
- def in_sequence_head; end
1473
- def nb_captures; end
1474
- def rest?(*args, &block); end
1475
- end
1476
-
1477
- module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1478
- def in_sequence_head; end
1479
- end
1480
-
1481
- RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
1482
- RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
1483
- RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
1484
- RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
1485
-
1486
- class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
1487
- def arg_list; end
1488
- def method_name; end
1489
- end
1490
-
1491
- class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
1492
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1493
-
1494
- def arity; end
1495
- def operator; end
1496
- end
1497
-
1498
- RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
1499
-
1500
- class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
1501
- def arity; end
1502
- def in_sequence_head; end
1503
- def rest?; end
1504
- end
1505
-
1506
- RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
1507
-
1508
- class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
1509
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1510
-
1511
- def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
1512
- end
1513
-
1514
- class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
1515
- include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
1516
-
1517
- def arity; end
1518
- def in_sequence_head; end
1519
- end
1520
-
1521
- class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
1522
- def arity; end
1523
- def in_sequence_head; end
1524
- end
1525
-
1526
- class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
1527
- extend ::Forwardable
1528
-
1529
- def initialize(builder = T.unsafe(nil)); end
1530
-
1531
- def _reduce_10(val, _values); end
1532
- def _reduce_11(val, _values); end
1533
- def _reduce_13(val, _values); end
1534
- def _reduce_14(val, _values); end
1535
- def _reduce_15(val, _values); end
1536
- def _reduce_16(val, _values); end
1537
- def _reduce_17(val, _values); end
1538
- def _reduce_18(val, _values); end
1539
- def _reduce_19(val, _values); end
1540
- def _reduce_2(val, _values); end
1541
- def _reduce_20(val, _values); end
1542
- def _reduce_21(val, _values); end
1543
- def _reduce_22(val, _values); end
1544
- def _reduce_25(val, _values); end
1545
- def _reduce_26(val, _values); end
1546
- def _reduce_3(val, _values); end
1547
- def _reduce_33(val, _values); end
1548
- def _reduce_37(val, _values); end
1549
- def _reduce_38(val, _values); end
1550
- def _reduce_39(val, _values); end
1551
- def _reduce_4(val, _values); end
1552
- def _reduce_40(val, _values); end
1553
- def _reduce_41(val, _values); end
1554
- def _reduce_42(val, _values); end
1555
- def _reduce_43(val, _values); end
1556
- def _reduce_44(val, _values); end
1557
- def _reduce_45(val, _values); end
1558
- def _reduce_46(val, _values); end
1559
- def _reduce_5(val, _values); end
1560
- def _reduce_6(val, _values); end
1561
- def _reduce_7(val, _values); end
1562
- def _reduce_8(val, _values); end
1563
- def _reduce_9(val, _values); end
1564
- def _reduce_none(val, _values); end
1565
- def emit_atom(*args, &block); end
1566
- def emit_call(*args, &block); end
1567
- def emit_capture(*args, &block); end
1568
- def emit_list(*args, &block); end
1569
- def emit_unary_op(*args, &block); end
1570
- def emit_union(*args, &block); end
1571
- def inspect; end
1572
- def next_token(*args, &block); end
1573
- def parse(source); end
1574
-
1575
- private
1576
-
1577
- def enforce_unary(node); end
1578
- def on_error(token, val, _vstack); end
1579
- end
1580
-
1581
- RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
1582
- RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
1583
- RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
1584
- RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
1585
-
1586
- class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
1587
- def comments; end
1588
- def do_parse; end
1589
- def tokens; end
1590
- end
1591
-
1592
- class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
1593
- def emit_atom(type, token); end
1594
- def emit_call(type, selector_t, args = T.unsafe(nil)); end
1595
- def emit_list(type, begin_t, children, end_t); end
1596
- def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
1597
-
1598
- private
1599
-
1600
- def join_exprs(left_expr, right_expr); end
1601
- def loc(token_or_range); end
1602
- def n(type, children, source_map); end
1603
- def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
1604
- end
1605
-
1606
- class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
1607
- def initialize(str_or_buffer); end
1608
-
1609
- def emit_comment; end
1610
- def pos; end
1611
- def source_buffer; end
1612
- def token(type, value); end
1613
- end
1614
-
1615
- module RuboCop::AST::NodePattern::Sets
1616
- class << self
1617
- def [](set); end
1618
- def name(set); end
1619
- def uniq(name); end
1620
- end
1621
- end
1622
-
1623
- RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
1624
- RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
1625
- RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
1626
- RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set)
1627
- RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
1628
- RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
1629
- RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set)
1630
- RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set)
1631
- RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
1632
- RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set)
1633
- RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set)
1634
- RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), Set)
1635
- RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set)
1636
- RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
1637
- RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set)
1638
- RuboCop::AST::NodePattern::Sets::SET_BEFORE_AFTER = T.let(T.unsafe(nil), Set)
1639
- RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set)
1640
- RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set)
1641
- RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
1642
- RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set)
1643
- RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set)
1644
- RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
1645
- RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
1646
- RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
1647
- RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
1648
- RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
1649
- RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
1650
- RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set)
1651
- RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
1652
- RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
1653
- RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set)
1654
- RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
1655
- RuboCop::AST::NodePattern::Sets::SET_DESCRIBE_FEATURE = T.let(T.unsafe(nil), Set)
1656
- RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set)
1657
- RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set)
1658
- RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set)
1659
- RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
1660
- RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
1661
- RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set)
1662
- RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set)
1663
- RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
1664
- RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set)
1665
- RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set)
1666
- RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set)
1667
- RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
1668
- RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
1669
- RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set)
1670
- RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
1671
- RuboCop::AST::NodePattern::Sets::SET_GEMCUTTER_RUBYGEMS_RUBYFORGE = T.let(T.unsafe(nil), Set)
1672
- RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
1673
- RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set)
1674
- RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
1675
- RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set)
1676
- RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
1677
- RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
1678
- RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set)
1679
- RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
1680
- RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
1681
- RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
1682
- RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
1683
- RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
1684
- RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
1685
- RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
1686
- RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set)
1687
- RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set)
1688
- RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set)
1689
- RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
1690
- RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
1691
- RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
1692
- RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set)
1693
- RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
1694
- RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set)
1695
- RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set)
1696
- RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
1697
- RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
1698
- RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set)
1699
- RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
1700
- RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
1701
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
1702
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set)
1703
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
1704
- RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set)
1705
- RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
1706
- RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
1707
- RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
1708
- RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set)
1709
- RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set)
1710
- RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
1711
- RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
1712
- RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set)
1713
- RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
1714
- RuboCop::AST::NodePattern::Sets::SET_SORT_MIN_MAX = T.let(T.unsafe(nil), Set)
1715
- RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
1716
- RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
1717
- RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set)
1718
- RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set)
1719
- RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
1720
- RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
1721
- RuboCop::AST::NodePattern::Sets::SET_TASK_NAMESPACE = T.let(T.unsafe(nil), Set)
1722
- RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
1723
- RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
1724
- RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C = T.let(T.unsafe(nil), Set)
1725
- RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
1726
- RuboCop::AST::NodePattern::Sets::SET_TYPE_TEMPLATE_TYPE_MEMBER = T.let(T.unsafe(nil), Set)
1727
- RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
1728
- RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
1729
- RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
1730
- RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
1731
- RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
1732
- RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
1733
- RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
1734
- RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
1735
- RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
1736
- RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
1737
- RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
1738
- RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
1739
- RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set)
1740
- RuboCop::AST::NodePattern::Sets::SET___EQL = T.let(T.unsafe(nil), Set)
1741
- RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
1742
- RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
1743
- RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
1744
- RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
1745
- RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
1746
- RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
1747
-
1748
- module RuboCop::AST::NumericNode
1749
- def sign?; end
1750
- end
1751
-
1752
- RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)
1753
-
1754
- class RuboCop::AST::OrNode < ::RuboCop::AST::Node
1755
- include ::RuboCop::AST::BinaryOperatorNode
1756
- include ::RuboCop::AST::PredicateOperatorNode
1757
-
1758
- def alternate_operator; end
1759
- def inverse_operator; end
1760
- end
1761
-
1762
- class RuboCop::AST::PairNode < ::RuboCop::AST::Node
1763
- include ::RuboCop::AST::HashElementNode
1764
-
1765
- def colon?; end
1766
- def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
1767
- def hash_rocket?; end
1768
- def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
1769
- def value_on_new_line?; end
1770
- end
1771
-
1772
- RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)
1773
- RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)
1774
- RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)
1775
- RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)
1776
-
1777
- module RuboCop::AST::ParameterizedNode
1778
- def arguments?; end
1779
- def block_argument?; end
1780
- def first_argument; end
1781
- def last_argument; end
1782
- def parenthesized?; end
1783
- def rest_argument?; end
1784
- def splat_argument?; end
1785
- end
1786
-
1787
- module RuboCop::AST::ParameterizedNode::RestArguments
1788
- include ::RuboCop::AST::ParameterizedNode
1789
-
1790
- def arguments; end
1791
- def arguments?; end
1792
- def first_argument; end
1793
- def last_argument; end
1794
- end
1795
-
1796
- module RuboCop::AST::ParameterizedNode::WrappedArguments
1797
- include ::RuboCop::AST::ParameterizedNode
1798
-
1799
- def arguments; end
1800
- end
1801
-
1802
- module RuboCop::AST::PredicateOperatorNode
1803
- def logical_operator?; end
1804
- def operator; end
1805
- def semantic_operator?; end
1806
- end
1807
-
1808
- RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
1809
- RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
1810
- RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
1811
- RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
1812
-
1813
- class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode
1814
- def name; end
1815
- end
1816
-
1817
- class RuboCop::AST::ProcessedSource
1818
- include ::RuboCop::Ext::ProcessedSource
1819
-
1820
- def initialize(source, ruby_version, path = T.unsafe(nil)); end
1821
-
1822
- def [](*args); end
1823
- def ast; end
1824
- def ast_with_comments; end
1825
- def blank?; end
1826
- def buffer; end
1827
- def checksum; end
1828
- def comment_at_line(line); end
1829
- def commented?(source_range); end
1830
- def comments; end
1831
- def comments_before_line(line); end
1832
- def contains_comment?(source_range); end
1833
- def current_line(token); end
1834
- def diagnostics; end
1835
- def each_comment(&block); end
1836
- def each_comment_in_lines(line_range); end
1837
- def each_token(&block); end
1838
- def file_path; end
1839
- def find_comment(&block); end
1840
- def find_token(&block); end
1841
- def first_token_of(range_or_node); end
1842
- def following_line(token); end
1843
- def last_token_of(range_or_node); end
1844
- def line_indentation(line_number); end
1845
- def line_with_comment?(line); end
1846
- def lines; end
1847
- def parser_error; end
1848
- def path; end
1849
- def preceding_line(token); end
1850
- def raw_source; end
1851
- def ruby_version; end
1852
- def start_with?(string); end
1853
- def tokens; end
1854
- def tokens_within(range_or_node); end
1855
- def valid_syntax?; end
1856
-
1857
- private
1858
-
1859
- def comment_index; end
1860
- def create_parser(ruby_version); end
1861
- def first_token_index(range_or_node); end
1862
- def last_token_index(range_or_node); end
1863
- def parse(source, ruby_version); end
1864
- def parser_class(ruby_version); end
1865
- def sorted_tokens; end
1866
- def source_range(range_or_node); end
1867
- def tokenize(parser); end
1868
-
1869
- class << self
1870
- def from_file(path, ruby_version); end
1871
- end
1872
- end
1873
-
1874
- RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
1875
- RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
1876
-
1877
- class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
1878
- def begin; end
1879
- def end; end
1880
- end
1881
-
1882
- class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
1883
- include ::RuboCop::Ext::RegexpNode
1884
-
1885
- def content; end
1886
- def delimiter?(char); end
1887
- def delimiters; end
1888
- def extended?; end
1889
- def ignore_case?; end
1890
- def interpolation?; end
1891
- def multiline_mode?; end
1892
- def no_encoding?; end
1893
- def options; end
1894
- def percent_r_literal?; end
1895
- def regopt; end
1896
- def single_interpolation?; end
1897
- def slash_literal?; end
1898
- def to_regexp; end
1899
-
1900
- private
1901
-
1902
- def regopt_include?(option); end
1903
- end
1904
-
1905
- RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)
1906
-
1907
- class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
1908
- def body; end
1909
- def branch_index; end
1910
- def exception_variable; end
1911
- def exceptions; end
1912
- end
1913
-
1914
- class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
1915
- def body; end
1916
- def branches; end
1917
- def else?; end
1918
- def else_branch; end
1919
- def resbody_branches; end
1920
- end
1921
-
1922
- class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
1923
- include ::RuboCop::AST::ParameterizedNode
1924
- include ::RuboCop::AST::ParameterizedNode::WrappedArguments
1925
- end
1926
-
1927
- module RuboCop::AST::RuboCopCompatibility
1928
- def rubocop_loaded; end
1929
- end
1930
-
1931
- RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
1932
-
1933
- class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
1934
- def body; end
1935
- def identifier; end
1936
- end
1937
-
1938
- class RuboCop::AST::SendNode < ::RuboCop::AST::Node
1939
- include ::RuboCop::AST::ParameterizedNode
1940
- include ::RuboCop::AST::ParameterizedNode::RestArguments
1941
- include ::RuboCop::AST::MethodIdentifierPredicates
1942
- include ::RuboCop::AST::MethodDispatchNode
1943
-
1944
- def attribute_accessor?(param0 = T.unsafe(nil)); end
1945
-
1946
- private
1947
-
1948
- def first_argument_index; end
1949
- end
1950
-
1951
- module RuboCop::AST::Sexp
1952
- def s(type, *children); end
1953
- end
1954
-
1955
- class RuboCop::AST::StrNode < ::RuboCop::AST::Node
1956
- include ::RuboCop::AST::BasicLiteralNode
1957
-
1958
- def heredoc?; end
1959
- end
1960
-
1961
- class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
1962
- include ::RuboCop::AST::ParameterizedNode
1963
- include ::RuboCop::AST::MethodIdentifierPredicates
1964
- include ::RuboCop::AST::MethodDispatchNode
1965
-
1966
- def arguments; end
1967
- def node_parts; end
1968
- end
1969
-
1970
- class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
1971
- include ::RuboCop::AST::BasicLiteralNode
1972
- end
1973
-
1974
- class RuboCop::AST::Token
1975
- def initialize(pos, type, text); end
1976
-
1977
- def begin_pos; end
1978
- def column; end
1979
- def comma?; end
1980
- def comment?; end
1981
- def end?; end
1982
- def end_pos; end
1983
- def equal_sign?; end
1984
- def left_array_bracket?; end
1985
- def left_brace?; end
1986
- def left_bracket?; end
1987
- def left_curly_brace?; end
1988
- def left_parens?; end
1989
- def left_ref_bracket?; end
1990
- def line; end
1991
- def pos; end
1992
- def rescue_modifier?; end
1993
- def right_bracket?; end
1994
- def right_curly_brace?; end
1995
- def right_parens?; end
1996
- def semicolon?; end
1997
- def space_after?; end
1998
- def space_before?; end
1999
- def text; end
2000
- def to_s; end
2001
- def type; end
2002
-
2003
- class << self
2004
- def from_parser_token(parser_token); end
2005
- end
2006
- end
2007
-
2008
- module RuboCop::AST::Traversal
2009
- extend ::RuboCop::AST::Traversal::CallbackCompiler
2010
-
2011
- def on_(node); end
2012
- def on___ENCODING__(node); end
2013
- def on___FILE__(node); end
2014
- def on___LINE__(node); end
2015
- def on_alias(node); end
2016
- def on_and(node); end
2017
- def on_and_asgn(node); end
2018
- def on_arg(node); end
2019
- def on_arg_expr(node); end
2020
- def on_args(node); end
2021
- def on_array(node); end
2022
- def on_array_pattern(node); end
2023
- def on_array_pattern_with_tail(node); end
2024
- def on_back_ref(node); end
2025
- def on_begin(node); end
2026
- def on_block(node); end
2027
- def on_block_pass(node); end
2028
- def on_blockarg(node); end
2029
- def on_break(node); end
2030
- def on_case(node); end
2031
- def on_case_match(node); end
2032
- def on_casgn(node); end
2033
- def on_cbase(node); end
2034
- def on_class(node); end
2035
- def on_complex(node); end
2036
- def on_const(node); end
2037
- def on_const_pattern(node); end
2038
- def on_csend(node); end
2039
- def on_cvar(node); end
2040
- def on_cvasgn(node); end
2041
- def on_def(node); end
2042
- def on_defined?(node); end
2043
- def on_defs(node); end
2044
- def on_dstr(node); end
2045
- def on_dsym(node); end
2046
- def on_eflipflop(node); end
2047
- def on_empty_else(node); end
2048
- def on_ensure(node); end
2049
- def on_erange(node); end
2050
- def on_false(node); end
2051
- def on_find_pattern(node); end
2052
- def on_float(node); end
2053
- def on_for(node); end
2054
- def on_forward_arg(node); end
2055
- def on_forward_args(node); end
2056
- def on_forwarded_args(node); end
2057
- def on_gvar(node); end
2058
- def on_gvasgn(node); end
2059
- def on_hash(node); end
2060
- def on_hash_pattern(node); end
2061
- def on_if(node); end
2062
- def on_if_guard(node); end
2063
- def on_iflipflop(node); end
2064
- def on_in_match(node); end
2065
- def on_in_pattern(node); end
2066
- def on_index(node); end
2067
- def on_indexasgn(node); end
2068
- def on_int(node); end
2069
- def on_irange(node); end
2070
- def on_ivar(node); end
2071
- def on_ivasgn(node); end
2072
- def on_kwarg(node); end
2073
- def on_kwargs(node); end
2074
- def on_kwbegin(node); end
2075
- def on_kwnilarg(node); end
2076
- def on_kwoptarg(node); end
2077
- def on_kwrestarg(node); end
2078
- def on_kwsplat(node); end
2079
- def on_lambda(node); end
2080
- def on_lvar(node); end
2081
- def on_lvasgn(node); end
2082
- def on_masgn(node); end
2083
- def on_match_alt(node); end
2084
- def on_match_as(node); end
2085
- def on_match_current_line(node); end
2086
- def on_match_nil_pattern(node); end
2087
- def on_match_pattern(node); end
2088
- def on_match_pattern_p(node); end
2089
- def on_match_rest(node); end
2090
- def on_match_var(node); end
2091
- def on_match_with_lvasgn(node); end
2092
- def on_match_with_trailing_comma(node); end
2093
- def on_mlhs(node); end
2094
- def on_module(node); end
2095
- def on_mrasgn(node); end
2096
- def on_next(node); end
2097
- def on_nil(node); end
2098
- def on_not(node); end
2099
- def on_nth_ref(node); end
2100
- def on_numblock(node); end
2101
- def on_op_asgn(node); end
2102
- def on_optarg(node); end
2103
- def on_or(node); end
2104
- def on_or_asgn(node); end
2105
- def on_pair(node); end
2106
- def on_pin(node); end
2107
- def on_postexe(node); end
2108
- def on_preexe(node); end
2109
- def on_procarg0(node); end
2110
- def on_rasgn(node); end
2111
- def on_rational(node); end
2112
- def on_redo(node); end
2113
- def on_regexp(node); end
2114
- def on_regopt(node); end
2115
- def on_resbody(node); end
2116
- def on_rescue(node); end
2117
- def on_restarg(node); end
2118
- def on_retry(node); end
2119
- def on_return(node); end
2120
- def on_sclass(node); end
2121
- def on_self(node); end
2122
- def on_send(node); end
2123
- def on_shadowarg(node); end
2124
- def on_splat(node); end
2125
- def on_str(node); end
2126
- def on_super(node); end
2127
- def on_sym(node); end
2128
- def on_true(node); end
2129
- def on_undef(node); end
2130
- def on_unless_guard(node); end
2131
- def on_until(node); end
2132
- def on_until_post(node); end
2133
- def on_when(node); end
2134
- def on_while(node); end
2135
- def on_while_post(node); end
2136
- def on_xstr(node); end
2137
- def on_yield(node); end
2138
- def on_zsuper(node); end
2139
- def walk(node); end
2140
- end
2141
-
2142
- module RuboCop::AST::Traversal::CallbackCompiler
2143
- def arity_check(range); end
2144
- def body(signature, prelude); end
2145
- def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
2146
- end
2147
-
2148
- RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
2149
- RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
2150
- class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
2151
- RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
2152
- RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
2153
-
2154
- class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
2155
- include ::RuboCop::AST::ConditionalNode
2156
- include ::RuboCop::AST::ModifierNode
2157
-
2158
- def do?; end
2159
- def inverse_keyword; end
2160
- def keyword; end
2161
- end
2162
-
2163
- module RuboCop::AST::Version; end
2164
- RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)
2165
-
2166
- class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
2167
- def body; end
2168
- def branch_index; end
2169
- def conditions; end
2170
- def each_condition(&block); end
2171
- def then?; end
2172
- end
2173
-
2174
- class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
2175
- include ::RuboCop::AST::ConditionalNode
2176
- include ::RuboCop::AST::ModifierNode
2177
-
2178
- def do?; end
2179
- def inverse_keyword; end
2180
- def keyword; end
2181
- end
2182
-
2183
- class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
2184
- include ::RuboCop::AST::ParameterizedNode
2185
- include ::RuboCop::AST::MethodIdentifierPredicates
2186
- include ::RuboCop::AST::MethodDispatchNode
2187
-
2188
- def arguments; end
2189
- def node_parts; end
2190
- end
2191
-
2192
- RuboCop::NodePattern = RuboCop::AST::NodePattern
2193
- RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
2194
- RuboCop::Token = RuboCop::AST::Token