1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
|
# frozen_string_literal: true
# Here we are reopening the prism module to provide methods on nodes that aren't
# templated and are meant as convenience methods.
module Prism
module RegularExpressionOptions # :nodoc:
# Returns a numeric value that represents the flags that were used to create
# the regular expression.
def options
o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
o
end
end
class InterpolatedMatchLastLineNode < Node
include RegularExpressionOptions
end
class InterpolatedRegularExpressionNode < Node
include RegularExpressionOptions
end
class MatchLastLineNode < Node
include RegularExpressionOptions
end
class RegularExpressionNode < Node
include RegularExpressionOptions
end
private_constant :RegularExpressionOptions
module HeredocQuery # :nodoc:
# Returns true if this node was represented as a heredoc in the source code.
def heredoc?
opening&.start_with?("<<")
end
end
class InterpolatedStringNode < Node
include HeredocQuery
end
class InterpolatedXStringNode < Node
include HeredocQuery
end
class StringNode < Node
include HeredocQuery
# Occasionally it's helpful to treat a string as if it were interpolated so
# that there's a consistent interface for working with strings.
def to_interpolated
InterpolatedStringNode.new(
source,
frozen? ? InterpolatedStringNodeFlags::FROZEN : 0,
opening_loc,
[copy(opening_loc: nil, closing_loc: nil, location: content_loc)],
closing_loc,
location
)
end
end
class XStringNode < Node
include HeredocQuery
# Occasionally it's helpful to treat a string as if it were interpolated so
# that there's a consistent interface for working with strings.
def to_interpolated
InterpolatedXStringNode.new(
source,
opening_loc,
[StringNode.new(source, 0, nil, content_loc, nil, unescaped, content_loc)],
closing_loc,
location
)
end
end
private_constant :HeredocQuery
class ImaginaryNode < Node
# Returns the value of the node as a Ruby Complex.
def value
Complex(0, numeric.value)
end
end
class RationalNode < Node
# Returns the value of the node as a Ruby Rational.
def value
Rational(numeric.is_a?(IntegerNode) ? numeric.value : slice.chomp("r"))
end
end
class ConstantReadNode < Node
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
def full_name_parts
[name]
end
# Returns the full name of this constant. For example: "Foo"
def full_name
name.to_s
end
end
class ConstantWriteNode < Node
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
def full_name_parts
[name]
end
# Returns the full name of this constant. For example: "Foo"
def full_name
name.to_s
end
end
class ConstantPathNode < Node
# An error class raised when dynamic parts are found while computing a
# constant path's full name. For example:
# Foo::Bar::Baz -> does not raise because all parts of the constant path are
# simple constants
# var::Bar::Baz -> raises because the first part of the constant path is a
# local variable
class DynamicPartsInConstantPathError < StandardError; end
# An error class raised when missing nodes are found while computing a
# constant path's full name. For example:
# Foo:: -> raises because the constant path is missing the last part
class MissingNodesInConstantPathError < StandardError; end
# Returns the list of parts for the full name of this constant path.
# For example: [:Foo, :Bar]
def full_name_parts
parts = [] #: Array[Symbol]
current = self #: node?
while current.is_a?(ConstantPathNode)
child = current.child
if child.is_a?(MissingNode)
raise MissingNodesInConstantPathError, "Constant path contains missing nodes. Cannot compute full name"
end
parts.unshift(child.name)
current = current.parent
end
if !current.is_a?(ConstantReadNode) && !current.nil?
raise DynamicPartsInConstantPathError, "Constant path contains dynamic parts. Cannot compute full name"
end
parts.unshift(current&.name || :"")
end
# Returns the full name of this constant path. For example: "Foo::Bar"
def full_name
full_name_parts.join("::")
end
end
class ConstantPathTargetNode < Node
# Returns the list of parts for the full name of this constant path.
# For example: [:Foo, :Bar]
def full_name_parts
parts =
case parent
when ConstantPathNode, ConstantReadNode
parent.full_name_parts
when nil
[:""]
else
# e.g. self::Foo, (var)::Bar = baz
raise ConstantPathNode::DynamicPartsInConstantPathError, "Constant target path contains dynamic parts. Cannot compute full name"
end
if child.is_a?(MissingNode)
raise ConstantPathNode::MissingNodesInConstantPathError, "Constant target path contains missing nodes. Cannot compute full name"
end
parts.push(child.name)
end
# Returns the full name of this constant path. For example: "Foo::Bar"
def full_name
full_name_parts.join("::")
end
end
class ConstantTargetNode < Node
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
def full_name_parts
[name]
end
# Returns the full name of this constant. For example: "Foo"
def full_name
name.to_s
end
end
class ParametersNode < Node
# Mirrors the Method#parameters method.
def signature
names = [] #: Array[[Symbol, Symbol] | [Symbol]]
requireds.each do |param|
names << (param.is_a?(MultiTargetNode) ? [:req] : [:req, param.name])
end
optionals.each { |param| names << [:opt, param.name] }
if rest && rest.is_a?(RestParameterNode)
names << [:rest, rest.name || :*]
end
posts.each do |param|
if param.is_a?(MultiTargetNode)
names << [:req]
elsif param.is_a?(NoKeywordsParameterNode)
# Invalid syntax, e.g. "def f(**nil, ...)" moves the NoKeywordsParameterNode to posts
raise "Invalid syntax"
else
names << [:req, param.name]
end
end
# Regardless of the order in which the keywords were defined, the required
# keywords always come first followed by the optional keywords.
keyopt = [] #: Array[OptionalKeywordParameterNode]
keywords.each do |param|
if param.is_a?(OptionalKeywordParameterNode)
keyopt << param
else
names << [:keyreq, param.name]
end
end
keyopt.each { |param| names << [:key, param.name] }
case keyword_rest
when ForwardingParameterNode
names.concat([[:rest, :*], [:keyrest, :**], [:block, :&]])
when KeywordRestParameterNode
names << [:keyrest, keyword_rest.name || :**]
when NoKeywordsParameterNode
names << [:nokey]
end
names << [:block, block.name || :&] if block
names
end
end
end
|