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
|
# frozen_string_literal: true
module RuboCop
module AST
# Common functionality between the parser and prism builder
# @api private
module BuilderExtensions
def self.included(base)
base.emit_forward_arg = true
base.emit_match_pattern = true
end
# @api private
NODE_MAP = {
and: AndNode,
and_asgn: AndAsgnNode,
alias: AliasNode,
arg: ArgNode,
blockarg: ArgNode,
forward_arg: ArgNode,
kwarg: ArgNode,
kwoptarg: ArgNode,
kwrestarg: ArgNode,
optarg: ArgNode,
restarg: ArgNode,
shadowarg: ArgNode,
args: ArgsNode,
array: ArrayNode,
lvasgn: AsgnNode,
ivasgn: AsgnNode,
cvasgn: AsgnNode,
gvasgn: AsgnNode,
block: BlockNode,
numblock: BlockNode,
itblock: BlockNode,
break: BreakNode,
case_match: CaseMatchNode,
casgn: CasgnNode,
case: CaseNode,
class: ClassNode,
complex: ComplexNode,
const: ConstNode,
def: DefNode,
defined?: DefinedNode,
defs: DefNode,
dstr: DstrNode,
ensure: EnsureNode,
for: ForNode,
forward_args: ForwardArgsNode,
forwarded_kwrestarg: KeywordSplatNode,
float: FloatNode,
hash: HashNode,
if: IfNode,
in_pattern: InPatternNode,
int: IntNode,
index: IndexNode,
indexasgn: IndexasgnNode,
irange: RangeNode,
erange: RangeNode,
kwargs: HashNode,
kwbegin: KeywordBeginNode,
kwsplat: KeywordSplatNode,
lambda: LambdaNode,
masgn: MasgnNode,
mlhs: MlhsNode,
module: ModuleNode,
next: NextNode,
op_asgn: OpAsgnNode,
or_asgn: OrAsgnNode,
or: OrNode,
pair: PairNode,
procarg0: Procarg0Node,
rational: RationalNode,
regexp: RegexpNode,
rescue: RescueNode,
resbody: ResbodyNode,
return: ReturnNode,
csend: CsendNode,
send: SendNode,
str: StrNode,
xstr: StrNode,
sclass: SelfClassNode,
super: SuperNode,
zsuper: SuperNode,
sym: SymbolNode,
until: UntilNode,
until_post: UntilNode,
lvar: VarNode,
ivar: VarNode,
cvar: VarNode,
gvar: VarNode,
when: WhenNode,
while: WhileNode,
while_post: WhileNode,
yield: YieldNode
}.freeze
# Generates {Node} from the given information.
#
# @return [Node] the generated node
def n(type, children, source_map)
node_klass(type).new(type, children, location: source_map)
end
# Overwrite the base method to allow strings with invalid encoding
# More details here https://github.com/whitequark/parser/issues/283
def string_value(token)
value(token)
end
private
def node_klass(type)
NODE_MAP[type] || Node
end
end
# `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser`
# generate ASTs with {RuboCop::AST::Node}.
#
# @example
# buffer = Parser::Source::Buffer.new('(string)')
# buffer.source = 'puts :foo'
#
# builder = RuboCop::AST::Builder.new
# require 'parser/ruby25'
# parser = Parser::Ruby25.new(builder)
# root_node = parser.parse(buffer)
class Builder < Parser::Builders::Default
include BuilderExtensions
end
end
end
|
