AST-inline 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_INDEX_GET;
 
     public CoreMethods(RubyContext context) {
         this.context = context;
@@ -100,6 +101,7 @@ public CoreMethods(RubyContext context) {
         final RubyClass nilClass = context.getCoreLibrary().nilClass;
         final RubyClass stringClass = context.getCoreLibrary().stringClass;
         final RubyClass symbolClass = context.getCoreLibrary().symbolClass;
+        final RubyClass arrayClass = context.getCoreLibrary().arrayClass;
 
         integerNegAssumption = registerAssumption(integerClass, "-@");
         floatNegAssumption = registerAssumption(floatClass, "-@");
@@ -150,6 +152,7 @@ public CoreMethods(RubyContext context) {
         MODULE_CASE_EQUAL = getMethod(moduleClass, "===");
         STRING_EQUAL = getMethod(stringClass, "==");
         SYMBOL_TO_PROC = getMethod(symbolClass, "to_proc");
+        ARRAY_INDEX_GET = getMethod(arrayClass, "[]");
     }
 
     private Assumption registerAssumption(RubyClass klass, String methodName) {
@@ -238,6 +241,8 @@ public RubyNode createCallNode(RubyCallNodeParameters callParameters, Translator
                     return InlinedGreaterThanNodeGen.create(context, callParameters, self, args[0]);
                 case ">=":
                     return InlinedGreaterOrEqualNodeGen.create(context, callParameters, self, args[0]);
+                case "[]":
+                    return InlinedIndexGetNodeGen.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/InlinedIndexGetNode.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 com.oracle.truffle.api.profiles.ConditionProfile;
+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;
+
+public abstract class InlinedIndexGetNode extends BinaryInlinedOperationNode {
+
+    protected static final String METHOD = "[]";
+
+    public InlinedIndexGetNode(RubyContext context, RubyCallNodeParameters callNodeParameters) {
+        super(context, callNodeParameters);
+    }
+
+    @Specialization(
+            guards = "lookupNode.lookupProtected(frame, array, METHOD) == coreMethods().ARRAY_INDEX_GET",
+            assumptions = "assumptions",
+            limit = "1")
+    protected Object arrayRead(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);
+    }
+
+}

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

@@ -67,7 +67,7 @@ protected InternalMethod lookupMethodCached(
             @Cached("contextReference.get()") RubyContext cachedContext,
             @Cached("metaClass") RubyClass cachedMetaClass,
             @Cached("name") String cachedName,
-            @Cached(value = "config", allowUncached = true) DispatchConfiguration cachedConfig,
+            @Cached("config") DispatchConfiguration cachedConfig,
             @Cached("lookupCached(cachedContext, frame, cachedMetaClass, cachedName, config)") MethodLookupResult methodLookupResult) {
 
         return methodLookupResult.getMethod();