Remove the old Translator

Author: eregon

src/main/java/org/truffleruby/builtins/CoreMethodNodeManager.java

@@ -48,11 +48,11 @@
 import org.truffleruby.language.methods.InternalMethod;
 import org.truffleruby.language.methods.SharedMethodInfo;
 import org.truffleruby.language.objects.SingletonClassNode;
-import org.truffleruby.parser.Translator;
 
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.TruffleOptions;
 import com.oracle.truffle.api.dsl.NodeFactory;
+import org.truffleruby.parser.YARPTranslator;
 
 public final class CoreMethodNodeManager {
 
@@ -369,7 +369,7 @@ public static RubyCoreMethodRootNode createCoreMethodRootNode(NodeFactory<? exte
         final boolean needsSelf = needsSelf(method);
 
         if (needsSelf) {
-            RubyNode readSelfNode = Translator.profileArgument(language, new ReadSelfNode());
+            RubyNode readSelfNode = YARPTranslator.profileArgument(language, new ReadSelfNode());
             argumentsNodes[i++] = transformArgument(method, readSelfNode, 0);
         }
 
@@ -378,7 +378,7 @@ public static RubyCoreMethodRootNode createCoreMethodRootNode(NodeFactory<? exte
         final int nArgs = required + optional;
 
         for (int n = 0; n < nArgs; n++) {
-            RubyNode readArgumentNode = Translator
+            RubyNode readArgumentNode = YARPTranslator
                     .profileArgument(language, new ReadPreArgumentNode(n, false, MissingArgumentBehavior.NOT_PROVIDED));
             argumentsNodes[i++] = transformArgument(method, readArgumentNode, n + 1);
         }

src/main/java/org/truffleruby/builtins/PrimitiveNodeConstructor.java

@@ -17,7 +17,6 @@
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.SourceIndexLength;
-import org.truffleruby.parser.Translator;
 
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.source.Source;
@@ -60,7 +59,8 @@ public RubyNode createInvokePrimitiveNode(Source source, SourceIndexLength sourc
         }
 
         final RubyNode primitiveNode = (RubyNode) CoreMethodNodeManager.createNodeFromFactory(factory, arguments);
-        return Translator.withSourceSection(sourceSection, primitiveNode);
+        primitiveNode.unsafeSetSourceSection(sourceSection);
+        return primitiveNode;
     }
 
 }

src/main/java/org/truffleruby/core/inlined/LambdaToProcNode.java

@@ -16,15 +16,15 @@
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.methods.BlockDefinitionNode;
-import org.truffleruby.parser.MethodTranslator;
+import org.truffleruby.parser.YARPBlockNodeTranslator;
 
 /** Wraps a {@link BlockDefinitionNode} to convert the returned block (which should be a {@link ProcType#LAMBDA}) to be
  * a proc.
  *
  * <p>
  * When we encounter a function named {@code lambda} which is called with a block, we speculatively create a lambda call
- * target for that block in {@link MethodTranslator}. But if that method does not refer to {@code Kernel#lambda}, then a
- * proc call target is needed instead. This node is thus needed to "deoptimize" such cases. */
+ * target for that block in {@link YARPBlockNodeTranslator}. But if that method does not refer to {@code Kernel#lambda},
+ * then a proc call target is needed instead. This node is thus needed to "deoptimize" such cases. */
 public final class LambdaToProcNode extends RubyContextSourceNode {
 
     /** A {@link BlockDefinitionNode}, possibly wrapped in a RubyNodeWrapper by instrumentation */

src/main/java/org/truffleruby/core/proc/ProcCallTargets.java

@@ -18,15 +18,15 @@
 import org.truffleruby.language.RubyProcRootNode;
 import org.truffleruby.language.RubyRootNode;
 import org.truffleruby.language.methods.BlockDefinitionNode;
-import org.truffleruby.parser.MethodTranslator;
+import org.truffleruby.parser.YARPBlockNodeTranslator;
 
 import java.util.function.Supplier;
 
 /** Holds compiled call target for a {@link BlockDefinitionNode} (one instance per node). Each {@link RubyProc} created
  * by evaluating the definition has a reference to one of these. The point is that there are two possible call targets
- * for blocks: the proc and the lambda one. We only eagerly compile one in {@link MethodTranslator#compileBlockNode},
- * but we might need to later compile the other, given a {@link RubyProc} instance. This class thus acts as a shared
- * cache for the call targets. */
+ * for blocks: the proc and the lambda one. We only eagerly compile one in
+ * {@link YARPBlockNodeTranslator#compileBlockNode}, but we might need to later compile the other, given a
+ * {@link RubyProc} instance. This class thus acts as a shared cache for the call targets. */
 public final class ProcCallTargets {
 
     // At least one of those two call targets won't be null.

src/main/java/org/truffleruby/language/methods/BlockDefinitionNode.java

@@ -23,7 +23,7 @@
 import org.truffleruby.language.control.FrameOnStackMarker;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
-import org.truffleruby.parser.Translator;
+import org.truffleruby.parser.YARPTranslator;
 
 /** Create a Ruby Proc to pass as a block to the called method. The literal block is represented as call targets and a
  * SharedMethodInfo. This is executed at the call site just before dispatch. */
@@ -41,7 +41,7 @@ public BlockDefinitionNode(
             ProcCallTargets callTargets,
             BreakID breakID,
             int frameOnStackMarkerSlot) {
-        assert (type == ProcType.PROC) == (frameOnStackMarkerSlot != Translator.NO_FRAME_ON_STACK_MARKER);
+        assert (type == ProcType.PROC) == (frameOnStackMarkerSlot != YARPTranslator.NO_FRAME_ON_STACK_MARKER);
         this.type = type;
         this.sharedMethodInfo = sharedMethodInfo;
         this.callTargets = callTargets;
@@ -62,7 +62,7 @@ RubyProc doBlockDefinition(VirtualFrame frame,
             @Cached GetSpecialVariableStorage readSpecialVariableStorageNode,
             @Cached WithoutVisibilityNode withoutVisibilityNode) {
         final FrameOnStackMarker frameOnStackMarker;
-        if (frameOnStackMarkerSlot != Translator.NO_FRAME_ON_STACK_MARKER) {
+        if (frameOnStackMarkerSlot != YARPTranslator.NO_FRAME_ON_STACK_MARKER) {
             frameOnStackMarker = (FrameOnStackMarker) frame.getObject(frameOnStackMarkerSlot);
             assert frameOnStackMarker != null;
         } else {