Improved polyglot isolate library lookup.

Author: tzezula

sdk/CHANGELOG.md

@@ -10,6 +10,7 @@ This changelog summarizes major changes between GraalVM SDK versions. The main f
 * GR-65404 Remove `PolyglotLauncher` as it is no longer used.
 * GR-63009: The WebAssembly (Wasm) language is now available as a polyglot isolate.
 * GR-63009: JavaScript polyglot isolate now includes support for the WebAssembly (Wasm) language.
+* GR-68613: JavaScript polyglot isolate now includes support for the WebAssembly (Wasm) language.
 
 ## Version 25.0.0
 * GR-60636 Truffle now stops compiling when the code cache fills up on HotSpot. A warning is printed when that happens.

truffle/mx.truffle/mx_truffle.py

@@ -1366,11 +1366,11 @@ class _PolyglotIsolateResourceProject(mx.JavaProject):
     and the resource ID is `<language_id>-isolate-<os>-<arch>`.
     """
 
-    def __init__(self, language_suite, subDir, language_id, resource_id, os_name, cpu_architecture, placeholder):
+    def __init__(self, language_suite, subDir, language_id, all_language_ids, resource_id, os_name, cpu_architecture, placeholder):
         name = f'com.oracle.truffle.isolate.resource.{language_id}.{os_name}.{cpu_architecture}'
         javaCompliance = str(mx.distribution('truffle:TRUFFLE_API').javaCompliance) + '+'
         project_dir = os.path.join(language_suite.dir, subDir, name)
-        deps = ['truffle:TRUFFLE_API']
+        deps = ['truffle:TRUFFLE_API', 'truffle-enterprise:TRUFFLE_ENTERPRISE']
         if placeholder:
             deps += ['sdk:NATIVEIMAGE']
         super(_PolyglotIsolateResourceProject, self).__init__(language_suite, name, subDir=subDir, srcDirs=[], deps=deps,
@@ -1380,6 +1380,7 @@ def __init__(self, language_suite, subDir, language_id, resource_id, os_name, cp
         self.srcDirs.append(src_gen_dir)
         self.declaredAnnotationProcessors = ['truffle:TRUFFLE_DSL_PROCESSOR']
         self.language_id = language_id
+        self.all_language_ids = all_language_ids
         self.resource_id = resource_id
         self.os_name = os_name
         self.cpu_architecture = cpu_architecture
@@ -1457,6 +1458,7 @@ def build(self):
         subst_eng = mx_subst.SubstitutionEngine()
         subst_eng.register_no_arg('package', pkg_name)
         subst_eng.register_no_arg('languageId', prj.language_id)
+        subst_eng.register_no_arg('languageIds', ', '.join([f'"{l}"' for l in prj.all_language_ids]))
         subst_eng.register_no_arg('resourceId', prj.resource_id)
         subst_eng.register_no_arg('os', prj.os_name)
         subst_eng.register_no_arg('arch', prj.cpu_architecture)
@@ -1469,9 +1471,10 @@ def build(self):
 
 
 
-def register_polyglot_isolate_distributions(language_suite, register_project, register_distribution, language_id,
+def register_polyglot_isolate_distributions(language_suite, register_project, register_distribution, main_language_id,
                                             subDir, language_pom_distribution, maven_group_id, language_license,
-                                            isolate_build_options=None, platforms=None, additional_image_path_artifacts=None):
+                                            isolate_build_options=None, platforms=None, additional_image_path_artifacts=None,
+                                            additional_language_ids=None):
     """
     Creates and registers the polyglot isolate resource distribution and isolate resource meta-POM distribution.
     The created polyglot isolate resource distribution is named `<ID>_ISOLATE_RESOURCES`, inheriting the Maven group ID
@@ -1484,26 +1487,27 @@ def register_polyglot_isolate_distributions(language_suite, register_project, re
     :type register_project: (mx.Project) -> None
     :param register_distribution: A callback to dynamically register the distribution, obtained as a parameter from `mx_register_dynamic_suite_constituents`.
     :type register_distribution: (mx.Distribution) -> None
-    :param str language_id: The language ID.
+    :param str main_language_id: The language ID.
     :param str subDir: a path relative to `suite.dir` in which the IDE project configuration for this distribution is generated
     :param POMDistribution language_pom_distribution: The language meta pom distribution used to set the image builder module-path.
     :param str maven_group_id: The maven language group id.
     :param str | list | language_license: Language licence(s).
     :param list isolate_build_options: additional options passed to a native image to build the isolate library.
     :param list platforms: supported platforms, defaults to ['linux-amd64', 'linux-aarch64', 'darwin-amd64', 'darwin-aarch64', 'windows-amd64']
     :param list additional_image_path_artifacts: additional artifacts to include in the polyglot isolate library image path
+    :param list additional_language_ids: language ids of additional languages added into polyglot isolate library
     """
     assert language_suite
     assert register_project
     assert register_distribution
-    assert language_id
+    assert main_language_id
     assert subDir
     assert language_pom_distribution
     assert maven_group_id
     assert language_license
 
     polyglot_isolates_value = mx_sdk_vm_impl._parse_cmd_arg('polyglot_isolates')
-    if not polyglot_isolates_value or not (polyglot_isolates_value is True or (isinstance(polyglot_isolates_value, list) and language_id in polyglot_isolates_value)):
+    if not polyglot_isolates_value or not (polyglot_isolates_value is True or (isinstance(polyglot_isolates_value, list) and main_language_id in polyglot_isolates_value)):
         return False
 
     if not isinstance(language_license, list):
@@ -1520,7 +1524,14 @@ def _qualname(distribution_name):
         additional_image_path_artifacts = [_qualname(d) for d in additional_image_path_artifacts]
     else:
         additional_image_path_artifacts = []
-    language_id_upper_case = language_id.upper()
+    if additional_language_ids:
+        if main_language_id in additional_language_ids:
+            all_language_ids = additional_language_ids
+        else:
+            all_language_ids = [main_language_id] + additional_language_ids
+    else:
+        all_language_ids = [main_language_id]
+    language_id_upper_case = main_language_id.upper()
     if platforms is None:
         platforms = [
             'linux-amd64',
@@ -1536,12 +1547,12 @@ def _qualname(distribution_name):
     platform_meta_poms = []
     for platform in platforms:
         build_for_current_platform = platform == current_platform
-        resource_id = f'{language_id}-isolate-{platform}'
+        resource_id = f'{main_language_id}-isolate-{platform}'
         os_name, cpu_architecture = platform.split('-')
         os_name_upper_case = os_name.upper()
         cpu_architecture_upper_case = cpu_architecture.upper()
         # 1. Register a project generating and building an internal resource for polyglot isolate library
-        build_internal_resource = _PolyglotIsolateResourceProject(language_suite, subDir, language_id, resource_id,
+        build_internal_resource = _PolyglotIsolateResourceProject(language_suite, subDir, main_language_id, all_language_ids, resource_id,
                                                                   os_name, cpu_architecture, not build_for_current_platform)
         register_project(build_internal_resource)
         resources_dist_dependencies = [
@@ -1551,13 +1562,13 @@ def _qualname(distribution_name):
         if build_for_current_platform:
             # 2. Register a project building the isolate library
             isolate_deps = [language_pom_distribution, 'truffle-enterprise:TRUFFLE_ENTERPRISE'] + additional_image_path_artifacts
-            build_library = PolyglotIsolateProject(language_suite, language_id, isolate_deps, isolate_build_options)
+            build_library = PolyglotIsolateProject(language_suite, main_language_id, isolate_deps, isolate_build_options)
             register_project(build_library)
 
             # 3. Register layout distribution with isolate library and isolate resources
             resource_base_folder = f'META-INF/resources/engine/{resource_id}/libvm'
             attrs = {
-                'description': f'Contains {language_id} language library resources.',
+                'description': f'Contains {main_language_id} language library resources.',
                 'hashEntry': f'{resource_base_folder}/sha256',
                 'fileListEntry': f'{resource_base_folder}/files',
                 'maven': False,
@@ -1567,7 +1578,7 @@ def _qualname(distribution_name):
                 name=f'{language_id_upper_case}_ISOLATE_LAYOUT_{os_name_upper_case}_{cpu_architecture_upper_case}',
                 deps=[],
                 layout={
-                    f'{resource_base_folder}/': f'dependency:{build_library.name}',
+                    f'{resource_base_folder}/{mx.add_lib_suffix("libpolyglotisolate")}': f'dependency:{build_library.name}',
                     f'{resource_base_folder}/resources/': {"source_type": "dependency",
                                                           "dependency": f'{build_library.name}',
                                                           "path": 'language_resources/resources/*',
@@ -1596,7 +1607,7 @@ def _qualname(distribution_name):
         # We pass directly the license id
         licenses.update(['GFTC'])
         attrs = {
-            'description': f'Polyglot isolate resources for {language_id} for {platform}.',
+            'description': f'Polyglot isolate resources for {main_language_id} for {platform}.',
             'moduleInfo': {
                 'name': build_internal_resource.name,
             },
@@ -1617,7 +1628,7 @@ def _qualname(distribution_name):
             deps=resources_dist_dependencies,
             mainClass=None,
             excludedLibs=[],
-            distDependencies=['truffle:TRUFFLE_API'],
+            distDependencies=['truffle:TRUFFLE_API', 'truffle-enterprise:TRUFFLE_ENTERPRISE'],
             javaCompliance=str(build_internal_resource.javaCompliance)+'+',
             platformDependent=True,
             theLicense=sorted(list(licenses)),
@@ -1629,7 +1640,7 @@ def _qualname(distribution_name):
         # 5. Register meta POM distribution for the isolate library jar file for a specific platform.
         isolate_dist_name = f'{language_id_upper_case}_ISOLATE_{os_name_upper_case}_{cpu_architecture_upper_case}'
         attrs = {
-            'description': f'The {language_id} polyglot isolate for {platform}.',
+            'description': f'The {main_language_id} polyglot isolate for {platform}.',
             'maven': {
                 'groupId': 'org.graalvm.polyglot',
                 'artifactId': maven_artifact_id,
@@ -1651,10 +1662,10 @@ def _qualname(distribution_name):
     # 6. Register meta POM distribution listing all platform specific meta-POMS.
     isolate_dist_name = f'{language_id_upper_case}_ISOLATE'
     attrs = {
-        'description': f'The {language_id} polyglot isolate.',
+        'description': f'The {main_language_id} polyglot isolate.',
         'maven': {
             'groupId': 'org.graalvm.polyglot',
-            'artifactId': f'{language_id}-isolate',
+            'artifactId': f'{main_language_id}-isolate',
             'tag': ['default', 'public'],
         },
     }

truffle/mx.truffle/polyglot_isolate_resource.template

@@ -43,10 +43,13 @@ package <package>;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.InternalResource;
 
+import com.oracle.truffle.polyglot.enterprise.isolate.PolyglotIsolateLanguages;
+
 import java.io.IOException;
 import java.nio.file.Path;
 
 @InternalResource.Id(value = PolyglotIsolateResource.ID, componentId = "engine", optional = true)
+@PolyglotIsolateLanguages({<languageIds>})
 public final class PolyglotIsolateResource implements InternalResource {
 
     static final String ID = "<resourceId>";

truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/impl/Accessor.java

@@ -802,6 +802,8 @@ public abstract <T, G> Iterator<T> mergeHostGuestFrames(Object polyglotEngine, S
 
         public abstract TruffleFile getInternalResource(Object owner, String resourceId) throws IOException;
 
+        public abstract Map<String, InternalResource> getEngineInternalResources();
+
         public abstract Path getEngineResource(Object polyglotEngine, String resourceId) throws IOException;
 
         public abstract Collection<String> getResourceIds(String componentId);

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/EngineAccessor.java

@@ -2191,6 +2191,15 @@ private static TruffleFile getInternalResource(Object owner, String resourceId,
             return EngineAccessor.LANGUAGE.getTruffleFile(rootPath.toString(), languageContext.getInternalFileSystemContext());
         }
 
+        @Override
+        public Map<String, InternalResource> getEngineInternalResources() {
+            Map<String, InternalResource> result = new HashMap<>();
+            for (InternalResourceCache cache : InternalResourceCache.getEngineResources()) {
+                result.put(cache.getResourceId(), cache.getInternalResource());
+            }
+            return result;
+        }
+
         @Override
         public Path getEngineResource(Object polyglotEngine, String resourceId) throws IOException {
             InternalResourceCache resourceCache = InternalResourceCache.getEngineResource(resourceId);

truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/InternalResourceCache.java

@@ -154,6 +154,10 @@ Path getPath(PolyglotEngineImpl polyglotEngine) throws IOException {
         }
     }
 
+    InternalResource getInternalResource() {
+        return resourceFactory.get();
+    }
+
     void initializeOwningRoot(InternalResourceRoots.Root root) {
         assert owningRoot == null;
         assert path == null;