AST-inline Array#at

* So it is AST-inlined too and not just Array#[].

Author: eregon

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

@@ -88,6 +88,7 @@ public class CoreMethods {
     public final InternalMethod MODULE_CASE_EQUAL;
     public final InternalMethod STRING_EQUAL;
     public final InternalMethod SYMBOL_TO_PROC;
+    public final InternalMethod ARRAY_AT;
     public final InternalMethod ARRAY_INDEX_GET;
     public final InternalMethod ARRAY_INDEX_SET;
 
@@ -153,6 +154,7 @@ public CoreMethods(RubyContext context) {
         MODULE_CASE_EQUAL = getMethod(moduleClass, "===");
         STRING_EQUAL = getMethod(stringClass, "==");
         SYMBOL_TO_PROC = getMethod(symbolClass, "to_proc");
+        ARRAY_AT = getMethod(arrayClass, "at");
         ARRAY_INDEX_GET = getMethod(arrayClass, "[]");
         ARRAY_INDEX_SET = getMethod(arrayClass, "[]=");
     }
@@ -245,6 +247,8 @@ public RubyNode createCallNode(RubyCallNodeParameters callParameters, Translator
                     return InlinedGreaterOrEqualNodeGen.create(context, callParameters, self, args[0]);
                 case "[]":
                     return InlinedIndexGetNodeGen.create(context, callParameters, self, args[0]);
+                case "at":
+                    return InlinedAtNodeGen.create(context, callParameters, self, args[0]);
                 case "is_a?":
                     return InlinedIsANodeGen.create(context, callParameters, self, args[0]);
                 case "kind_of?":

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.inlined;
+
+import org.truffleruby.RubyContext;
+import org.truffleruby.core.array.ArrayIndexNodes;
+import org.truffleruby.core.array.RubyArray;
+import org.truffleruby.language.dispatch.RubyCallNodeParameters;
+import org.truffleruby.language.methods.LookupMethodOnSelfNode;
+
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.profiles.ConditionProfile;
+
+public abstract class InlinedAtNode extends BinaryInlinedOperationNode {
+
+    protected static final String METHOD = "at";
+
+    public InlinedAtNode(RubyContext context, RubyCallNodeParameters callNodeParameters) {
+        super(context, callNodeParameters);
+    }
+
+    @Specialization(
+            guards = "lookupNode.lookupProtected(frame, array, METHOD) == coreMethods().ARRAY_AT",
+            assumptions = "assumptions",
+            limit = "1")
+    protected Object arrayAt(VirtualFrame frame, RubyArray array, int index,
+            @Cached LookupMethodOnSelfNode lookupNode,
+            @Cached ArrayIndexNodes.ReadNormalizedNode readNormalizedNode,
+            @Cached ConditionProfile denormalized) {
+        if (denormalized.profile(index < 0)) {
+            index += array.size;
+        }
+        return readNormalizedNode.executeRead(array, index);
+    }
+
+    @Specialization
+    protected Object fallback(VirtualFrame frame, Object a, Object b) {
+        return rewriteAndCall(frame, a, b);
+    }
+
+}