jruby · Apr 6, 2015 · Apr 6, 2015 · Apr 6, 2015
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java
@@ -110,13 +110,15 @@ public abstract static class TranscodingMapNode extends CoreMethodNode {
         @Child private CallDispatchHeadNode toSymNode;
         @Child private CallDispatchHeadNode newLookupTableNode;
         @Child private CallDispatchHeadNode lookupTableWriteNode;
+        @Child private CallDispatchHeadNode newTranscodingNode;
 
         public TranscodingMapNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
             upcaseNode = DispatchHeadNodeFactory.createMethodCall(context);
             toSymNode = DispatchHeadNodeFactory.createMethodCall(context);
             newLookupTableNode = DispatchHeadNodeFactory.createMethodCall(context);
             lookupTableWriteNode = DispatchHeadNodeFactory.createMethodCall(context);
+            newTranscodingNode = DispatchHeadNodeFactory.createMethodCall(context);
         }
 
         public TranscodingMapNode(TranscodingMapNode prev) {
@@ -125,6 +127,7 @@ public TranscodingMapNode(TranscodingMapNode prev) {
             toSymNode = prev.toSymNode;
             newLookupTableNode = prev.newLookupTableNode;
             lookupTableWriteNode = prev.lookupTableWriteNode;
+            newTranscodingNode = prev.newTranscodingNode;
         }
 
         @Specialization
@@ -145,7 +148,8 @@ public Object transcodingMap(VirtualFrame frame) {
 
                     final Object upcasedLookupTableKey = upcaseNode.call(frame, getContext().makeString(new ByteList(e.getDestination())), "upcase", null);
                     final Object lookupTableKey = toSymNode.call(frame, upcasedLookupTableKey, "to_sym", null);
-                    lookupTableWriteNode.call(frame, value, "[]=", null, lookupTableKey, true);
+                    final Object lookupTableValue = newTranscodingNode.call(frame, getContext().getCoreLibrary().getTranscodingClass(), "create", null, key, lookupTableKey);
+                    lookupTableWriteNode.call(frame, value, "[]=", null, lookupTableKey, lookupTableValue);
                 }
 
                 lookupTableWriteNode.call(frame, ret, "[]=", null, key, value);
@@ -155,25 +159,4 @@ public Object transcodingMap(VirtualFrame frame) {
         }
     }
 
-    @RubiniusOnly
-    @CoreMethod(names = "transcoding_path_lookup", onSingleton = true, required = 2)
-    public abstract static class TranscodingPathLookupNode extends CoreMethodNode {
-
-        public TranscodingPathLookupNode(RubyContext context, SourceSection sourceSection) {
-            super(context, sourceSection);
-        }
-
-        public TranscodingPathLookupNode(TranscodingPathLookupNode prev) {
-            super(prev);
-        }
-
-        @Specialization
-        public boolean transcodingPathLookup(RubyString sourceEncodingName, RubyString destinationEncodingName) {
-            final TranscoderDB.Entry entry = TranscoderDB.getEntry(sourceEncodingName.getByteList().getUnsafeBytes(),
-                    destinationEncodingName.getByteList().getUnsafeBytes());
-
-            return entry.getTranscoder() != null;
-        }
-    }
-
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
@@ -108,6 +108,7 @@ public class CoreLibrary {
     private final RubyClass systemStackErrorClass;
     private final RubyClass threadClass;
     private final RubyClass timeClass;
+    private final RubyClass transcodingClass;
     private final RubyClass trueClass;
     private final RubyClass tupleClass;
     private final RubyClass typeErrorClass;
@@ -310,6 +311,7 @@ public CoreLibrary(RubyContext context) {
         byteArrayClass = defineClass(rubiniusModule, objectClass, "ByteArray");
         lookupTableClass = defineClass(rubiniusModule, hashClass, "LookupTable");
         stringDataClass = defineClass(rubiniusModule, objectClass, "StringData");
+        transcodingClass = defineClass(encodingClass, objectClass, "Transcoding");
         tupleClass = defineClass(rubiniusModule, arrayClass, "Tuple");
 
         // Include the core modules
@@ -1194,6 +1196,10 @@ public RubyClass getStringDataClass() {
         return stringDataClass;
     }
 
+    public RubyClass getTranscodingClass() {
+        return transcodingClass;
+    }
+
     public RubyClass getTupleClass() {
         return tupleClass;
     }

diff --git a/truffle/src/main/ruby/core/rubinius/api/shims/encoding.rb b/truffle/src/main/ruby/core/rubinius/api/shims/encoding.rb
@@ -1,4 +1,25 @@
 class Encoding
+  # There's a fun bootstrapping issue here.  Encoding::Converter.transcoding_map needs access to the Encoding::Transcoding
+  # class. However, this shim runs before Encoding::Transcoding is defined.  Since the class body is short, we reproduce
+  # it here along with a convenient factory method.
+  class Transcoding
+    attr_accessor :source
+    attr_accessor :target
+
+    def inspect
+      "#<#{super} #{source} to #{target}"
+    end
+
+    def self.create(source, target)
+      ret = new
+
+      ret.source = source
+      ret.target = target
+
+      ret
+    end
+  end
+
   TranscodingMap = Encoding::Converter.transcoding_map
   EncodingMap = Encoding.encoding_map
   EncodingList = Encoding.list

diff --git a/truffle/src/main/ruby/core/rubinius/api/shims/lookuptable.rb b/truffle/src/main/ruby/core/rubinius/api/shims/lookuptable.rb
@@ -13,7 +13,14 @@ class LookupTable < Hash
     alias_method :lookup_orig, :[]
 
     def [](key)
-      lookup_orig(key.to_sym)
+      lookup_orig(key_to_sym(key))
+    end
+
+    private
+
+    # Taken from Rubinius LookupTable.
+    def key_to_sym(key)
+      key.kind_of?(String) ? key.to_sym : key
     end
   end
 end