Skip to content

Commit 09225a1

Browse files
eregoneregon
committed
Cleanups
1 parent 51e30b3 commit 09225a1

File tree

4 files changed

+78
-156
lines changed

4 files changed

+78
-156
lines changed

‎src/main/java/org/truffleruby/parser/BodyTranslator.java

Lines changed: 4 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,6 @@
9393
import org.truffleruby.language.control.WhileNode;
9494
import org.truffleruby.language.defined.DefinedNode;
9595
import org.truffleruby.language.defined.DefinedWrapperNode;
96-
import org.truffleruby.language.dispatch.RubyCallNode;
9796
import org.truffleruby.language.dispatch.RubyCallNodeParameters;
9897
import org.truffleruby.language.exceptions.EnsureNode;
9998
import org.truffleruby.language.exceptions.RescueStandardErrorNode;
@@ -777,16 +776,7 @@ public RubyNode visitCaseNode(CaseParseNode node) {
777776
method = "when_splat";
778777
arguments = new RubyNode[]{ rubyExpression, NodeUtil.cloneNode(readTemp) };
779778
}
780-
final RubyCallNodeParameters callParameters = new RubyCallNodeParameters(
781-
receiver,
782-
method,
783-
null,
784-
EmptyArgumentsDescriptor.INSTANCE,
785-
arguments,
786-
false,
787-
true);
788-
final RubyNode conditionNode = language.coreMethodAssumptions
789-
.createCallNode(callParameters);
779+
final RubyNode conditionNode = createCallNode(receiver, method, arguments);
790780

791781
// Create the if node
792782
final RubyNode thenNode = translateNodeOrNil(sourceSection, when.getBodyNode());
@@ -2249,15 +2239,7 @@ public RubyNode visitOpAsgnConstDeclNode(OpAsgnConstDeclParseNode node) {
22492239

22502240
default: {
22512241
final SourceIndexLength sourceSection = node.getPosition();
2252-
final RubyCallNodeParameters callParameters = new RubyCallNodeParameters(
2253-
lhs,
2254-
node.getOperator(),
2255-
null,
2256-
EmptyArgumentsDescriptor.INSTANCE,
2257-
new RubyNode[]{ rhs },
2258-
false,
2259-
true);
2260-
final RubyNode opNode = language.coreMethodAssumptions.createCallNode(callParameters);
2242+
final RubyNode opNode = createCallNode(lhs, node.getOperator(), rhs);
22612243
final RubyNode ret = lhs.makeWriteNode(opNode);
22622244
ret.unsafeSetSourceSection(sourceSection);
22632245
return addNewlineIfNeeded(node, ret);
@@ -2589,15 +2571,8 @@ private RubyNode translateRationalComplex(SourceIndexLength sourceSection, Strin
25892571
final RubyNode moduleNode = new ObjectClassLiteralNode();
25902572
ReadConstantNode receiver = new ReadConstantNode(moduleNode, name);
25912573
RubyNode[] arguments = new RubyNode[]{ a, b };
2592-
RubyCallNodeParameters parameters = new RubyCallNodeParameters(
2593-
receiver,
2594-
"convert",
2595-
null,
2596-
EmptyArgumentsDescriptor.INSTANCE,
2597-
arguments,
2598-
false,
2599-
true);
2600-
return withSourceSection(sourceSection, new RubyCallNode(parameters));
2574+
var callNode = createCallNode(receiver, "convert", arguments);
2575+
return withSourceSection(sourceSection, callNode);
26012576
}
26022577

26032578
@Override

‎src/main/java/org/truffleruby/parser/PatternMatchingTranslator.java

Lines changed: 55 additions & 124 deletions
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,10 @@
1717
import org.truffleruby.core.array.ArraySliceNodeGen;
1818
import org.truffleruby.language.RubyNode;
1919
import org.truffleruby.language.SourceIndexLength;
20-
import org.truffleruby.language.arguments.EmptyArgumentsDescriptor;
2120
import org.truffleruby.language.control.AndNode;
2221
import org.truffleruby.language.control.ExecuteAndReturnTrueNode;
2322
import org.truffleruby.language.control.NotNode;
2423
import org.truffleruby.language.control.RaiseException;
25-
import org.truffleruby.language.dispatch.RubyCallNodeParameters;
2624
import org.truffleruby.language.literal.NilLiteralNode;
2725
import org.truffleruby.language.literal.TruffleInternalModuleLiteralNode;
2826
import org.truffleruby.language.locals.ReadLocalNode;
@@ -77,6 +75,39 @@ public PatternMatchingTranslator(
7775
this.bodyTranslator = bodyTranslator;
7876
}
7977

78+
public RubyNode translatePatternNode(ParseNode patternNode, RubyNode expressionValue) {
79+
currentValueToMatch = expressionValue;
80+
81+
// TODO move the other cases to the visitor pattern
82+
switch (patternNode.getNodeType()) {
83+
case ARRAYPATTERNNODE:
84+
return this.visitArrayPatternNode((ArrayPatternParseNode) patternNode);
85+
case HASHPATTERNNODE: // both of these throw the same exception, hence this is skipped.
86+
case FINDPATTERNNODE:
87+
final RubyContext context = RubyLanguage.getCurrentContext();
88+
throw new RaiseException(
89+
context,
90+
context.getCoreExceptions().syntaxError(
91+
"not yet handled in pattern matching: " + patternNode + " " + patternNode.getPosition(),
92+
currentNode,
93+
patternNode.getPosition().toSourceSection(source)));
94+
case IFNODE: // handles both if and unless
95+
var ifNode = (IfParseNode) patternNode;
96+
RubyNode pattern;
97+
RubyNode condition = ifNode.getCondition().accept(bodyTranslator);
98+
if (ifNode.getThenBody() != null) {
99+
pattern = translatePatternNode(ifNode.getThenBody(), expressionValue);
100+
} else {
101+
pattern = translatePatternNode(ifNode.getElseBody(), expressionValue);
102+
condition = new NotNode(condition);
103+
}
104+
105+
return new AndNode(pattern, condition);
106+
default:
107+
return createCallNode(patternNode.accept(this), "===", NodeUtil.cloneNode(expressionValue));
108+
}
109+
}
110+
80111
@Override
81112
protected RubyNode defaultVisit(ParseNode node) {
82113
final RubyContext context = RubyLanguage.getCurrentContext();
@@ -90,29 +121,17 @@ protected RubyNode defaultVisit(ParseNode node) {
90121

91122
@Override
92123
public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNode) {
93-
final RubyCallNodeParameters deconstructCallParameters;
94-
final RubyNode receiver;
95-
final RubyNode deconstructed;
96124
final SourceIndexLength sourceSection = arrayPatternParseNode.getPosition();
97125

98-
ListParseNode preNodes = arrayPatternParseNode.getPreArgs();
99-
ListParseNode postNodes = arrayPatternParseNode.getPostArgs();
100-
ParseNode restNode = arrayPatternParseNode.getRestArg();
101-
102-
receiver = new TruffleInternalModuleLiteralNode();
103-
receiver.unsafeSetSourceSection(sourceSection);
104-
deconstructCallParameters = new RubyCallNodeParameters(
105-
receiver,
106-
"deconstruct_checked",
107-
null,
108-
EmptyArgumentsDescriptor.INSTANCE,
109-
new RubyNode[]{ currentValueToMatch },
110-
false,
111-
true);
112-
deconstructed = language.coreMethodAssumptions.createCallNode(deconstructCallParameters);
113-
114-
final int deconSlot = environment.declareLocalTemp("p_decon_array");
115-
final ReadLocalNode readTemp = environment.readNode(deconSlot, sourceSection);
126+
var preNodes = arrayPatternParseNode.getPreArgs();
127+
var postNodes = arrayPatternParseNode.getPostArgs();
128+
var restNode = arrayPatternParseNode.getRestArg();
129+
130+
var deconstructed = createCallNode(new TruffleInternalModuleLiteralNode(), "deconstruct_checked",
131+
currentValueToMatch);
132+
133+
final int deconstructedSlot = environment.declareLocalTemp("p_decon_array");
134+
final ReadLocalNode readTemp = environment.readNode(deconstructedSlot, sourceSection);
116135
final RubyNode assignTemp = readTemp.makeWriteNode(deconstructed);
117136
currentValueToMatch = readTemp;
118137

@@ -121,44 +140,27 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
121140
RubyNode condition = new ArrayPatternLengthCheckNode(arrayPatternParseNode.minimumArgsNum(),
122141
currentValueToMatch, arrayPatternParseNode.hasRestArg());
123142

124-
// Constant == pattern.deconstruct
143+
// Constant === pattern.deconstruct
125144
if (arrayPatternParseNode.hasConstant()) {
126145
ConstParseNode constant = (ConstParseNode) arrayPatternParseNode.getConstant();
127146
RubyNode constVal = constant.accept(this);
128-
final RubyCallNodeParameters instanceCheckParameters = new RubyCallNodeParameters(
129-
constVal,
130-
"===",
131-
null,
132-
EmptyArgumentsDescriptor.INSTANCE,
133-
new RubyNode[]{ currentValueToMatch },
134-
false,
135-
true);
136-
RubyNode isInstance = language.coreMethodAssumptions.createCallNode(instanceCheckParameters);
147+
var isInstance = createCallNode(constVal, "===", currentValueToMatch);
137148
condition = new AndNode(isInstance, condition);
138149
}
139150

140151
for (int i = 0; i < preSize; i++) {
141-
ParseNode loopPreNode = preNodes.get(i);
152+
var preNode = preNodes.get(i);
142153
RubyNode translatedPatternElement;
143154
RubyNode prev = currentValueToMatch;
144155
var exprElement = ArrayIndexNodes.ReadConstantIndexNode.create(currentValueToMatch, i);
145156
currentValueToMatch = exprElement;
146157
try {
147-
translatedPatternElement = loopPreNode.accept(this);
158+
translatedPatternElement = preNode.accept(this);
148159
} finally {
149160
currentValueToMatch = prev;
150161
}
151162

152-
var parameters = new RubyCallNodeParameters(
153-
translatedPatternElement,
154-
"===",
155-
null,
156-
EmptyArgumentsDescriptor.INSTANCE,
157-
new RubyNode[]{ NodeUtil.cloneNode(exprElement) },
158-
false,
159-
true);
160-
161-
var callNode = language.coreMethodAssumptions.createCallNode(parameters);
163+
var callNode = createCallNode(translatedPatternElement, "===", NodeUtil.cloneNode(exprElement));
162164
condition = new AndNode(condition, callNode);
163165
}
164166

@@ -198,16 +200,11 @@ public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNod
198200
currentValueToMatch = prev;
199201
}
200202

201-
var parameters = new RubyCallNodeParameters(
203+
var callNode = createCallNode(
202204
translatedPatternElement,
203205
"===",
204-
null,
205-
EmptyArgumentsDescriptor.INSTANCE,
206-
new RubyNode[]{ NodeUtil.cloneNode(exprElement) },
207-
false,
208-
true);
206+
NodeUtil.cloneNode(exprElement));
209207

210-
var callNode = language.coreMethodAssumptions.createCallNode(parameters);
211208
condition = new AndNode(condition, callNode);
212209
}
213210
}
@@ -221,79 +218,13 @@ public RubyNode visitFindPatternNode(FindPatternParseNode findPatternParseNode)
221218

222219
@Override
223220
public RubyNode visitHashPatternNode(HashPatternParseNode node) {
224-
final RubyCallNodeParameters deconstructCallParameters;
225-
final RubyCallNodeParameters matcherCallParameters;
226-
final RubyCallNodeParameters matcherCallParametersPost;
227-
final RubyNode receiver;
228-
final RubyNode deconstructed;
229-
deconstructCallParameters = new RubyCallNodeParameters(
230-
currentValueToMatch,
231-
"deconstruct_keys",
232-
null,
233-
EmptyArgumentsDescriptor.INSTANCE,
234-
new RubyNode[]{ new NilLiteralNode(true) },
235-
false,
236-
true);
237-
deconstructed = language.coreMethodAssumptions.createCallNode(deconstructCallParameters);
238-
239-
receiver = new TruffleInternalModuleLiteralNode();
240-
receiver.unsafeSetSourceSection(node.getPosition());
241-
242-
matcherCallParameters = new RubyCallNodeParameters(
243-
receiver,
244-
"hash_pattern_matches?",
245-
null,
246-
EmptyArgumentsDescriptor.INSTANCE,
247-
new RubyNode[]{ node.accept(this), NodeUtil.cloneNode(deconstructed) },
248-
false,
249-
true);
221+
var deconstructed = createCallNode(currentValueToMatch, "deconstruct_keys", new NilLiteralNode(true));
250222

251-
return language.coreMethodAssumptions.createCallNode(matcherCallParameters);
252-
}
253-
254-
public RubyNode translatePatternNode(ParseNode patternNode, RubyNode expressionValue) {
255-
final RubyCallNodeParameters matcherCallParameters;
256-
257-
currentValueToMatch = expressionValue;
258-
259-
260-
// TODO move the other cases to the visitor pattern
261-
switch (patternNode.getNodeType()) {
262-
case ARRAYPATTERNNODE:
263-
return this.visitArrayPatternNode((ArrayPatternParseNode) patternNode);
264-
case HASHPATTERNNODE: // both of these throw the same exception, hence this is skipped.
265-
case FINDPATTERNNODE:
266-
final RubyContext context = RubyLanguage.getCurrentContext();
267-
var node = patternNode;
268-
throw new RaiseException(
269-
context,
270-
context.getCoreExceptions().syntaxError(
271-
"not yet handled in pattern matching: " + node + " " + node.getPosition(),
272-
currentNode,
273-
node.getPosition().toSourceSection(source)));
274-
case IFNODE: // handles both if and unless
275-
var ifNode = (IfParseNode) patternNode;
276-
RubyNode pattern;
277-
RubyNode condition = ifNode.getCondition().accept(bodyTranslator);
278-
if (ifNode.getThenBody() != null) {
279-
pattern = translatePatternNode(ifNode.getThenBody(), expressionValue);
280-
} else {
281-
pattern = translatePatternNode(ifNode.getElseBody(), expressionValue);
282-
condition = new NotNode(condition);
283-
}
284-
285-
return new AndNode(pattern, condition);
286-
default:
287-
matcherCallParameters = new RubyCallNodeParameters(
288-
patternNode.accept(this),
289-
"===",
290-
null,
291-
EmptyArgumentsDescriptor.INSTANCE,
292-
new RubyNode[]{ NodeUtil.cloneNode(expressionValue) },
293-
false,
294-
true);
295-
return language.coreMethodAssumptions.createCallNode(matcherCallParameters);
296-
}
223+
return createCallNode(
224+
new TruffleInternalModuleLiteralNode(),
225+
"hash_pattern_matches?",
226+
node.accept(this),
227+
NodeUtil.cloneNode(deconstructed));
297228
}
298229

299230
@Override

‎src/main/java/org/truffleruby/parser/Translator.java

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,14 @@
1515

1616
import org.truffleruby.RubyLanguage;
1717
import org.truffleruby.debug.ChaosNode;
18+
import org.truffleruby.language.RubyContextSourceNode;
1819
import org.truffleruby.language.RubyNode;
1920
import org.truffleruby.language.SourceIndexLength;
21+
import org.truffleruby.language.arguments.EmptyArgumentsDescriptor;
2022
import org.truffleruby.language.arguments.ProfileArgumentNodeGen;
2123
import org.truffleruby.language.arguments.ReadSelfNode;
2224
import org.truffleruby.language.control.SequenceNode;
25+
import org.truffleruby.language.dispatch.RubyCallNodeParameters;
2326
import org.truffleruby.language.literal.NilLiteralNode;
2427
import org.truffleruby.language.locals.WriteLocalVariableNode;
2528
import org.truffleruby.language.objects.SelfNode;
@@ -168,4 +171,17 @@ protected static RubyNode[] createArray(int size) {
168171
return size == 0 ? RubyNode.EMPTY_ARRAY : new RubyNode[size];
169172
}
170173

174+
/** Uses ignoreVisibility=true */
175+
protected RubyContextSourceNode createCallNode(RubyNode receiver, String method, RubyNode... arguments) {
176+
var parameters = new RubyCallNodeParameters(
177+
receiver,
178+
method,
179+
null,
180+
EmptyArgumentsDescriptor.INSTANCE,
181+
arguments,
182+
false,
183+
true);
184+
return language.coreMethodAssumptions.createCallNode(parameters);
185+
}
186+
171187
}

‎src/main/ruby/truffleruby/core/truffle/internal.rb

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -59,9 +59,9 @@ def self.when_splat(cases, expression)
5959

6060
def self.deconstruct_checked(pattern)
6161
if pattern.respond_to? :deconstruct
62-
decon = pattern.deconstruct
63-
if Primitive.object_kind_of?(decon, Array)
64-
decon
62+
deconstructed = pattern.deconstruct
63+
if Primitive.object_kind_of?(deconstructed, Array)
64+
deconstructed
6565
else
6666
raise TypeError,'deconstruct must return Array'
6767
end

0 commit comments

Comments
 (0)