--- a/truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/vm/ImplicitExplicitExportTest.java	Wed Aug 05 10:19:41 2015 -0700
+++ b/truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/vm/ImplicitExplicitExportTest.java	Thu Aug 06 08:31:49 2015 +0200
@@ -30,6 +30,7 @@
 import org.junit.*;
 
 import com.oracle.truffle.api.*;
+import com.oracle.truffle.api.TruffleLanguage.Env;
 import com.oracle.truffle.api.debug.*;
 import com.oracle.truffle.api.instrument.*;
 import com.oracle.truffle.api.nodes.Node;
@@ -108,36 +109,41 @@
         assertEquals("Global symbol is also 43", "43", vm.findGlobalSymbol("ahoj").invoke(null));
     }
 
-    private abstract static class AbstractExportImportLanguage extends TruffleLanguage {
-        protected AbstractExportImportLanguage(Env env) {
-            super(env);
+    private static final class Ctx {
+        final Map<String, String> explicit = new HashMap<>();
+        final Map<String, String> implicit = new HashMap<>();
+        final Env env;
+
+        public Ctx(Env env) {
+            this.env = env;
         }
+    }
 
-        private final Map<String, String> explicit = new HashMap<>();
-        private final Map<String, String> implicit = new HashMap<>();
+    private abstract static class AbstractExportImportLanguage extends TruffleLanguage<Ctx> {
+
+        @Override
+        protected Ctx createContext(Env env) {
+            return new Ctx(env);
+        }
 
         @Override
         protected CallTarget parse(Source code, Node context, String... argumentNames) throws IOException {
-            return new ValueCallTarget(code, getClass());
+            return new ValueCallTarget(code, this);
         }
 
         @Override
-        protected Object findExportedSymbol(String globalName, boolean onlyExplicit) {
-            if (explicit.containsKey(globalName)) {
-                return explicit.get(globalName);
+        protected Object findExportedSymbol(Ctx context, String globalName, boolean onlyExplicit) {
+            if (context.explicit.containsKey(globalName)) {
+                return context.explicit.get(globalName);
             }
-            if (!onlyExplicit && implicit.containsKey(globalName)) {
-                return implicit.get(globalName);
+            if (!onlyExplicit && context.implicit.containsKey(globalName)) {
+                return context.implicit.get(globalName);
             }
             return null;
         }
 
-        public static <Language extends TruffleLanguage> Language findContext(Class<Language> type) {
-            return TruffleLanguage.findContext(type);
-        }
-
         @Override
-        protected Object getLanguageGlobal() {
+        protected Object getLanguageGlobal(Ctx context) {
             return null;
         }
 
@@ -157,6 +163,7 @@
         }
 
         private Object importExport(Source code) {
+            Ctx ctx = findContext();
             Properties p = new Properties();
             try (Reader r = code.getReader()) {
                 p.load(r);
@@ -169,13 +176,13 @@
                 if (n instanceof String) {
                     String k = (String) n;
                     if (k.startsWith("explicit.")) {
-                        explicit.put(k.substring(9), p.getProperty(k));
+                        ctx.explicit.put(k.substring(9), p.getProperty(k));
                     }
                     if (k.startsWith("implicit.")) {
-                        implicit.put(k.substring(9), p.getProperty(k));
+                        ctx.implicit.put(k.substring(9), p.getProperty(k));
                     }
                     if (k.equals("return")) {
-                        return env().importSymbol(p.getProperty(k));
+                        return ctx.env.importSymbol(p.getProperty(k));
                     }
                 }
             }
@@ -185,9 +192,9 @@
 
     private static final class ValueCallTarget implements RootCallTarget {
         private final Source code;
-        private final Class<? extends AbstractExportImportLanguage> language;
+        private final AbstractExportImportLanguage language;
 
-        private ValueCallTarget(Source code, Class<? extends AbstractExportImportLanguage> language) {
+        private ValueCallTarget(Source code, AbstractExportImportLanguage language) {
             this.code = code;
             this.language = language;
         }
@@ -199,8 +206,7 @@
 
         @Override
         public Object call(Object... arguments) {
-            AbstractExportImportLanguage context = AbstractExportImportLanguage.findContext(language);
-            return context.importExport(code);
+            return language.importExport(code);
         }
     }
 
@@ -210,22 +216,25 @@
 
     @TruffleLanguage.Registration(mimeType = L1, name = "ImportExport1", version = "0")
     public static final class ExportImportLanguage1 extends AbstractExportImportLanguage {
-        public ExportImportLanguage1(Env env) {
-            super(env);
+        public static final AbstractExportImportLanguage INSTANCE = new ExportImportLanguage1();
+
+        public ExportImportLanguage1() {
         }
     }
 
     @TruffleLanguage.Registration(mimeType = L2, name = "ImportExport2", version = "0")
     public static final class ExportImportLanguage2 extends AbstractExportImportLanguage {
-        public ExportImportLanguage2(Env env) {
-            super(env);
+        public static final AbstractExportImportLanguage INSTANCE = new ExportImportLanguage2();
+
+        public ExportImportLanguage2() {
         }
     }
 
     @TruffleLanguage.Registration(mimeType = L3, name = "ImportExport3", version = "0")
     public static final class ExportImportLanguage3 extends AbstractExportImportLanguage {
-        public ExportImportLanguage3(Env env) {
-            super(env);
+        public static final AbstractExportImportLanguage INSTANCE = new ExportImportLanguage3();
+
+        private ExportImportLanguage3() {
         }
     }