Merge pull request #14 in G/truffle from ~VOJIN.JOVANOVIC_ORACLE.COM/truffle:issue/AS-745 to master

* commit '37dce9619a7c447a87ee620bdd7b575444556819':
  Re-factoring the LanguageCache so that languages can be re-initialized with reflection.

Author: woess

truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/vm/LanguageCacheReflectiveReinitializationTest.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.api.vm;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class LanguageCacheReflectiveReinitializationTest {
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void canReinitializeLanguages() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        System.setProperty("com.oracle.truffle.aot", "true");
+
+        Class<?> languageCacheClass = Class.forName("com.oracle.truffle.api.vm.LanguageCache");
+        Field languageCacheField = languageCacheClass.getDeclaredField("CACHE");
+        languageCacheField.setAccessible(true);
+        assert languageCacheField.get(null) == null;
+
+        Method initMethod = languageCacheClass.getDeclaredMethod("initializeLanguages", ClassLoader.class);
+        initMethod.setAccessible(true);
+        Map<String, Object> languages = (Map<String, Object>) initMethod.invoke(null, Thread.currentThread().getContextClassLoader());
+
+        assert languages.containsKey("application/x-test") : "Re-initialized languages must contain application/x-test language after reflective initialization.";
+    }
+}

truffle/com.oracle.truffle.api.vm/src/com/oracle/truffle/api/vm/LanguageCache.java

@@ -46,7 +46,7 @@
  * cache with languages found in application classloader.
  */
 final class LanguageCache {
-    static final boolean PRELOAD;
+    private static final boolean PRELOAD;
     private static final Map<String, LanguageCache> CACHE;
     private TruffleLanguage<?> language;
     private final String className;
@@ -55,18 +55,29 @@ final class LanguageCache {
     private final String version;
 
     static {
-        Map<String, LanguageCache> map = null;
-        if (TruffleOptions.AOT) {
-            map = languages();
-            for (LanguageCache info : map.values()) {
-                info.getImpl(true);
-            }
-        }
-        CACHE = map;
+        CACHE = TruffleOptions.AOT ? initializeLanguages(loader()) : null;
         PRELOAD = CACHE != null;
     }
 
-    LanguageCache(String prefix, Properties info, TruffleLanguage<?> language) {
+    /**
+     * This method initializes all languages under the provided classloader.
+     *
+     * NOTE: Method's signature should not be changed as it is reflectively invoked from AOT
+     * compilation.
+     *
+     * @param loader The classloader to be used for finding languages.
+     * @return A map of initialized languages.
+     */
+    private static Map<String, LanguageCache> initializeLanguages(ClassLoader loader) {
+        Map<String, LanguageCache> map;
+        map = createLanguages(loader);
+        for (LanguageCache info : map.values()) {
+            info.createLanguage(loader);
+        }
+        return map;
+    }
+
+    private LanguageCache(String prefix, Properties info, TruffleLanguage<?> language) {
         this.className = info.getProperty(prefix + "className");
         this.name = info.getProperty(prefix + "name");
         this.version = info.getProperty(prefix + "version");
@@ -90,20 +101,14 @@ private static ClassLoader loader() {
         return l;
     }
 
-    private static TruffleLanguage<?> find(String name, ClassLoader loader) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
-        if (PRELOAD) {
-            return CACHE.get(name).language;
-        } else {
-            Class<?> langClazz = Class.forName(name, true, loader);
-            return (TruffleLanguage<?>) langClazz.getField("INSTANCE").get(null);
-        }
-    }
-
     static Map<String, LanguageCache> languages() {
         if (PRELOAD) {
             return CACHE;
         }
-        ClassLoader loader = loader();
+        return createLanguages(loader());
+    }
+
+    private static Map<String, LanguageCache> createLanguages(ClassLoader loader) {
         Map<String, LanguageCache> map = new LinkedHashMap<>();
         Enumeration<URL> en;
         try {
@@ -154,13 +159,20 @@ TruffleLanguage<?> getImpl(boolean create) {
             return language;
         }
         if (create) {
-            try {
-                language = LanguageCache.find(className, loader());
-            } catch (Exception ex) {
-                throw new IllegalStateException("Cannot initialize " + getName() + " language with implementation " + className, ex);
-            }
+            createLanguage(loader());
         }
         return language;
     }
 
+    private void createLanguage(ClassLoader loader) {
+        try {
+            TruffleLanguage<?> result;
+            Class<?> langClazz = Class.forName(className, true, loader);
+            result = (TruffleLanguage<?>) langClazz.getField("INSTANCE").get(null);
+            language = result;
+        } catch (Exception ex) {
+            throw new IllegalStateException("Cannot initialize " + getName() + " language with implementation " + className, ex);
+        }
+    }
+
 }