Avoid using IllegalStateException in getUncachedToEspresso

This is not a control-flow exception

(cherry picked from commit 9376be9)

Author: gilles-duboscq

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/nodes/interop/ToEspressoNode.java

@@ -37,6 +37,7 @@
 import com.oracle.truffle.api.interop.UnsupportedTypeException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.NodeInfo;
+import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import com.oracle.truffle.espresso.EspressoLanguage;
 import com.oracle.truffle.espresso.impl.ArrayKlass;
 import com.oracle.truffle.espresso.impl.Field;
@@ -262,21 +263,23 @@ public Object doInternalTypeConverter(Object value, Klass targetType,
         })
         public Object doGeneric(Object value, Klass targetType,
                         @Bind("getMeta()") Meta meta,
-                        @CachedLibrary(limit = "LIMIT") InteropLibrary interop) throws UnsupportedTypeException {
-            try {
-                return getUncachedToEspresso(targetType, meta).execute(value);
-            } catch (IllegalStateException ex) {
-                // hit the unknown type case, so inline generic handling for that here
-                if (targetType instanceof ObjectKlass) {
-                    try {
-                        checkHasAllFieldsOrThrow(value, (ObjectKlass) targetType, interop, getMeta());
-                        return StaticObject.createForeign(getLanguage(), targetType, value, interop);
-                    } catch (ClassCastException e) {
-                        throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
-                    }
+                        @CachedLibrary(limit = "LIMIT") InteropLibrary interop,
+                        @Cached InlinedBranchProfile unknownProfile) throws UnsupportedTypeException {
+            ToEspressoNode uncachedToEspresso = getUncachedToEspresso(targetType, meta);
+            if (uncachedToEspresso != null) {
+                return uncachedToEspresso.execute(value);
+            }
+            unknownProfile.enter(this);
+            // hit the unknown type case, so inline generic handling for that here
+            if (targetType instanceof ObjectKlass) {
+                try {
+                    checkHasAllFieldsOrThrow(value, (ObjectKlass) targetType, interop, getMeta());
+                    return StaticObject.createForeign(getLanguage(), targetType, value, interop);
+                } catch (ClassCastException e) {
+                    throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
                 }
-                throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
             }
+            throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
         }
     }
 

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/nodes/interop/ToReference.java

@@ -45,6 +45,7 @@
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import com.oracle.truffle.api.profiles.BranchProfile;
+import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 import com.oracle.truffle.espresso.EspressoLanguage;
 import com.oracle.truffle.espresso.impl.ArrayKlass;
 import com.oracle.truffle.espresso.impl.Klass;
@@ -223,7 +224,8 @@ static ToReference getUncachedToReference(Klass targetType, Meta meta) {
             return ToReferenceFactory.ToByteArrayNodeGen.getUncached();
         }
         if (targetType.isArray()) {
-            throw new IllegalStateException("Generic arrays type mappings must be handled separately!");
+            // Generic arrays type mappings must be handled separately!
+            return null;
         }
         if (targetType.isJavaLangObject()) {
             return ToReferenceFactory.ToJavaLangObjectNodeGen.getUncached();
@@ -255,11 +257,8 @@ static ToReference getUncachedToReference(Klass targetType, Meta meta) {
                     return ToReferenceFactory.ToMapNodeGen.getUncached();
                 }
             }
-            if (isTypeMappingEnabled(targetType)) {
-                throw new IllegalStateException("Interface type mappings must be handled separately!");
-            } else {
-                throw new IllegalStateException("unknown types must be handled separately!");
-            }
+            // Interface type mappings & unknown interface types must be handled separately!
+            return null;
         }
         if (isForeignException(targetType, meta)) {
             return ToReferenceFactory.ToForeignExceptionNodeGen.getUncached();
@@ -300,7 +299,7 @@ static ToReference getUncachedToReference(Klass targetType, Meta meta) {
         if (targetType == meta.java_math_BigInteger) {
             return ToReferenceFactory.ToBigIntegerNodeGen.getUncached();
         }
-        throw new IllegalStateException("unknown types must be handled separately!");
+        return null;
     }
 
     @NodeInfo(shortName = "Dynamic toEspresso node")
@@ -454,21 +453,23 @@ public StaticObject doInternalTypeConverter(Object value, @SuppressWarnings("unu
         })
         public StaticObject doGeneric(Object value, Klass targetType,
                         @Bind("getMeta()") Meta meta,
-                        @CachedLibrary(limit = "LIMIT") InteropLibrary interop) throws UnsupportedTypeException {
-            try {
-                return getUncachedToReference(targetType, meta).execute(value);
-            } catch (IllegalStateException ex) {
-                // hit the unknown type case, so inline generic handling for that here
-                if (targetType instanceof ObjectKlass) {
-                    try {
-                        checkHasAllFieldsOrThrow(value, (ObjectKlass) targetType, interop, getMeta());
-                        return StaticObject.createForeign(getLanguage(), targetType, value, interop);
-                    } catch (ClassCastException e) {
-                        throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
-                    }
+                        @CachedLibrary(limit = "LIMIT") InteropLibrary interop,
+                        @Cached InlinedBranchProfile unknownProfile) throws UnsupportedTypeException {
+            ToReference uncachedToReference = getUncachedToReference(targetType, meta);
+            if (uncachedToReference != null) {
+                return uncachedToReference.execute(value);
+            }
+            unknownProfile.enter(this);
+            // hit the unknown type case, so inline generic handling for that here
+            if (targetType instanceof ObjectKlass) {
+                try {
+                    checkHasAllFieldsOrThrow(value, (ObjectKlass) targetType, interop, getMeta());
+                    return StaticObject.createForeign(getLanguage(), targetType, value, interop);
+                } catch (ClassCastException e) {
+                    throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
                 }
-                throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
             }
+            throw UnsupportedTypeException.create(new Object[]{value}, targetType.getTypeAsString());
         }
     }