[GR-63778] A language with id regex is not installed, Installed languages are: regex.

PullRequest: graal/20460

Author: tzezula

truffle/src/com.oracle.truffle.api.instrumentation.test/src/com/oracle/truffle/api/instrumentation/test/TruffleContextTest.java

@@ -574,7 +574,7 @@ public void testEvalInnerContextEvalErrors() {
         innerContext.leave(null, prev);
 
         assertFails(() -> innerContext.evalInternal(null, com.oracle.truffle.api.source.Source.newBuilder("foobarbazz$_", "", "").build()), IllegalArgumentException.class, (e) -> {
-            assertTrue(e.getMessage(), e.getMessage().startsWith("A language with id 'foobarbazz$_' is not installed. Installed languages are:"));
+            assertTrue(e.getMessage(), e.getMessage().startsWith("A language with id 'foobarbazz$_' is not available. Available languages are:"));
         });
         innerContext.close();
     }

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/ContextAPITest.java

@@ -75,6 +75,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
+import com.oracle.truffle.api.test.common.TestUtils;
 import org.graalvm.options.OptionCategory;
 import org.graalvm.options.OptionDescriptors;
 import org.graalvm.options.OptionKey;
@@ -1378,4 +1379,25 @@ public void testPermittedLanguages() {
 
     }
 
+    @Test
+    public void testGR63778() {
+        try (Context c = Context.create()) {
+            assertFails(() -> c.eval(TestUtils.getDefaultLanguageId(TestGR63778Internal.class), ""),
+                            IllegalArgumentException.class,
+                            (ia) -> {
+                                String message = ia.getMessage();
+                                assertTrue(message.contains(" language with id '" + TestUtils.getDefaultLanguageId(TestGR63778Internal.class) + "' is not available."));
+                                assertTrue(message.contains("A language with this id is installed, but only available internally."));
+                            });
+        }
+    }
+
+    @TruffleLanguage.Registration(internal = true)
+    static class TestGR63778Internal extends AbstractExecutableTestLanguage {
+
+        @Override
+        protected Object execute(RootNode node, Env env, Object[] contextArguments, Object[] frameArguments) throws Exception {
+            return null;
+        }
+    }
 }

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/ContextPolyglotAccessTest.java

@@ -185,7 +185,7 @@ public void testNotExistingEmbedder() {
             context.initialize(NOT_EXISTING_LANGUAGE);
             fail();
         } catch (IllegalArgumentException e) {
-            assertTrue(e.getMessage(), e.getMessage().startsWith("A language with id '" + NOT_EXISTING_LANGUAGE + "' is not installed."));
+            assertTrue(e.getMessage(), e.getMessage().startsWith("A language with id '" + NOT_EXISTING_LANGUAGE + "' is not available."));
         }
 
         evalTestLanguage(context, NotExistingEmbedderTestLanguage.class, "");

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/LanguageSPITest.java

@@ -1563,6 +1563,42 @@ protected Object execute(RootNode node, Env env, Object[] contextArguments, Obje
         }
     }
 
+    @Test
+    public void testGR63778() {
+        try (Context context = Context.create()) {
+            execute(context, TestGR63778Language.class);
+        }
+    }
+
+    @TruffleLanguage.Registration
+    static class TestGR63778Language extends AbstractExecutableTestLanguage {
+
+        @Override
+        @TruffleBoundary
+        protected Object execute(RootNode node, Env env, Object[] contextArguments, Object[] frameArguments) throws Exception {
+            try (TruffleContext truffleContext = env.newInnerContextBuilder().build();) {
+                Source source = Source.newBuilder(TestUtils.getDefaultLanguageId(TestGR63778Internal.class), "", "source").build();
+                assertFails(() -> truffleContext.evalPublic(null, source),
+                                IllegalArgumentException.class,
+                                (ia) -> {
+                                    String message = ia.getMessage();
+                                    assertTrue(message.contains(" language with id '" + TestUtils.getDefaultLanguageId(TestGR63778Internal.class) + "' is not available."));
+                                    assertTrue(message.contains("A language with this id is installed, but only available internally."));
+                                });
+                return null;
+            }
+        }
+    }
+
+    @TruffleLanguage.Registration(internal = true)
+    static class TestGR63778Internal extends AbstractExecutableTestLanguage {
+
+        @Override
+        protected Object execute(RootNode node, Env env, Object[] contextArguments, Object[] frameArguments) throws Exception {
+            return null;
+        }
+    }
+
     @Test
     public void testInnerContextPermittedLanguages() {
         try (Context context = Context.create()) {

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

@@ -1911,8 +1911,8 @@ public Object eval(String languageId, Object source) {
     }
 
     public PolyglotLanguage requirePublicLanguage(String languageId) {
-        PolyglotLanguage language = engine.idToLanguage.get(languageId);
-        if (language == null || language.cache.isInternal()) {
+        PolyglotLanguage language = engine.idToPublicLanguage.get(languageId);
+        if (language == null) {
             engine.requireLanguage(languageId, false); // will trigger the error
             assert false;
             return null;

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

@@ -1176,25 +1176,31 @@ void reportAllContextThreads(ThreadsListener listener) {
 
     PolyglotLanguage requireLanguage(String id, boolean allowInternal) {
         checkState();
-        PolyglotLanguage language;
+        Map<String, PolyglotLanguage> useLanguages;
         if (allowInternal) {
-            language = idToLanguage.get(id);
+            useLanguages = idToLanguage;
         } else {
-            language = idToPublicLanguage.get(id);
+            useLanguages = idToPublicLanguage;
         }
+        PolyglotLanguage language = useLanguages.get(id);
         if (language == null) {
-            throw throwNotInstalled(id, idToLanguage.keySet());
+            throw throwNotInstalled(id, useLanguages.keySet());
         }
         return language;
     }
 
-    private static RuntimeException throwNotInstalled(String id, Set<String> allLanguages) {
+    private RuntimeException throwNotInstalled(String id, Set<String> allLanguages) {
         String misspelledGuess = matchSpellingError(allLanguages, id);
         String didYouMean = "";
         if (misspelledGuess != null) {
             didYouMean = String.format("Did you mean '%s'? ", misspelledGuess);
         }
-        throw PolyglotEngineException.illegalArgument(String.format("A language with id '%s' is not installed. %sInstalled languages are: %s.", id, didYouMean, allLanguages));
+        String internalLanguageHint = "";
+        if (idToLanguage.containsKey(id)) {
+            // no access to internal, but internal language available
+            internalLanguageHint = "A language with this id is installed, but only available internally. ";
+        }
+        throw PolyglotEngineException.illegalArgument(String.format("A language with id '%s' is not available. %s%sAvailable languages are: %s.", id, didYouMean, internalLanguageHint, allLanguages));
     }
 
     private static String matchSpellingError(Set<String> allIds, String enteredId) {