LoadArgumentsTranslator.java

  1. /*
  2.  * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved. This
  3.  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  4.  * redistribute it and/or modify it under the terms of the:
  5.  *
  6.  * Eclipse Public License version 1.0
  7.  * GNU General Public License version 2
  8.  * GNU Lesser General Public License version 2.1
  9.  */
  10. package org.jruby.truffle.translator;

  12. import com.oracle.truffle.api.frame.FrameSlot;
  13. import com.oracle.truffle.api.source.Source;
  14. import com.oracle.truffle.api.source.SourceSection;
  15. import org.jruby.ast.RequiredKeywordArgumentValueNode;
  16. import org.jruby.ast.StarNode;
  17. import org.jruby.ast.types.INameNode;
  18. import org.jruby.lexer.yacc.ISourcePosition;
  19. import org.jruby.truffle.nodes.ReadNode;
  20. import org.jruby.truffle.nodes.RubyNode;
  21. import org.jruby.truffle.nodes.cast.ArrayCastNodeFactory;
  22. import org.jruby.truffle.nodes.cast.BooleanCastNodeFactory;
  23. import org.jruby.truffle.nodes.control.IfNode;
  24. import org.jruby.truffle.nodes.control.SequenceNode;
  25. import org.jruby.truffle.nodes.core.ArrayIndexNodeFactory;
  26. import org.jruby.truffle.nodes.core.ArraySliceNodeFactory;
  27. import org.jruby.truffle.nodes.literal.ArrayLiteralNode;
  28. import org.jruby.truffle.nodes.literal.NilLiteralNode;
  29. import org.jruby.truffle.nodes.methods.arguments.*;
  30. import org.jruby.truffle.nodes.methods.locals.ReadLocalVariableNodeFactory;
  31. import org.jruby.truffle.nodes.methods.locals.WriteLocalVariableNodeFactory;
  32. import org.jruby.truffle.runtime.RubyContext;

  34. import java.util.*;

  36. public class LoadArgumentsTranslator extends Translator {

  38.     private static class ArraySlot {

  40.         private FrameSlot arraySlot;
  41.         private int previousIndex;

  43.         public ArraySlot(FrameSlot arraySlot, int previousIndex) {
  44.             this.arraySlot = arraySlot;
  45.             this.previousIndex = previousIndex;
  46.         }

  48.         public FrameSlot getArraySlot() {
  49.             return arraySlot;
  50.         }

  52.         public int getPreviousIndex() {
  53.             return previousIndex;
  54.         }
  55.     }

  57.     private final boolean isBlock;
  58.     private final BodyTranslator methodBodyTranslator;
  59.     private final Deque<ArraySlot> arraySlotStack = new ArrayDeque<>();

  61.     private enum State {
  62.         PRE,
  63.         OPT,
  64.         POST
  65.     }

  67.     private int required;
  68.     private int index;
  69.     private int indexFromEnd = 1;
  70.     private State state;
  71.     private boolean hasKeywordArguments;
  72.     private List<String> excludedKeywords = new ArrayList<>();

  74.     private org.jruby.ast.ArgsNode argsNode;

  76.     public LoadArgumentsTranslator(RubyNode currentNode, RubyContext context, Source source, boolean isBlock, BodyTranslator methodBodyTranslator) {
  77.         super(currentNode, context, source);
  78.         this.isBlock = isBlock;
  79.         this.methodBodyTranslator = methodBodyTranslator;
  80.     }

  82.     @Override
  83.     public RubyNode visitArgsNode(org.jruby.ast.ArgsNode node) {
  84.         argsNode = node;

  86.         final SourceSection sourceSection = translate(node.getPosition());

  88.         final List<RubyNode> sequence = new ArrayList<>();

  90.         if (node.getPre() != null) {
  91.             state = State.PRE;
  92.             index = 0;
  93.             for (org.jruby.ast.Node arg : node.getPre().childNodes()) {
  94.                 sequence.add(arg.accept(this));
  95.                 ++index;
  96.                 required++;
  97.             }
  98.         }

  100.         if (node.getOptArgs() != null) {
  101.             // (BlockNode 0, (OptArgNode:a 0, (LocalAsgnNode:a 0, (FixnumNode 0))), ...)
  102.             state = State.OPT;
  103.             index = argsNode.getPreCount();
  104.             for (org.jruby.ast.Node arg : node.getOptArgs().childNodes()) {
  105.                 sequence.add(arg.accept(this));
  106.                 ++index;
  107.             }
  108.         }

  110.         hasKeywordArguments = node.hasKwargs() && node.getKeywords() != null;

  112.         if (node.getRestArgNode() != null) {
  113.             methodBodyTranslator.getEnvironment().hasRestParameter = true;
  114.             sequence.add(node.getRestArgNode().accept(this));
  115.         }

  117.         if (node.getPost() != null) {
  118.             state = State.POST;
  119.             index = -1;
  120.             final List<org.jruby.ast.Node> children = new ArrayList<>(node.getPost().childNodes());
  121.             Collections.reverse(children);
  122.             for (org.jruby.ast.Node arg : children) {
  123.                 sequence.add(arg.accept(this));
  124.                 index--;
  125.                 required++;
  126.             }
  127.         }

  129.         if (hasKeywordArguments) {
  130.             for (org.jruby.ast.Node arg : node.getKeywords().childNodes()) {
  131.                 sequence.add(arg.accept(this));
  132.             }
  133.         }

  135.         if (node.getKeyRest() != null) {
  136.             sequence.add(node.getKeyRest().accept(this));
  137.         }

  139.         if (node.getBlock() != null) {
  140.             sequence.add(node.getBlock().accept(this));
  141.         }

  143.         return SequenceNode.sequence(context, sourceSection, sequence);
  144.     }

  146.     @Override
  147.     public RubyNode visitKeywordRestArgNode(org.jruby.ast.KeywordRestArgNode node) {
  148.         final SourceSection sourceSection = translate(node.getPosition());

  150.         final RubyNode readNode = new ReadKeywordRestArgumentNode(context, sourceSection, required, excludedKeywords.toArray(new String[excludedKeywords.size()]));
  151.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findOrAddFrameSlot(node.getName());

  153.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  154.     }

  156.     @Override
  157.     public RubyNode visitKeywordArgNode(org.jruby.ast.KeywordArgNode node) {
  158.         final SourceSection sourceSection = translate(node.getPosition());

  160.         final String name;
  161.         final RubyNode defaultValue;

  163.         final org.jruby.ast.Node firstChild = node.childNodes().get(0);

  165.         if (firstChild instanceof org.jruby.ast.LocalAsgnNode) {
  166.             final org.jruby.ast.LocalAsgnNode localAsgnNode = (org.jruby.ast.LocalAsgnNode) firstChild;
  167.             name = localAsgnNode.getName();

  169.             if (localAsgnNode.getValueNode() == null) {
  170.                 defaultValue = new NilLiteralNode(context, sourceSection);
  171.             } else if (localAsgnNode.getValueNode() instanceof RequiredKeywordArgumentValueNode) {
  172.                 /*
  173.                  * This isn't a true default value - it's a marker to say there isn't one. This actually makes sense;
  174.                  * the semantic action of executing this node is to report an error, and we do the same thing.
  175.                  */
  176.                 defaultValue = new MissingKeywordArgumentNode(context, sourceSection, name);
  177.             } else {
  178.                 defaultValue = localAsgnNode.getValueNode().accept(this);
  179.             }
  180.         } else if (firstChild instanceof org.jruby.ast.DAsgnNode) {
  181.             final org.jruby.ast.DAsgnNode dAsgnNode = (org.jruby.ast.DAsgnNode) firstChild;
  182.             name = dAsgnNode.getName();

  184.             if (dAsgnNode.getValueNode() == null) {
  185.                 defaultValue = new NilLiteralNode(context, sourceSection);
  186.             } else {
  187.                 defaultValue = dAsgnNode.getValueNode().accept(this);
  188.             }
  189.         } else {
  190.             throw new UnsupportedOperationException("unsupported keyword arg " + node);
  191.         }

  193.         excludedKeywords.add(name);

  195.         final RubyNode readNode = new ReadKeywordArgumentNode(context, sourceSection, required, name, defaultValue);
  196.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findFrameSlot(name);

  198.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  199.     }

  201.     @Override
  202.     public RubyNode visitArgumentNode(org.jruby.ast.ArgumentNode node) {
  203.         final SourceSection sourceSection = translate(node.getPosition());

  205.         final RubyNode readNode = readArgument(sourceSection);
  206.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findFrameSlot(node.getName());
  207.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  208.     }

  210.     private RubyNode readArgument(SourceSection sourceSection) {
  211.         if (useArray()) {
  212.             return ArrayIndexNodeFactory.create(context, sourceSection, index, loadArray(sourceSection));
  213.         } else {
  214.             if (state == State.PRE) {
  215.                 return new ReadPreArgumentNode(context, sourceSection, index, isBlock ? MissingArgumentBehaviour.NIL : MissingArgumentBehaviour.RUNTIME_ERROR);
  216.             } else if (state == State.POST) {
  217.                 return new ReadPostArgumentNode(context, sourceSection, index);
  218.             } else {
  219.                 throw new IllegalStateException();
  220.             }
  221.         }
  222.     }

  224.     @Override
  225.     public RubyNode visitRestArgNode(org.jruby.ast.RestArgNode node) {
  226.         final SourceSection sourceSection = translate(node.getPosition());

  228.         final RubyNode readNode;

  230.         int from = argsNode.getPreCount() + argsNode.getOptionalArgsCount();
  231.         int to = -argsNode.getPostCount();
  232.         if (useArray()) {
  233.             readNode = ArraySliceNodeFactory.create(context, sourceSection, from, to, loadArray(sourceSection));
  234.         } else {
  235.             readNode = new ReadRestArgumentNode(context, sourceSection, from, to, hasKeywordArguments);
  236.         }

  238.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findFrameSlot(node.getName());
  239.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  240.     }

  242.     @Override
  243.     public RubyNode visitBlockArgNode(org.jruby.ast.BlockArgNode node) {
  244.         final SourceSection sourceSection = translate(node.getPosition());

  246.         final RubyNode readNode = new ReadBlockNode(context, sourceSection, context.getCoreLibrary().getNilObject());
  247.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findFrameSlot(node.getName());
  248.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  249.     }

  251.     @Override
  252.     public RubyNode visitOptArgNode(org.jruby.ast.OptArgNode node) {
  253.         // (OptArgNode:a 0, (LocalAsgnNode:a 0, (FixnumNode 0)))
  254.         return node.getValue().accept(this);
  255.     }

  257.     @Override
  258.     public RubyNode visitLocalAsgnNode(org.jruby.ast.LocalAsgnNode node) {
  259.         return translateLocalAssignment(node.getPosition(), node.getName(), node.getValueNode());
  260.     }

  262.     @Override
  263.     public RubyNode visitDAsgnNode(org.jruby.ast.DAsgnNode node) {
  264.         return translateLocalAssignment(node.getPosition(), node.getName(), node.getValueNode());
  265.     }

  267.     private RubyNode translateLocalAssignment(ISourcePosition sourcePosition, String name, org.jruby.ast.Node valueNode) {
  268.         final SourceSection sourceSection = translate(sourcePosition);

  270.         final RubyNode readNode;

  272.         if (indexFromEnd == 1) {
  273.             if (valueNode instanceof org.jruby.ast.NilImplicitNode) {
  274.                 // Multiple assignment

  276.                 if (useArray()) {
  277.                     readNode = ArrayIndexNodeFactory.create(context, sourceSection, index, loadArray(sourceSection));
  278.                 } else {
  279.                     readNode = readArgument(sourceSection);
  280.                 }
  281.             } else {
  282.                 // Optional argument
  283.                 final RubyNode defaultValue = valueNode.accept(this);

  285.                 int minimum = index + 1 + argsNode.getPostCount();

  287.                 if (argsNode.hasKwargs()) {
  288.                     minimum += 1;
  289.                 }

  291.                 readNode = new ReadOptionalArgumentNode(context, sourceSection, index, minimum, defaultValue);
  292.             }
  293.         } else {
  294.             readNode = ArraySliceNodeFactory.create(context, sourceSection, index, indexFromEnd, loadArray(sourceSection));
  295.         }

  297.         final FrameSlot slot = methodBodyTranslator.getEnvironment().getFrameDescriptor().findOrAddFrameSlot(name);
  298.         return WriteLocalVariableNodeFactory.create(context, sourceSection, slot, readNode);
  299.     }

  301.     @Override
  302.     public RubyNode visitArrayNode(org.jruby.ast.ArrayNode node) {
  303.         // (ArrayNode 0, (MultipleAsgn19Node 0, (ArrayNode 0, (LocalAsgnNode:a 0, ), (LocalAsgnNode:b 0, )), null, null)))
  304.         return node.childNodes().get(0).accept(this);
  305.     }

  307.     @Override
  308.     public RubyNode visitMultipleAsgnNode(org.jruby.ast.MultipleAsgn19Node node) {
  309.         final SourceSection sourceSection = translate(node.getPosition());

  311.         // (MultipleAsgn19Node 0, (ArrayNode 0, (LocalAsgnNode:a 0, ), (LocalAsgnNode:b 0, )), null, null))

  313.         final int arrayIndex = index;

  315.         final String arrayName = methodBodyTranslator.getEnvironment().allocateLocalTemp("destructure");
  316.         final FrameSlot arraySlot = methodBodyTranslator.getEnvironment().declareVar(arrayName);

  318.         pushArraySlot(arraySlot);

  320.         final List<org.jruby.ast.Node> childNodes;

  322.         if (node.childNodes() == null || node.childNodes().get(0) == null) {
  323.             childNodes = Collections.emptyList();
  324.         } else {
  325.             childNodes = node.childNodes().get(0).childNodes();
  326.         }

  328.         final List<RubyNode> notNilSequence = new ArrayList<>();

  330.         if (node.getPre() != null) {
  331.             index = 0;
  332.             for (org.jruby.ast.Node child : node.getPre().childNodes()) {
  333.                 notNilSequence.add(child.accept(this));
  334.                 index++;
  335.             }
  336.         }

  338.         if (node.getRest() != null) {
  339.             index = node.getPreCount();
  340.             indexFromEnd = -node.getPostCount();
  341.             notNilSequence.add(node.getRest().accept(this));
  342.             indexFromEnd = 1;
  343.         }

  345.         if (node.getPost() != null) {
  346.             index = -1;
  347.             final List<org.jruby.ast.Node> children = new ArrayList<>(node.getPost().childNodes());
  348.             Collections.reverse(children);
  349.             for (org.jruby.ast.Node child : children) {
  350.                 notNilSequence.add(child.accept(this));
  351.                 index--;
  352.             }
  353.         }

  355.         final RubyNode notNil = SequenceNode.sequence(context, sourceSection, notNilSequence);

  357.         popArraySlot(arraySlot);

  359.         final List<RubyNode> nilSequence = new ArrayList<>();

  361.         final ParameterCollector parametersToClearCollector = new ParameterCollector();

  363.         if (node.getPre() != null) {
  364.             for (org.jruby.ast.Node child : node.getPre().childNodes()) {
  365.                 child.accept(parametersToClearCollector);
  366.             }
  367.         }

  369.         if (node.getRest() != null) {
  370.             if (node.getRest() instanceof INameNode) {
  371.                 final String name = ((INameNode) node.getRest()).getName();
  372.                 nilSequence.add(((ReadNode) methodBodyTranslator.getEnvironment().findOrAddLocalVarNodeDangerous(name, sourceSection)).makeWriteNode(new ArrayLiteralNode.UninitialisedArrayLiteralNode(context, sourceSection, new RubyNode[]{})));
  373.             } else if (node.getRest() instanceof StarNode) {
  374.                 // Don't think we need to do anything
  375.             } else {
  376.                 throw new UnsupportedOperationException("unsupported rest node " + node.getRest());
  377.             }
  378.         }

  380.         if (node.getPost() != null) {
  381.             for (org.jruby.ast.Node child : node.getPost().childNodes()) {
  382.                 child.accept(parametersToClearCollector);
  383.             }
  384.         }

  386.         for (String parameterToClear : parametersToClearCollector.getParameters()) {
  387.             nilSequence.add(((ReadNode) methodBodyTranslator.getEnvironment().findOrAddLocalVarNodeDangerous(parameterToClear, sourceSection)).makeWriteNode(new NilLiteralNode(context, sourceSection)));
  388.         }

  390.         if (!childNodes.isEmpty()) {
  391.             // We haven't pushed a new array slot, so this will read the value which we couldn't convert to an array into the first destructured argument
  392.             index = arrayIndex;
  393.             nilSequence.add(childNodes.get(0).accept(this));
  394.         }

  396.         final RubyNode nil = SequenceNode.sequence(context, sourceSection, nilSequence);

  398.         return SequenceNode.sequence(context, sourceSection,
  399.                 WriteLocalVariableNodeFactory.create(context, sourceSection, arraySlot,
  400.                         ArrayCastNodeFactory.create(context, sourceSection,
  401.                                 readArgument(sourceSection))),
  402.                 new IfNode(context, sourceSection,
  403.                         BooleanCastNodeFactory.create(context, sourceSection,
  404.                                 new IsNilNode(context, sourceSection, ReadLocalVariableNodeFactory.create(context, sourceSection, arraySlot))),
  405.                         nil,
  406.                         notNil == null ? new NilLiteralNode(context, sourceSection) : notNil));
  407.     }

  409.     @Override
  410.     protected RubyNode defaultVisit(org.jruby.ast.Node node) {
  411.         // For normal expressions in the default value for optional arguments, use the normal body translator
  412.         return node.accept(methodBodyTranslator);
  413.     }

  415.     public void pushArraySlot(FrameSlot slot) {
  416.         arraySlotStack.push(new ArraySlot(slot, index));
  417.     }

  419.     public void popArraySlot(FrameSlot slot) {
  420.         index = arraySlotStack.pop().getPreviousIndex();
  421.     }

  423.     protected boolean useArray() {
  424.         return !arraySlotStack.isEmpty();
  425.     }

  427.     protected RubyNode loadArray(SourceSection sourceSection) {
  428.         return ReadLocalVariableNodeFactory.create(context, sourceSection, arraySlotStack.peek().getArraySlot());
  429.     }

  431.     @Override
  432.     protected String getIdentifier() {
  433.         return methodBodyTranslator.getIdentifier();
  434.     }

  436. }
Created with JaCoCo 0.7.3.201501050207