[GR-54865] Make sure custom type converters take precedence over internal collection mappings.

PullRequest: graal/19725

Author: javeleon

espresso/src/com.oracle.truffle.espresso.polyglot/src/com/oracle/truffle/espresso/polyglot/GuestTypeConversion.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,6 +40,23 @@
  */
 package com.oracle.truffle.espresso.polyglot;
 
+/**
+ * This interface must be implemented by a custom defined type converter that is declared as context
+ * builder input using the 'java.PolyglotTypeConverters' option. If a polyglot object that is passed
+ * into Espresso has a declared meta name that matches the declaration used for the GuestConversion,
+ * the toGuest method is invoked. This invocation is responsible for returning a guest object
+ * matching the parameterized type.
+ * </p>
+ * Note that, in the case where the target type, e.g. a method parameter type in the guest, is not
+ * assignable from the returned instance of the toGuest method, the converted value is ignored.
+ * Hence, other custom or internal type mappings might be attempted in sequence in response to such
+ * incompatible conversion. For example, the built-in collection type mappings
+ * (java.BuiltInPolyglotCollections) might be compatible for the incoming polyglot object, or there
+ * might be custom interface mapping (java.PolyglotInterfaceMappings).
+ * 
+ * @param <T> the guest type this converter is converting an interop meta name-mapped polyglot
+ *            instance to.
+ */
 public interface GuestTypeConversion<T> {
     T toGuest(Object polyglotInstance);
 }

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

@@ -241,6 +241,7 @@ public static Object doArray(Object value, ArrayKlass targetType,
         public static Object doTypeConverter(Object value, EspressoType targetType,
                         @Bind Node node,
                         @Cached LookupTypeConverterNode lookupTypeConverter,
+                        @Cached InstanceOf.Dynamic instanceOf,
                         @CachedLibrary(limit = "LIMIT") InteropLibrary interop,
                         @Cached InlinedBranchProfile error) throws UnsupportedTypeException {
             try {
@@ -254,7 +255,10 @@ public static Object doTypeConverter(Object value, EspressoType targetType,
                     if (targetType instanceof ParameterizedEspressoType parameterizedEspressoType) {
                         EspressoLanguage.get(node).getTypeArgumentProperty().setObject(foreignWrapper, parameterizedEspressoType.getTypeArguments());
                     }
-                    return converter.convert(foreignWrapper);
+                    StaticObject result = (StaticObject) converter.convert(foreignWrapper);
+                    if (instanceOf.execute(result.getKlass(), targetType.getRawType())) {
+                        return result;
+                    }
                 }
             } catch (UnsupportedMessageException e) {
                 // no meta object, fall through to throw unsupported type
@@ -297,13 +301,28 @@ public static Object doInternalTypeConverter(Object value, EspressoType targetTy
         })
         public static Object doBuiltinCollectionMapped(Object value, EspressoType targetType,
                         @Bind Node node,
+                        @Cached LookupTypeConverterNode lookupTypeConverterNode,
                         @Cached LookupProxyKlassNode lookupProxyKlassNode,
                         @Cached ProxyInstantiateNode proxyInstantiateNode,
+                        @Cached InstanceOf.Dynamic instanceOf,
                         @CachedLibrary(limit = "LIMIT") InteropLibrary interop,
+                        @Cached InlinedBranchProfile converterProfile,
                         @Cached InlinedBranchProfile errorProfile) throws UnsupportedTypeException {
             try {
                 Object metaObject = interop.getMetaObject(value);
                 String metaName = getMetaName(metaObject, interop);
+                // first check if there's a user-defined custom type converter defined
+                PolyglotTypeMappings.TypeConverter converter = lookupTypeConverterNode.execute(metaName);
+                if (converter != null) {
+                    converterProfile.enter(node);
+                    EspressoContext context = EspressoContext.get(node);
+                    StaticObject foreignWrapper = StaticObject.createForeign(context.getLanguage(), context.getMeta().java_lang_Object, value, interop);
+                    StaticObject result = (StaticObject) converter.convert(foreignWrapper);
+                    if (instanceOf.execute(result.getKlass(), targetType.getRawType())) {
+                        return result;
+                    }
+                }
+                // then check if there's a type-mapped interface
                 WrappedProxyKlass proxyKlass = lookupProxyKlassNode.execute(metaObject, metaName, targetType.getRawType());
                 if (proxyKlass != null) {
                     return proxyInstantiateNode.execute(proxyKlass, value, targetType);