prism 0.26.0 → 0.27.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +20 -1
- data/Makefile +3 -2
- data/config.yml +278 -5
- data/ext/prism/api_node.c +70 -72
- data/ext/prism/extconf.rb +23 -4
- data/ext/prism/extension.c +11 -6
- data/ext/prism/extension.h +1 -1
- data/include/prism/ast.h +271 -4
- data/include/prism/diagnostic.h +3 -0
- data/include/prism/version.h +2 -2
- data/lib/prism/ffi.rb +1 -1
- data/lib/prism/lex_compat.rb +18 -1
- data/lib/prism/node.rb +1772 -265
- data/lib/prism/parse_result/newlines.rb +0 -2
- data/lib/prism/parse_result.rb +59 -13
- data/lib/prism/reflection.rb +18 -28
- data/lib/prism/serialize.rb +7 -4
- data/lib/prism/translation/parser/compiler.rb +32 -13
- data/lib/prism/translation/ripper.rb +59 -59
- data/lib/prism/translation/ruby_parser.rb +66 -28
- data/lib/prism.rb +1 -1
- data/prism.gemspec +1 -1
- data/rbi/prism/node.rbi +5 -2
- data/rbi/prism/parse_result.rbi +62 -34
- data/rbi/prism/reflection.rbi +7 -13
- data/rbi/prism.rbi +9 -9
- data/sig/prism/node.rbs +4 -1
- data/sig/prism/parse_result.rbs +30 -10
- data/sig/prism/reflection.rbs +2 -8
- data/sig/prism/serialize.rbs +2 -3
- data/sig/prism.rbs +9 -9
- data/src/diagnostic.c +7 -1
- data/src/prism.c +16 -3
- data/src/util/pm_integer.c +9 -2
- metadata +2 -2
@@ -805,17 +805,29 @@ module Prism
|
|
805
805
|
# if /foo #{bar}/ then end
|
806
806
|
# ^^^^^^^^^^^^
|
807
807
|
def visit_interpolated_match_last_line_node(node)
|
808
|
-
|
808
|
+
parts = visit_interpolated_parts(node.parts)
|
809
|
+
regexp =
|
810
|
+
if parts.length == 1
|
811
|
+
s(node, :lit, Regexp.new(parts.first, node.options))
|
812
|
+
else
|
813
|
+
s(node, :dregx).concat(parts).tap do |result|
|
814
|
+
options = node.options
|
815
|
+
result << options if options != 0
|
816
|
+
end
|
817
|
+
end
|
818
|
+
|
819
|
+
s(node, :match, regexp)
|
809
820
|
end
|
810
821
|
|
811
822
|
# /foo #{bar}/
|
812
823
|
# ^^^^^^^^^^^^
|
813
824
|
def visit_interpolated_regular_expression_node(node)
|
814
|
-
|
815
|
-
|
816
|
-
|
825
|
+
parts = visit_interpolated_parts(node.parts)
|
826
|
+
|
827
|
+
if parts.length == 1
|
828
|
+
s(node, :lit, Regexp.new(parts.first, node.options))
|
817
829
|
else
|
818
|
-
s(node, :dregx).concat(
|
830
|
+
s(node, :dregx).concat(parts).tap do |result|
|
819
831
|
options = node.options
|
820
832
|
result << options if options != 0
|
821
833
|
end
|
@@ -825,45 +837,71 @@ module Prism
|
|
825
837
|
# "foo #{bar}"
|
826
838
|
# ^^^^^^^^^^^^
|
827
839
|
def visit_interpolated_string_node(node)
|
828
|
-
|
829
|
-
|
830
|
-
unescaped = node.parts.map { |part| part.is_a?(StringNode) ? part.unescaped : part.statements.body.first.unescaped }.join
|
831
|
-
s(node, :str, unescaped)
|
832
|
-
else
|
833
|
-
s(node, :dstr).concat(visit_interpolated_parts(node.parts))
|
834
|
-
end
|
840
|
+
parts = visit_interpolated_parts(node.parts)
|
841
|
+
parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts)
|
835
842
|
end
|
836
843
|
|
837
844
|
# :"foo #{bar}"
|
838
845
|
# ^^^^^^^^^^^^^
|
839
846
|
def visit_interpolated_symbol_node(node)
|
840
|
-
|
841
|
-
|
842
|
-
s(node, :lit, unescaped.to_sym)
|
843
|
-
else
|
844
|
-
s(node, :dsym).concat(visit_interpolated_parts(node.parts))
|
845
|
-
end
|
847
|
+
parts = visit_interpolated_parts(node.parts)
|
848
|
+
parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts)
|
846
849
|
end
|
847
850
|
|
848
851
|
# `foo #{bar}`
|
849
852
|
# ^^^^^^^^^^^^
|
850
853
|
def visit_interpolated_x_string_node(node)
|
851
|
-
|
852
|
-
|
854
|
+
source = node.heredoc? ? node.parts.first : node
|
855
|
+
parts = visit_interpolated_parts(node.parts)
|
856
|
+
parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts)
|
853
857
|
end
|
854
858
|
|
855
859
|
# Visit the interpolated content of the string-like node.
|
856
860
|
private def visit_interpolated_parts(parts)
|
857
|
-
|
858
|
-
|
859
|
-
|
860
|
-
|
861
|
+
visited = []
|
862
|
+
parts.each do |part|
|
863
|
+
result = visit(part)
|
864
|
+
|
865
|
+
if result[0] == :evstr && result[1]
|
866
|
+
if result[1][0] == :str
|
867
|
+
visited << result[1]
|
868
|
+
elsif result[1][0] == :dstr
|
869
|
+
visited.concat(result[1][1..-1])
|
870
|
+
else
|
871
|
+
visited << result
|
872
|
+
end
|
873
|
+
else
|
874
|
+
visited << result
|
875
|
+
end
|
876
|
+
end
|
877
|
+
|
878
|
+
state = :beginning #: :beginning | :string_content | :interpolated_content
|
879
|
+
|
880
|
+
visited.each_with_object([]) do |result, results|
|
881
|
+
case state
|
882
|
+
when :beginning
|
883
|
+
if result.is_a?(String)
|
884
|
+
results << result
|
885
|
+
state = :string_content
|
886
|
+
elsif result.is_a?(Array) && result[0] == :str
|
887
|
+
results << result[1]
|
888
|
+
state = :string_content
|
861
889
|
else
|
862
890
|
results << ""
|
863
|
-
results <<
|
891
|
+
results << result
|
892
|
+
state = :interpolated_content
|
893
|
+
end
|
894
|
+
when :string_content
|
895
|
+
if result.is_a?(String)
|
896
|
+
results[0] << result
|
897
|
+
elsif result.is_a?(Array) && result[0] == :str
|
898
|
+
results[0] << result[1]
|
899
|
+
else
|
900
|
+
results << result
|
901
|
+
state = :interpolated_content
|
864
902
|
end
|
865
903
|
else
|
866
|
-
results <<
|
904
|
+
results << result
|
867
905
|
end
|
868
906
|
end
|
869
907
|
end
|
@@ -1297,7 +1335,7 @@ module Prism
|
|
1297
1335
|
# __FILE__
|
1298
1336
|
# ^^^^^^^^
|
1299
1337
|
def visit_source_file_node(node)
|
1300
|
-
s(node, :str,
|
1338
|
+
s(node, :str, node.filepath)
|
1301
1339
|
end
|
1302
1340
|
|
1303
1341
|
# __LINE__
|
@@ -1498,7 +1536,7 @@ module Prism
|
|
1498
1536
|
# Parse the given source and translate it into the seattlerb/ruby_parser
|
1499
1537
|
# gem's Sexp format.
|
1500
1538
|
def parse(source, filepath = "(string)")
|
1501
|
-
translate(Prism.parse(source), filepath)
|
1539
|
+
translate(Prism.parse(source, filepath: filepath), filepath)
|
1502
1540
|
end
|
1503
1541
|
|
1504
1542
|
# Parse the given file and translate it into the seattlerb/ruby_parser
|
data/lib/prism.rb
CHANGED
@@ -37,7 +37,7 @@ module Prism
|
|
37
37
|
private_constant :LexRipper
|
38
38
|
|
39
39
|
# :call-seq:
|
40
|
-
# Prism::lex_compat(source, **options) ->
|
40
|
+
# Prism::lex_compat(source, **options) -> LexCompat::Result
|
41
41
|
#
|
42
42
|
# Returns a parse result whose value is an array of tokens that closely
|
43
43
|
# resembles the return value of Ripper::lex. The main difference is that the
|
data/prism.gemspec
CHANGED
data/rbi/prism/node.rbi
CHANGED
@@ -10,7 +10,7 @@ class Prism::Node
|
|
10
10
|
abstract!
|
11
11
|
|
12
12
|
sig { returns(Prism::Source) }
|
13
|
-
|
13
|
+
def source; end
|
14
14
|
|
15
15
|
sig { returns(Prism::Location) }
|
16
16
|
def location; end
|
@@ -3754,13 +3754,16 @@ class Prism::HashPatternNode < Prism::Node
|
|
3754
3754
|
def type; end
|
3755
3755
|
end
|
3756
3756
|
|
3757
|
-
# Represents the use of the `if` keyword, either in the block form or the modifier form.
|
3757
|
+
# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
|
3758
3758
|
#
|
3759
3759
|
# bar if foo
|
3760
3760
|
# ^^^^^^^^^^
|
3761
3761
|
#
|
3762
3762
|
# if foo then bar end
|
3763
3763
|
# ^^^^^^^^^^^^^^^^^^^
|
3764
|
+
#
|
3765
|
+
# foo ? bar : baz
|
3766
|
+
# ^^^^^^^^^^^^^^^
|
3764
3767
|
class Prism::IfNode < Prism::Node
|
3765
3768
|
sig { returns(T.nilable(Prism::Location)) }
|
3766
3769
|
def if_keyword_loc; end
|
data/rbi/prism/parse_result.rbi
CHANGED
@@ -2,13 +2,13 @@
|
|
2
2
|
|
3
3
|
class Prism::Source
|
4
4
|
sig { returns(String) }
|
5
|
-
|
5
|
+
def source; end
|
6
6
|
|
7
7
|
sig { returns(Integer) }
|
8
|
-
|
8
|
+
def start_line; end
|
9
9
|
|
10
10
|
sig { returns(T::Array[Integer]) }
|
11
|
-
|
11
|
+
def offsets; end
|
12
12
|
|
13
13
|
sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
|
14
14
|
def initialize(source, start_line = 1, offsets = []); end
|
@@ -43,13 +43,13 @@ end
|
|
43
43
|
|
44
44
|
class Prism::Location
|
45
45
|
sig { returns(Prism::Source) }
|
46
|
-
|
46
|
+
def source; end
|
47
47
|
|
48
48
|
sig { returns(Integer) }
|
49
|
-
|
49
|
+
def start_offset; end
|
50
50
|
|
51
51
|
sig { returns(Integer) }
|
52
|
-
|
52
|
+
def length; end
|
53
53
|
|
54
54
|
sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
|
55
55
|
def initialize(source, start_offset, length); end
|
@@ -140,7 +140,7 @@ class Prism::Comment
|
|
140
140
|
abstract!
|
141
141
|
|
142
142
|
sig { returns(Prism::Location) }
|
143
|
-
|
143
|
+
def location; end
|
144
144
|
|
145
145
|
sig { params(location: Prism::Location).void }
|
146
146
|
def initialize(location); end
|
@@ -173,10 +173,10 @@ end
|
|
173
173
|
|
174
174
|
class Prism::MagicComment
|
175
175
|
sig { returns(Prism::Location) }
|
176
|
-
|
176
|
+
def key_loc; end
|
177
177
|
|
178
178
|
sig { returns(Prism::Location) }
|
179
|
-
|
179
|
+
def value_loc; end
|
180
180
|
|
181
181
|
sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
|
182
182
|
def initialize(key_loc, value_loc); end
|
@@ -196,16 +196,16 @@ end
|
|
196
196
|
|
197
197
|
class Prism::ParseError
|
198
198
|
sig { returns(Symbol) }
|
199
|
-
|
199
|
+
def type; end
|
200
200
|
|
201
201
|
sig { returns(String) }
|
202
|
-
|
202
|
+
def message; end
|
203
203
|
|
204
204
|
sig { returns(Prism::Location) }
|
205
|
-
|
205
|
+
def location; end
|
206
206
|
|
207
207
|
sig { returns(Symbol) }
|
208
|
-
|
208
|
+
def level; end
|
209
209
|
|
210
210
|
sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
|
211
211
|
def initialize(type, message, location, level); end
|
@@ -219,16 +219,16 @@ end
|
|
219
219
|
|
220
220
|
class Prism::ParseWarning
|
221
221
|
sig { returns(Symbol) }
|
222
|
-
|
222
|
+
def type; end
|
223
223
|
|
224
224
|
sig { returns(String) }
|
225
|
-
|
225
|
+
def message; end
|
226
226
|
|
227
227
|
sig { returns(Prism::Location) }
|
228
|
-
|
228
|
+
def location; end
|
229
229
|
|
230
230
|
sig { returns(Symbol) }
|
231
|
-
|
231
|
+
def level; end
|
232
232
|
|
233
233
|
sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
|
234
234
|
def initialize(type, message, location, level); end
|
@@ -240,32 +240,27 @@ class Prism::ParseWarning
|
|
240
240
|
def inspect; end
|
241
241
|
end
|
242
242
|
|
243
|
-
class Prism::
|
244
|
-
|
245
|
-
|
246
|
-
sig { returns(Value) }
|
247
|
-
attr_reader :value
|
243
|
+
class Prism::Result
|
244
|
+
sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
|
245
|
+
def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
|
248
246
|
|
249
247
|
sig { returns(T::Array[Prism::Comment]) }
|
250
|
-
|
248
|
+
def comments; end
|
251
249
|
|
252
250
|
sig { returns(T::Array[Prism::MagicComment]) }
|
253
|
-
|
251
|
+
def magic_comments; end
|
254
252
|
|
255
253
|
sig { returns(T.nilable(Prism::Location)) }
|
256
|
-
|
254
|
+
def data_loc; end
|
257
255
|
|
258
256
|
sig { returns(T::Array[Prism::ParseError]) }
|
259
|
-
|
257
|
+
def errors; end
|
260
258
|
|
261
259
|
sig { returns(T::Array[Prism::ParseWarning]) }
|
262
|
-
|
260
|
+
def warnings; end
|
263
261
|
|
264
262
|
sig { returns(Prism::Source) }
|
265
|
-
|
266
|
-
|
267
|
-
sig { params(value: Value, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
|
268
|
-
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
|
263
|
+
def source; end
|
269
264
|
|
270
265
|
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
|
271
266
|
def deconstruct_keys(keys); end
|
@@ -280,15 +275,48 @@ class Prism::ParseResult
|
|
280
275
|
def failure?; end
|
281
276
|
end
|
282
277
|
|
278
|
+
class Prism::ParseResult < Prism::Result
|
279
|
+
sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
|
280
|
+
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
|
281
|
+
|
282
|
+
sig { returns(Prism::ProgramNode) }
|
283
|
+
def value; end
|
284
|
+
|
285
|
+
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
|
286
|
+
def deconstruct_keys(keys); end
|
287
|
+
end
|
288
|
+
|
289
|
+
class Prism::LexResult < Prism::Result
|
290
|
+
sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
|
291
|
+
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
|
292
|
+
|
293
|
+
sig { returns(T::Array[T.untyped]) }
|
294
|
+
def value; end
|
295
|
+
|
296
|
+
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
|
297
|
+
def deconstruct_keys(keys); end
|
298
|
+
end
|
299
|
+
|
300
|
+
class Prism::ParseLexResult < Prism::Result
|
301
|
+
sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
|
302
|
+
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
|
303
|
+
|
304
|
+
sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
|
305
|
+
def value; end
|
306
|
+
|
307
|
+
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
|
308
|
+
def deconstruct_keys(keys); end
|
309
|
+
end
|
310
|
+
|
283
311
|
class Prism::Token
|
284
312
|
sig { returns(Prism::Source) }
|
285
|
-
|
313
|
+
def source; end
|
286
314
|
|
287
315
|
sig { returns(Symbol) }
|
288
|
-
|
316
|
+
def type; end
|
289
317
|
|
290
318
|
sig { returns(String) }
|
291
|
-
|
319
|
+
def value; end
|
292
320
|
|
293
321
|
sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
|
294
322
|
def initialize(source, type, value, location); end
|
data/rbi/prism/reflection.rbi
CHANGED
@@ -4,11 +4,11 @@ module Prism::Reflection
|
|
4
4
|
end
|
5
5
|
|
6
6
|
class Prism::Reflection::Field
|
7
|
-
sig { returns(Symbol) }
|
8
|
-
attr_reader :name
|
9
|
-
|
10
7
|
sig { params(name: Symbol).void }
|
11
8
|
def initialize(name); end
|
9
|
+
|
10
|
+
sig { returns(Symbol) }
|
11
|
+
def name; end
|
12
12
|
end
|
13
13
|
|
14
14
|
class Prism::Reflection::NodeField < Prism::Reflection::Field
|
@@ -38,24 +38,18 @@ end
|
|
38
38
|
class Prism::Reflection::OptionalLocationField < Prism::Reflection::Field
|
39
39
|
end
|
40
40
|
|
41
|
-
class Prism::Reflection::
|
41
|
+
class Prism::Reflection::IntegerField < Prism::Reflection::Field
|
42
42
|
end
|
43
43
|
|
44
|
-
class Prism::Reflection::
|
44
|
+
class Prism::Reflection::FloatField < Prism::Reflection::Field
|
45
45
|
end
|
46
46
|
|
47
47
|
class Prism::Reflection::FlagsField < Prism::Reflection::Field
|
48
|
-
sig { returns(T::Array[Symbol]) }
|
49
|
-
attr_reader :flags
|
50
|
-
|
51
48
|
sig { params(name: Symbol, flags: T::Array[Symbol]).void }
|
52
49
|
def initialize(name, flags); end
|
53
|
-
end
|
54
|
-
|
55
|
-
class Prism::Reflection::IntegerField < Prism::Reflection::Field
|
56
|
-
end
|
57
50
|
|
58
|
-
|
51
|
+
sig { returns(T::Array[Symbol]) }
|
52
|
+
def flags; end
|
59
53
|
end
|
60
54
|
|
61
55
|
module Prism::Reflection
|
data/rbi/prism.rbi
CHANGED
@@ -7,28 +7,28 @@ module Prism
|
|
7
7
|
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
|
8
8
|
def self.dump_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
9
9
|
|
10
|
-
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::
|
10
|
+
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
|
11
11
|
def self.lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
12
12
|
|
13
|
-
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::
|
13
|
+
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
|
14
14
|
def self.lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
15
15
|
|
16
|
-
sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::
|
16
|
+
sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
|
17
17
|
def self.lex_compat(source, **options); end
|
18
18
|
|
19
19
|
sig { params(source: String).returns(T::Array[T.untyped]) }
|
20
20
|
def self.lex_ripper(source); end
|
21
21
|
|
22
|
-
sig { params(source: String, serialized: String).returns(Prism::ParseResult
|
22
|
+
sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
|
23
23
|
def self.load(source, serialized); end
|
24
24
|
|
25
|
-
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult
|
25
|
+
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
|
26
26
|
def self.parse(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
27
27
|
|
28
|
-
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult
|
28
|
+
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
|
29
29
|
def self.parse_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
30
30
|
|
31
|
-
sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult
|
31
|
+
sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
|
32
32
|
def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
33
33
|
|
34
34
|
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
|
@@ -37,10 +37,10 @@ module Prism
|
|
37
37
|
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
|
38
38
|
def self.parse_file_comments(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
39
39
|
|
40
|
-
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::
|
40
|
+
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
|
41
41
|
def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
42
42
|
|
43
|
-
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::
|
43
|
+
sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
|
44
44
|
def self.parse_lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
|
45
45
|
|
46
46
|
sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }
|
data/sig/prism/node.rbs
CHANGED
@@ -1515,13 +1515,16 @@ module Prism
|
|
1515
1515
|
def self.type: () -> :hash_pattern_node
|
1516
1516
|
end
|
1517
1517
|
|
1518
|
-
# Represents the use of the `if` keyword, either in the block form or the modifier form.
|
1518
|
+
# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
|
1519
1519
|
#
|
1520
1520
|
# bar if foo
|
1521
1521
|
# ^^^^^^^^^^
|
1522
1522
|
#
|
1523
1523
|
# if foo then bar end
|
1524
1524
|
# ^^^^^^^^^^^^^^^^^^^
|
1525
|
+
#
|
1526
|
+
# foo ? bar : baz
|
1527
|
+
# ^^^^^^^^^^^^^^^
|
1525
1528
|
class IfNode < Node
|
1526
1529
|
include _Node
|
1527
1530
|
|
data/sig/prism/parse_result.rbs
CHANGED
@@ -41,7 +41,7 @@ module Prism
|
|
41
41
|
def start_character_column: () -> Integer
|
42
42
|
def end_column: () -> Integer
|
43
43
|
def end_character_column: () -> Integer
|
44
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
44
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
45
45
|
def pretty_print: (untyped q) -> untyped
|
46
46
|
def join: (Location other) -> Location
|
47
47
|
end
|
@@ -50,7 +50,7 @@ module Prism
|
|
50
50
|
attr_reader location: Location
|
51
51
|
|
52
52
|
def initialize: (Location location) -> void
|
53
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
53
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
54
54
|
end
|
55
55
|
|
56
56
|
interface _Comment
|
@@ -76,7 +76,7 @@ module Prism
|
|
76
76
|
def key: () -> String
|
77
77
|
def value: () -> String
|
78
78
|
|
79
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
79
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
80
80
|
end
|
81
81
|
|
82
82
|
class ParseError
|
@@ -86,7 +86,7 @@ module Prism
|
|
86
86
|
attr_reader level: Symbol
|
87
87
|
|
88
88
|
def initialize: (Symbol type, String message, Location location, Symbol level) -> void
|
89
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
89
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
90
90
|
end
|
91
91
|
|
92
92
|
class ParseWarning
|
@@ -96,11 +96,10 @@ module Prism
|
|
96
96
|
attr_reader level: Symbol
|
97
97
|
|
98
98
|
def initialize: (Symbol type, String message, Location location, Symbol level) -> void
|
99
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
99
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
100
100
|
end
|
101
101
|
|
102
|
-
class
|
103
|
-
attr_reader value: T
|
102
|
+
class Result
|
104
103
|
attr_reader comments: Array[comment]
|
105
104
|
attr_reader magic_comments: Array[MagicComment]
|
106
105
|
attr_reader data_loc: Location?
|
@@ -108,12 +107,33 @@ module Prism
|
|
108
107
|
attr_reader warnings: Array[ParseWarning]
|
109
108
|
attr_reader source: Source
|
110
109
|
|
111
|
-
def initialize: (
|
112
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
110
|
+
def initialize: (Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
|
111
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
113
112
|
def success?: () -> bool
|
114
113
|
def failure?: () -> bool
|
115
114
|
end
|
116
115
|
|
116
|
+
class ParseResult < Result
|
117
|
+
attr_reader value: ProgramNode
|
118
|
+
|
119
|
+
def initialize: (ProgramNode value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
|
120
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
121
|
+
end
|
122
|
+
|
123
|
+
class LexResult < Result
|
124
|
+
attr_reader value: Array[[Token, Integer]]
|
125
|
+
|
126
|
+
def initialize: (Array[[Token, Integer]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
|
127
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
128
|
+
end
|
129
|
+
|
130
|
+
class ParseLexResult < Result
|
131
|
+
attr_reader value: [ProgramNode, Array[[Token, Integer]]]
|
132
|
+
|
133
|
+
def initialize: ([ProgramNode, Array[[Token, Integer]]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
|
134
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
135
|
+
end
|
136
|
+
|
117
137
|
class Token
|
118
138
|
attr_reader source: Source
|
119
139
|
attr_reader type: Symbol
|
@@ -121,7 +141,7 @@ module Prism
|
|
121
141
|
attr_reader location: Location
|
122
142
|
|
123
143
|
def initialize: (Source source, Symbol type, String value, Location location) -> void
|
124
|
-
def deconstruct_keys: (Array[Symbol] keys) ->
|
144
|
+
def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
|
125
145
|
def pretty_print: (untyped q) -> untyped
|
126
146
|
def ==: (untyped other) -> bool
|
127
147
|
end
|
data/sig/prism/reflection.rbs
CHANGED
@@ -33,10 +33,10 @@ module Prism
|
|
33
33
|
class OptionalLocationField < Field
|
34
34
|
end
|
35
35
|
|
36
|
-
class
|
36
|
+
class IntegerField < Field
|
37
37
|
end
|
38
38
|
|
39
|
-
class
|
39
|
+
class FloatField < Field
|
40
40
|
end
|
41
41
|
|
42
42
|
class FlagsField < Field
|
@@ -45,12 +45,6 @@ module Prism
|
|
45
45
|
def initialize: (Symbol name, Array[Symbol] flags) -> void
|
46
46
|
end
|
47
47
|
|
48
|
-
class IntegerField < Field
|
49
|
-
end
|
50
|
-
|
51
|
-
class DoubleField < Field
|
52
|
-
end
|
53
|
-
|
54
48
|
def self.fields_for: (node_singleton node) -> Array[Field]
|
55
49
|
end
|
56
50
|
end
|
data/sig/prism/serialize.rbs
CHANGED
@@ -1,7 +1,6 @@
|
|
1
1
|
module Prism
|
2
2
|
module Serialize
|
3
|
-
def self.load: (String, String) -> ParseResult
|
4
|
-
|
5
|
-
def self.load_tokens: (Source, String) -> ParseResult[Array[Token]] # TODO: check if array[token] is right
|
3
|
+
def self.load: (String, String) -> ParseResult
|
4
|
+
def self.load_tokens: (Source, String) -> LexResult
|
6
5
|
end
|
7
6
|
end
|