--- a/truffle/com.oracle.truffle.api.interop/src/com/oracle/truffle/api/interop/ForeignAccess.java	Thu Aug 06 18:20:20 2015 +0200
+++ b/truffle/com.oracle.truffle.api.interop/src/com/oracle/truffle/api/interop/ForeignAccess.java	Fri Aug 07 11:14:34 2015 +0200
@@ -61,45 +61,7 @@
             Factory f = (Factory) factory;
             assert f != null;
         }
-        class DelegatingFactory implements Factory {
-            @Override
-            public boolean canHandle(TruffleObject obj) {
-                if (baseClass == null) {
-                    return ((Factory) factory).canHandle(obj);
-                }
-                return baseClass.isInstance(obj);
-            }
-
-            @Override
-            public CallTarget accessMessage(Message msg) {
-                if (msg instanceof KnownMessage) {
-                    switch (msg.hashCode()) {
-                        case Execute.HASH1:
-                            return factory.accessInvoke(((Execute) msg).getArity());
-                        case Execute.HASH2:
-                            return factory.accessExecute(((Execute) msg).getArity());
-                        case GetSize.HASH:
-                            return factory.accessGetSize();
-                        case HasSize.HASH:
-                            return factory.accessHasSize();
-                        case IsBoxed.HASH:
-                            return factory.accessIsBoxed();
-                        case IsExecutable.HASH:
-                            return factory.accessIsExecutable();
-                        case IsNull.HASH:
-                            return factory.accessIsNull();
-                        case Read.HASH:
-                            return factory.accessRead();
-                        case Unbox.HASH:
-                            return factory.accessUnbox();
-                        case Write.HASH:
-                            return factory.accessWrite();
-                    }
-                }
-                return factory.accessMessage(msg);
-            }
-        }
-        return new ForeignAccess(new DelegatingFactory());
+        return new ForeignAccess(new DelegatingFactory(baseClass, factory));
     }
 
     /**
@@ -152,6 +114,17 @@
         return (TruffleObject) frame.getArguments()[ForeignAccessArguments.RECEIVER_INDEX];
     }
 
+    @Override
+    public String toString() {
+        Object f;
+        if (factory instanceof DelegatingFactory) {
+            f = ((DelegatingFactory) factory).factory;
+        } else {
+            f = factory;
+        }
+        return "ForeignAccess[" + f.getClass().getName() + "]";
+    }
+
     private void checkThread() {
         if (initThread != Thread.currentThread()) {
             throw new IllegalStateException("ForeignAccess created on " + initThread.getName() + " but used on " + Thread.currentThread().getName());
@@ -295,4 +268,52 @@
          */
         CallTarget accessMessage(Message unknown);
     }
+
+    private static class DelegatingFactory implements Factory {
+        private final Class<?> baseClass;
+        private final Factory10 factory;
+
+        public DelegatingFactory(Class<?> baseClass, Factory10 factory) {
+            this.baseClass = baseClass;
+            this.factory = factory;
+        }
+
+        @Override
+        public boolean canHandle(TruffleObject obj) {
+            if (baseClass == null) {
+                return ((Factory) factory).canHandle(obj);
+            }
+            return baseClass.isInstance(obj);
+        }
+
+        @Override
+        public CallTarget accessMessage(Message msg) {
+            if (msg instanceof KnownMessage) {
+                switch (msg.hashCode()) {
+                    case Execute.HASH1:
+                        return factory.accessInvoke(((Execute) msg).getArity());
+                    case Execute.HASH2:
+                        return factory.accessExecute(((Execute) msg).getArity());
+                    case GetSize.HASH:
+                        return factory.accessGetSize();
+                    case HasSize.HASH:
+                        return factory.accessHasSize();
+                    case IsBoxed.HASH:
+                        return factory.accessIsBoxed();
+                    case IsExecutable.HASH:
+                        return factory.accessIsExecutable();
+                    case IsNull.HASH:
+                        return factory.accessIsNull();
+                    case Read.HASH:
+                        return factory.accessRead();
+                    case Unbox.HASH:
+                        return factory.accessUnbox();
+                    case Write.HASH:
+                        return factory.accessWrite();
+                }
+            }
+            return factory.accessMessage(msg);
+        }
+    }
+
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/truffle/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/interop/ForeignAccessToStringTest.java	Fri Aug 07 11:14:34 2015 +0200
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2012, 2015, 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.test.interop;
+
+import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.interop.ForeignAccess;
+import com.oracle.truffle.api.interop.Message;
+import com.oracle.truffle.api.interop.TruffleObject;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class ForeignAccessToStringTest {
+    @Test
+    public void checkRegularFactory() {
+        ForeignAccess fa = ForeignAccess.create(new SimpleTestingFactory());
+        assertEquals("ForeignAccess[com.oracle.truffle.api.test.interop.ForeignAccessToStringTest$SimpleTestingFactory]", fa.toString());
+    }
+
+    @Test
+    public void check10Factory() {
+        ForeignAccess fa = ForeignAccess.create(TruffleObject.class, new Simple10TestingFactory());
+        assertEquals("ForeignAccess[com.oracle.truffle.api.test.interop.ForeignAccessToStringTest$Simple10TestingFactory]", fa.toString());
+    }
+
+    private static class SimpleTestingFactory implements ForeignAccess.Factory {
+        public SimpleTestingFactory() {
+        }
+
+        @Override
+        public boolean canHandle(TruffleObject obj) {
+            return false;
+        }
+
+        @Override
+        public CallTarget accessMessage(Message tree) {
+            return null;
+        }
+    }
+
+    private static class Simple10TestingFactory implements ForeignAccess.Factory10 {
+        @Override
+        public CallTarget accessIsNull() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessIsExecutable() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessIsBoxed() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessHasSize() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessGetSize() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessUnbox() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessRead() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessWrite() {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessExecute(int argumentsLength) {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessInvoke(int argumentsLength) {
+            return null;
+        }
+
+        @Override
+        public CallTarget accessMessage(Message unknown) {
+            return null;
+        }
+
+    }
+}