Refactor str.startswith() and str.endswith()

Author: otethal

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextModuleBuiltins.java

@@ -68,7 +68,7 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.ArgDescriptor;
 import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.builtins.objects.object.ObjectBuiltins;
-import com.oracle.graal.python.builtins.objects.str.StringBuiltins.EndsWithNode;
+import com.oracle.graal.python.builtins.objects.str.StringBuiltins.PrefixSuffixNode;
 import com.oracle.graal.python.lib.PyObjectLookupAttr;
 import com.oracle.graal.python.nodes.PRaiseNode;
 import com.oracle.graal.python.nodes.attributes.WriteAttributeToObjectNode;
@@ -126,15 +126,15 @@ Object run(TruffleString name,
                         @Cached CallNode callNode,
                         @Cached ObjectBuiltins.SetattrNode setattrNode,
                         @Cached TruffleString.CodePointLengthNode codePointLengthNode,
-                        @Cached EndsWithNode endsWithNode,
+                        @Cached PrefixSuffixNode prefixSuffixNode,
                         @Cached TruffleString.LastIndexOfCodePointNode lastIndexNode,
                         @Cached TruffleString.SubstringNode substringNode) {
             // see CPython's Objects/moduleobject.c - _PyModule_CreateInitialized for
             // comparison how they handle _Py_PackageContext
             TruffleString newModuleName = name;
             PythonContext ctx = getContext();
             TruffleString pyPackageContext = ctx.getPyPackageContext() == null ? null : ctx.getPyPackageContext();
-            if (pyPackageContext != null && endsWithNode.executeBoolean(null, pyPackageContext, newModuleName, 0, codePointLengthNode.execute(pyPackageContext, TS_ENCODING))) {
+            if (pyPackageContext != null && prefixSuffixNode.endsWith(pyPackageContext, newModuleName, 0, codePointLengthNode.execute(pyPackageContext, TS_ENCODING))) {
                 newModuleName = pyPackageContext;
                 ctx.setPyPackageContext(null);
             }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ctypes/CtypesModuleBuiltins.java

@@ -135,7 +135,7 @@
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
 import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
-import com.oracle.graal.python.builtins.objects.str.StringBuiltins.EndsWithNode;
+import com.oracle.graal.python.builtins.objects.str.StringBuiltins.PrefixSuffixNode;
 import com.oracle.graal.python.builtins.objects.str.StringUtils.SimpleTruffleStringFormatNode;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetBaseClassNode;
@@ -739,7 +739,7 @@ static Object py_dl_open(VirtualFrame frame, PythonModule self, TruffleString na
                         @Cached PyObjectHashNode hashNode,
                         @Cached AuditNode auditNode,
                         @Cached CodePointLengthNode codePointLengthNode,
-                        @Cached EndsWithNode endsWithNode,
+                        @Cached PrefixSuffixNode prefixSuffixNode,
                         @Cached EqualNode eqNode,
                         @Cached PythonObjectFactory factory,
                         @Cached PRaiseNode.Lazy raiseNode) {
@@ -755,7 +755,7 @@ static Object py_dl_open(VirtualFrame frame, PythonModule self, TruffleString na
             Exception exception = null;
             boolean loadWithLLVM = !context.getEnv().isNativeAccessAllowed() || //
                             (!context.getOption(PythonOptions.UseSystemToolchain) &&
-                                            endsWithNode.executeBoolean(frame, name, context.getSoAbi(), 0, codePointLengthNode.execute(name, TS_ENCODING)));
+                                            prefixSuffixNode.endsWith(name, context.getSoAbi(), 0, codePointLengthNode.execute(name, TS_ENCODING)));
             try {
                 if (loadWithLLVM) {
                     Object handler = loadLLVMLibrary(context, inliningTarget, name);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/str/StringBuiltins.java

@@ -121,10 +121,8 @@
 import com.oracle.graal.python.builtins.objects.slice.SliceNodes.ComputeIndices;
 import com.oracle.graal.python.builtins.objects.str.StringBuiltinsClinicProviders.FormatNodeClinicProviderGen;
 import com.oracle.graal.python.builtins.objects.str.StringBuiltinsClinicProviders.SplitNodeClinicProviderGen;
-import com.oracle.graal.python.builtins.objects.str.StringBuiltinsFactory.EndsWithNodeFactory;
 import com.oracle.graal.python.builtins.objects.str.StringBuiltinsFactory.EqNodeFactory;
 import com.oracle.graal.python.builtins.objects.str.StringBuiltinsFactory.LtNodeFactory;
-import com.oracle.graal.python.builtins.objects.str.StringBuiltinsFactory.StartsWithNodeFactory;
 import com.oracle.graal.python.builtins.objects.str.StringNodes.CastToJavaStringCheckedNode;
 import com.oracle.graal.python.builtins.objects.str.StringNodes.CastToTruffleStringCheckedNode;
 import com.oracle.graal.python.builtins.objects.str.StringNodes.JoinInternalNode;
@@ -175,6 +173,7 @@
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.Cached.Shared;
+import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.ImportStatic;
@@ -588,72 +587,77 @@ static Object doNoString(Object self, @SuppressWarnings("unused") Object other,
         }
     }
 
-    abstract static class PrefixSuffixBaseNode extends PythonQuaternaryClinicBuiltinNode {
+    @GenerateInline(false) // footprint reduction 56 -> 39
+    @ImportStatic(PGuards.class)
+    public abstract static class PrefixSuffixNode extends Node {
 
-        public abstract boolean executeBoolean(VirtualFrame frame, TruffleString self, TruffleString subStr, int start, int end);
+        enum Op {
+            PREFIX,
+            SUFFIX;
 
-        @Override
-        protected ArgumentClinicProvider getArgumentClinic() {
-            // must be implemented here, because DSL creates a generated node for this class
-            CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw new AbstractMethodError();
+            TruffleString methodName() {
+                return this == PREFIX ? T_STARTSWITH : T_ENDSWITH;
+            }
+        }
+
+        abstract boolean execute(Object self, Object subStr, int start, int end, Op op);
+
+        public final boolean startsWith(Object self, Object subStr, int start, int end) {
+            return execute(self, subStr, start, end, Op.PREFIX);
+        }
+
+        public final boolean endsWith(Object self, Object subStr, int start, int end) {
+            return execute(self, subStr, start, end, Op.SUFFIX);
         }
 
         @Specialization(guards = "!isPTuple(subStrObj)")
-        boolean doStringPrefixStartEnd(Object selfObj, Object subStrObj, int start, int end,
+        static boolean doString(Object selfObj, Object subStrObj, int start, int end, Op op,
                         @Bind("this") Node inliningTarget,
                         @Exclusive @Cached CastToTruffleStringCheckedNode castSelfNode,
                         @Exclusive @Cached CastToTruffleStringCheckedNode castPrefixNode,
-                        @Shared("cpLen") @Cached TruffleString.CodePointLengthNode codePointLengthNode,
-                        @Shared("regionEqual") @Cached TruffleString.RegionEqualNode regionEqualNode) {
-            TruffleString self = castSelfNode.cast(inliningTarget, selfObj, ErrorMessages.REQUIRES_STR_OBJECT_BUT_RECEIVED_P, getMethodName(), selfObj);
-            TruffleString subStr = castPrefixNode.cast(inliningTarget, subStrObj, ErrorMessages.FIRST_ARG_MUST_BE_S_OR_TUPLE_NOT_P, getMethodName(), "str", subStrObj);
+                        @Shared @Cached TruffleString.CodePointLengthNode codePointLengthNode,
+                        @Shared @Cached TruffleString.RegionEqualNode regionEqualNode) {
+            TruffleString self = castSelfNode.cast(inliningTarget, selfObj, ErrorMessages.REQUIRES_STR_OBJECT_BUT_RECEIVED_P, op.methodName(), selfObj);
+            TruffleString subStr = castPrefixNode.cast(inliningTarget, subStrObj, ErrorMessages.FIRST_ARG_MUST_BE_S_OR_TUPLE_NOT_P, op.methodName(), "str", subStrObj);
             int selfLen = codePointLengthNode.execute(self, TS_ENCODING);
             int subStrLen = codePointLengthNode.execute(subStr, TS_ENCODING);
-            return doIt(self, subStr, adjustStartIndex(start, selfLen), adjustEndIndex(end, selfLen), selfLen, subStrLen, regionEqualNode);
+            return doIt(self, subStr, adjustStartIndex(start, selfLen), adjustEndIndex(end, selfLen), selfLen, subStrLen, regionEqualNode, op);
         }
 
         @Specialization
-        @SuppressWarnings("truffle-static-method")
-        boolean doTuplePrefixStartEnd(Object selfObj, PTuple subStrs, int start, int end,
+        static boolean doTuple(Object selfObj, PTuple subStrs, int start, int end, Op op,
                         @Bind("this") Node inliningTarget,
-                        @Exclusive @Cached GetObjectArrayNode getObjectArrayNode,
-                        @Exclusive @Cached CastToTruffleStringNode castPrefixNode,
-                        @Shared("cpLen") @Cached TruffleString.CodePointLengthNode codePointLengthNode,
-                        @Shared("regionEqual") @Cached TruffleString.RegionEqualNode regionEqualNode,
+                        @Cached GetObjectArrayNode getObjectArrayNode,
                         @Exclusive @Cached CastToTruffleStringCheckedNode castSelfNode,
-                        @Cached PRaiseNode.Lazy raiseNode) {
-            TruffleString self = castSelfNode.cast(inliningTarget, selfObj, ErrorMessages.REQUIRES_STR_OBJECT_BUT_RECEIVED_P, getMethodName(), selfObj);
+                        @Exclusive @Cached CastToTruffleStringCheckedNode castPrefixNode,
+                        @Shared @Cached TruffleString.CodePointLengthNode codePointLengthNode,
+                        @Shared @Cached TruffleString.RegionEqualNode regionEqualNode) {
+            TruffleString self = castSelfNode.cast(inliningTarget, selfObj, ErrorMessages.REQUIRES_STR_OBJECT_BUT_RECEIVED_P, op.methodName(), selfObj);
 
             int selfLen = codePointLengthNode.execute(self, TS_ENCODING);
             int cpStart = adjustStartIndex(start, selfLen);
             int cpEnd = adjustEndIndex(end, selfLen);
 
             for (Object element : getObjectArrayNode.execute(inliningTarget, subStrs)) {
-                try {
-                    TruffleString subStr = castPrefixNode.execute(inliningTarget, element);
-                    int subStrLen = codePointLengthNode.execute(subStr, TS_ENCODING);
-                    if (doIt(self, subStr, cpStart, cpEnd, selfLen, subStrLen, regionEqualNode)) {
-                        return true;
-                    }
-                } catch (CannotCastException e) {
-                    throw raiseNode.get(inliningTarget).raise(TypeError, ErrorMessages.INVALID_ELEMENT_TYPE, getMethodName(), element);
+                TruffleString subStr = castPrefixNode.cast(inliningTarget, element, ErrorMessages.INVALID_ELEMENT_TYPE, op.methodName(), element);
+                int subStrLen = codePointLengthNode.execute(subStr, TS_ENCODING);
+                if (doIt(self, subStr, cpStart, cpEnd, selfLen, subStrLen, regionEqualNode, op)) {
+                    return true;
                 }
             }
             return false;
         }
 
-        // the actual operation; will be overridden by subclasses
-        @SuppressWarnings("unused")
-        boolean doIt(TruffleString text, TruffleString subStr, int start, int end, int textLen, int subStrLen, TruffleString.RegionEqualNode regionEqualNode) {
-            CompilerAsserts.neverPartOfCompilation();
-            throw new IllegalStateException("should not reach");
-        }
+        private static boolean doIt(TruffleString text, TruffleString subStr, int start, int end, int textLen, int subStrLen, TruffleString.RegionEqualNode regionEqualNode, Op op) {
+            // start and end must be normalized indices for 'text'
+            assert start >= 0;
+            assert end >= 0 && end <= textLen;
 
-        @SuppressWarnings("unused")
-        protected TruffleString getMethodName() {
-            CompilerAsserts.neverPartOfCompilation();
-            throw new IllegalStateException("should not reach");
+            if (end - start < subStrLen) {
+                return false;
+            }
+            int fromIndex = op == Op.PREFIX ? start : end - subStrLen;
+            return regionEqualNode.execute(text, fromIndex, subStr, 0, subStrLen, TS_ENCODING);
         }
     }
 
@@ -662,33 +666,17 @@ protected TruffleString getMethodName() {
     @ArgumentClinic(name = "start", conversion = ArgumentClinic.ClinicConversion.SliceIndex, defaultValue = "0", useDefaultForNone = true)
     @ArgumentClinic(name = "end", conversion = ArgumentClinic.ClinicConversion.SliceIndex, defaultValue = "Integer.MAX_VALUE", useDefaultForNone = true)
     @GenerateNodeFactory
-    public abstract static class StartsWithNode extends PrefixSuffixBaseNode {
+    public abstract static class StartsWithNode extends PythonQuaternaryClinicBuiltinNode {
 
         @Override
         protected ArgumentClinicProvider getArgumentClinic() {
             return StringBuiltinsClinicProviders.StartsWithNodeClinicProviderGen.INSTANCE;
         }
 
-        @Override
-        boolean doIt(TruffleString text, TruffleString prefix, int start, int end, int textLen, int prefixLen, TruffleString.RegionEqualNode regionEqualNode) {
-            // start and end must be normalized indices for 'text'
-            assert start >= 0;
-            assert end >= 0 && end <= textLen;
-
-            if (end - start < prefixLen) {
-                return false;
-            }
-            return regionEqualNode.execute(text, start, prefix, 0, prefixLen, TS_ENCODING);
-        }
-
-        @Override
-        protected TruffleString getMethodName() {
-            return T_STARTSWITH;
-        }
-
-        @NeverDefault
-        public static StartsWithNode create() {
-            return StartsWithNodeFactory.create();
+        @Specialization
+        static boolean doStartsWith(Object self, Object prefix, int start, int end,
+                        @Cached PrefixSuffixNode prefixSuffixNode) {
+            return prefixSuffixNode.startsWith(self, prefix, start, end);
         }
     }
 
@@ -697,33 +685,17 @@ public static StartsWithNode create() {
     @ArgumentClinic(name = "start", conversion = ArgumentClinic.ClinicConversion.SliceIndex, defaultValue = "0", useDefaultForNone = true)
     @ArgumentClinic(name = "end", conversion = ArgumentClinic.ClinicConversion.SliceIndex, defaultValue = "Integer.MAX_VALUE", useDefaultForNone = true)
     @GenerateNodeFactory
-    public abstract static class EndsWithNode extends PrefixSuffixBaseNode {
+    public abstract static class EndsWithNode extends PythonQuaternaryClinicBuiltinNode {
 
         @Override
         protected ArgumentClinicProvider getArgumentClinic() {
             return StringBuiltinsClinicProviders.EndsWithNodeClinicProviderGen.INSTANCE;
         }
 
-        @Override
-        boolean doIt(TruffleString text, TruffleString suffix, int start, int end, int textLen, int suffixLen, TruffleString.RegionEqualNode regionEqualNode) {
-            // start and end must be normalized indices for 'text'
-            assert start >= 0;
-            assert end >= 0 && end <= textLen;
-
-            if (end - start < suffixLen) {
-                return false;
-            }
-            return regionEqualNode.execute(text, end - suffixLen, suffix, 0, suffixLen, TS_ENCODING);
-        }
-
-        @Override
-        protected TruffleString getMethodName() {
-            return T_ENDSWITH;
-        }
-
-        @NeverDefault
-        public static EndsWithNode create() {
-            return EndsWithNodeFactory.create();
+        @Specialization
+        static boolean doEndsWith(Object self, Object prefix, int start, int end,
+                        @Cached PrefixSuffixNode prefixSuffixNode) {
+            return prefixSuffixNode.endsWith(self, prefix, start, end);
         }
     }
 
@@ -1029,7 +1001,7 @@ static PDict doString(VirtualFrame frame, Object cls, Object from, Object to, Ob
         }
 
         @Specialization(guards = {"isNoValue(to)", "isNoValue(z)"})
-        @SuppressWarnings({"unused", "truffle-static-method"})
+        @SuppressWarnings("unused")
         static PDict doDict(VirtualFrame frame, Object cls, PDict from, Object to, Object z,
                         @Bind("this") Node inliningTarget,
                         @Cached HashingCollectionNodes.GetHashingStorageNode getHashingStorageNode,
@@ -2694,12 +2666,12 @@ protected ArgumentClinicProvider getArgumentClinic() {
         }
 
         @Specialization
-        TruffleString remove(VirtualFrame frame, TruffleString self, TruffleString prefix,
-                        @Cached StartsWithNode startsWith,
+        static TruffleString remove(TruffleString self, TruffleString prefix,
+                        @Cached PrefixSuffixNode prefixSuffixNode,
                         @Cached TruffleString.CodePointLengthNode codePointLengthNode,
                         @Cached TruffleString.SubstringNode substringNode) {
             int prefixLen = codePointLengthNode.execute(prefix, TS_ENCODING);
-            if (startsWith.executeBoolean(frame, self, prefix, 0, prefixLen)) {
+            if (prefixSuffixNode.startsWith(self, prefix, 0, prefixLen)) {
                 int selfLen = codePointLengthNode.execute(self, TS_ENCODING);
                 return substringNode.execute(self, prefixLen, selfLen - prefixLen, TS_ENCODING, false);
             }
@@ -2719,14 +2691,14 @@ protected ArgumentClinicProvider getArgumentClinic() {
         }
 
         @Specialization
-        TruffleString remove(VirtualFrame frame, TruffleString self, TruffleString suffix,
+        static TruffleString remove(TruffleString self, TruffleString suffix,
                         @Bind("this") Node inliningTarget,
-                        @Cached EndsWithNode endsWith,
+                        @Cached PrefixSuffixNode prefixSuffixNode,
                         @Cached TruffleString.CodePointLengthNode codePointLengthNode,
                         @Cached TruffleString.SubstringNode substringNode,
                         @Cached InlinedConditionProfile profile) {
             int selfLen = codePointLengthNode.execute(self, TS_ENCODING);
-            if (profile.profile(inliningTarget, endsWith.executeBoolean(frame, self, suffix, 0, selfLen))) {
+            if (profile.profile(inliningTarget, prefixSuffixNode.endsWith(self, suffix, 0, selfLen))) {
                 int suffixLen = codePointLengthNode.execute(suffix, TS_ENCODING);
                 return substringNode.execute(self, 0, selfLen - suffixLen, TS_ENCODING, false);
             }