Remove dead code

Author: eregon

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

@@ -219,7 +219,6 @@
 import org.truffleruby.parser.ast.NilImplicitParseNode;
 import org.truffleruby.parser.ast.NilParseNode;
 import org.truffleruby.parser.ast.NilRestArgParseNode;
-import org.truffleruby.parser.ast.NodeType;
 import org.truffleruby.parser.ast.NthRefParseNode;
 import org.truffleruby.parser.ast.OpAsgnAndParseNode;
 import org.truffleruby.parser.ast.OpAsgnConstDeclParseNode;
@@ -883,122 +882,6 @@ public RubyNode visitCaseInNode(CaseInParseNode node) {
         return addNewlineIfNeeded(node, ret);
     }
 
-    // probably remove this later.
-    private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionNode, RubyNode expressionValue,
-            SourceIndexLength sourceSection) {
-        final RubyCallNodeParameters deconstructCallParameters;
-        final RubyCallNodeParameters matcherCallParameters;
-        final RubyNode receiver;
-        final RubyNode deconstructed;
-
-        switch (patternNode.getNodeType()) {
-            case ARRAYNODE:
-                // Pattern-match element-wise recursively if possible.
-                final int size = ((ArrayParseNode) patternNode).size();
-                if (expressionNode.getNodeType() == NodeType.ARRAYNODE &&
-                        ((ArrayParseNode) expressionNode).size() == size) {
-                    final ParseNode[] patternElements = ((ArrayParseNode) patternNode).children();
-                    final ParseNode[] expressionElements = ((ArrayParseNode) expressionNode).children();
-
-                    final RubyNode[] matches = new RubyNode[size];
-
-                    // For each element of the case expression, evaluate and assign it, then run the pattern-matching
-                    // on the element
-                    for (int n = 0; n < size; n++) {
-                        final int tempSlot = environment.declareLocalTemp("caseElem" + n);
-                        final ReadLocalNode readTemp = environment.readNode(tempSlot, sourceSection);
-                        final RubyNode assignTemp = readTemp.makeWriteNode(expressionElements[n].accept(this));
-                        matches[n] = sequence(sourceSection, Arrays.asList(
-                                assignTemp,
-                                caseInPatternMatch(
-                                        patternElements[n],
-                                        expressionElements[n],
-                                        readTemp,
-                                        sourceSection)));
-                    }
-
-                    // Incorporate the element-wise pattern-matching into the AST, with the longer right leg since
-                    // AndNode is visited left to right
-                    RubyNode match = matches[size - 1];
-                    for (int n = size - 2; n >= 0; n--) {
-                        match = new AndNode(matches[n], match);
-                    }
-                    return match;
-                }
-
-                deconstructCallParameters = new RubyCallNodeParameters(
-                        expressionValue,
-                        "deconstruct",
-                        null,
-                        EmptyArgumentsDescriptor.INSTANCE,
-                        RubyNode.EMPTY_ARRAY,
-                        false,
-                        true);
-                deconstructed = language.coreMethodAssumptions
-                        .createCallNode(deconstructCallParameters);
-
-                receiver = new TruffleInternalModuleLiteralNode();
-                receiver.unsafeSetSourceSection(sourceSection);
-
-                matcherCallParameters = new RubyCallNodeParameters(
-                        receiver,
-                        "array_pattern_matches?",
-                        null,
-                        EmptyArgumentsDescriptor.INSTANCE,
-                        new RubyNode[]{ patternNode.accept(this), NodeUtil.cloneNode(deconstructed) },
-                        false,
-                        true);
-                return language.coreMethodAssumptions
-                        .createCallNode(matcherCallParameters);
-            case HASHNODE:
-                deconstructCallParameters = new RubyCallNodeParameters(
-                        expressionValue,
-                        "deconstruct_keys",
-                        null,
-                        EmptyArgumentsDescriptor.INSTANCE,
-                        new RubyNode[]{ new NilLiteralNode(true) },
-                        false,
-                        true);
-                deconstructed = language.coreMethodAssumptions
-                        .createCallNode(deconstructCallParameters);
-
-                receiver = new TruffleInternalModuleLiteralNode();
-                receiver.unsafeSetSourceSection(sourceSection);
-
-                matcherCallParameters = new RubyCallNodeParameters(
-                        receiver,
-                        "hash_pattern_matches?",
-                        null,
-                        EmptyArgumentsDescriptor.INSTANCE,
-                        new RubyNode[]{ patternNode.accept(this), NodeUtil.cloneNode(deconstructed) },
-                        false,
-                        true);
-                return language.coreMethodAssumptions
-                        .createCallNode(matcherCallParameters);
-            case LOCALVARNODE:
-                // Assigns the value of an existing variable pattern as the value of the expression.
-                // May need to add a case with same/similar logic for new variables.
-                final RubyNode assignmentNode = new LocalAsgnParseNode(
-                        patternNode.getPosition(),
-                        ((LocalVarParseNode) patternNode).getName(),
-                        ((LocalVarParseNode) patternNode).getDepth(),
-                        expressionNode).accept(this);
-                return new OrNode(assignmentNode, new BooleanLiteralNode(true)); // TODO refactor to remove "|| true"
-            default:
-                matcherCallParameters = new RubyCallNodeParameters(
-                        patternNode.accept(this),
-                        "===",
-                        null,
-                        EmptyArgumentsDescriptor.INSTANCE,
-                        new RubyNode[]{ NodeUtil.cloneNode(expressionValue) },
-                        false,
-                        true);
-                return language.coreMethodAssumptions
-                        .createCallNode(matcherCallParameters);
-        }
-    }
-
-
     private RubyNode openModule(SourceIndexLength sourceSection, RubyNode defineOrGetNode, String moduleName,
             ParseNode bodyNode, OpenModule type, boolean dynamicConstantLookup) {
         final SourceSection fullSourceSection = sourceSection.toSourceSection(source);