jruby · Jul 27, 2017 · Jul 27, 2017 · Jul 28, 2017 · Jul 28, 2017 · Jul 29, 2017
diff --git a/core/src/main/java/org/jruby/IncludedModuleWrapper.java b/core/src/main/java/org/jruby/IncludedModuleWrapper.java
@@ -107,12 +107,12 @@ protected boolean isSame(RubyModule module) {
     }
 
     @Override
-    public Map<String, DynamicMethod> getMethods() {
+    public Map<RubySymbol, DynamicMethod> getMethods() {
         return origin.getMethods();
     }
 
     @Override
-    public Map<String, DynamicMethod> getMethodsForWrite() {
+    public Map<RubySymbol, DynamicMethod> getMethodsForWrite() {
         return origin.getMethodsForWrite();
     }
 
@@ -209,7 +209,7 @@ protected IRubyObject getAutoloadConstant(String name, boolean forceLoad) {
     }
 
     @Override
-    protected DynamicMethod searchMethodCommon(String name) {
+    protected DynamicMethod searchMethodCommon(RubySymbol name) {
         // IncludedModuleWrapper needs to search prepended modules too, so search until we find methodLocation
         RubyModule module = origin;
         RubyModule methodLoc = origin.getMethodLocation();
@@ -225,4 +225,9 @@ protected DynamicMethod searchMethodCommon(String name) {
 
         return null;
     }
+
+    @Deprecated
+    protected DynamicMethod searchMethodCommon(String name) {
+        return searchMethodCommon(getRuntime().newSymbol(name));
+    }
 }
diff --git a/core/src/main/java/org/jruby/PrependedModule.java b/core/src/main/java/org/jruby/PrependedModule.java
@@ -44,9 +44,9 @@ public class PrependedModule extends IncludedModule {
     public PrependedModule(Ruby runtime, RubyClass superClass, RubyModule origin) {
         super(runtime, superClass, origin);
         methods = origin.methods;
-        origin.methods = new ConcurrentHashMap<String, DynamicMethod>(0, 0.9f, 1);
+        origin.methods = new ConcurrentHashMap<RubySymbol, DynamicMethod>(0, 0.9f, 1);
         origin.methodLocation = this;
-        for (Map.Entry<String, DynamicMethod> entry : methods.entrySet()) {
+        for (Map.Entry<RubySymbol, DynamicMethod> entry : methods.entrySet()) {
             DynamicMethod method = entry.getValue();
             method.setImplementationClass(this);
             method.setDefinedClass(origin);

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -52,6 +52,8 @@
 import org.jruby.ast.WhileNode;
 import org.jruby.compiler.Constantizable;
 import org.jruby.compiler.NotCompilableException;
+import org.jruby.ext.ffi.Struct;
+import org.jruby.ext.ffi.StructLayout;
 import org.jruby.ext.thread.ConditionVariable;
 import org.jruby.ext.thread.Mutex;
 import org.jruby.ext.thread.SizedQueue;
@@ -65,6 +67,7 @@
 import org.jruby.runtime.JavaSites;
 import org.jruby.runtime.invokedynamic.InvokeDynamicSupport;
 import org.jruby.util.MRIRecursionGuard;
+import org.jruby.util.StringSupport;
 import org.jruby.util.StrptimeParser;
 import org.jruby.util.StrptimeToken;
 import org.objectweb.asm.util.TraceClassVisitor;
@@ -707,7 +710,7 @@ private RootNode addGetsLoop(RootNode oldRoot, boolean printing, boolean process
         GlobalVarNode dollarUnderscore = new GlobalVarNode(pos, newSymbol("$_"));
 
         BlockNode whileBody = new BlockNode(pos);
-        newBody.add(new WhileNode(pos, new VCallNode(pos, "gets"), whileBody));
+        newBody.add(new WhileNode(pos, new VCallNode(pos, newSymbol("gets")), whileBody));
 
         if (processLineEndings) whileBody.add(new CallNode(pos, dollarUnderscore, newSymbol("chop!"), null, null, false));
         if (split) whileBody.add(new GlobalAsgnNode(pos, newSymbol("$F"), new CallNode(pos, dollarUnderscore, newSymbol("split"), null, null, false)));
@@ -1302,22 +1305,28 @@ private void initRoot() {
         objectClass = RubyClass.createBootstrapClass(this, "Object", basicObjectClass, RubyObject.OBJECT_ALLOCATOR);
         moduleClass = RubyClass.createBootstrapClass(this, "Module", objectClass, RubyModule.MODULE_ALLOCATOR);
         classClass = RubyClass.createBootstrapClass(this, "Class", moduleClass, RubyClass.CLASS_ALLOCATOR);
+        symbolClass = RubyClass.createBootstrapClass(this, "Symbol", objectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
 
         basicObjectClass.setMetaClass(classClass);
         objectClass.setMetaClass(basicObjectClass);
         moduleClass.setMetaClass(classClass);
         classClass.setMetaClass(classClass);
+        symbolClass.setMetaClass(classClass);
+
+        sites = new JavaSites(this);
 
         RubyClass metaClass;
         metaClass = basicObjectClass.makeMetaClass(classClass);
         metaClass = objectClass.makeMetaClass(metaClass);
         metaClass = moduleClass.makeMetaClass(metaClass);
         metaClass = classClass.makeMetaClass(metaClass);
+        symbolClass.makeMetaClass(classClass);
 
         RubyBasicObject.createBasicObjectClass(this, basicObjectClass);
         RubyObject.createObjectClass(this, objectClass);
         RubyModule.createModuleClass(this, moduleClass);
         RubyClass.createClassClass(this, classClass);
+        RubySymbol.createSymbolClass(this, symbolClass);
 
         // set constants now that they're initialized
         basicObjectClass.setConstant("BasicObject", basicObjectClass);
@@ -1378,7 +1387,7 @@ private void initCore() {
 
         encodingService = new EncodingService(this);
 
-        RubySymbol.createSymbolClass(this);
+        RubySymbol.finishCreatingSymbolClass(this, symbolClass);
 
         if (profile.allowClass("ThreadGroup")) {
             RubyThreadGroup.createThreadGroupClass(this);
@@ -3491,7 +3500,7 @@ public RubyString newStringShared(ByteList byteList) {
     }
 
     public RubySymbol newSymbol(String name) {
-        return symbolTable.getSymbol(name);
+        return symbolTable.getSymbol(new String(name.getBytes(), RubyEncoding.ISO));
     }
 
     public RubySymbol newSymbol(String name, Encoding encoding) {
@@ -4448,11 +4457,17 @@ public List<StrptimeToken> getCachedStrptimePattern(String pattern) {
      * @param name the name of the method
      * @param method
      */
-    void addProfiledMethod(final String name, final DynamicMethod method) {
+    void addProfiledMethod(final RubySymbol name, final DynamicMethod method) {
         if (!config.isProfiling()) return;
         if (method.isUndefined()) return;
 
-        getProfilingService().addProfiledMethod( name, method );
+        // FIXME: profiled methods must end up as symbols eventually
+        getProfilingService().addProfiledMethod(StringSupport.byteListAsString(name.getBytes()), method );
+    }
+
+    @Deprecated
+    void addProfiledMethod(final String name, final DynamicMethod method) {
+        addProfiledMethod(newSymbol(name), method);
     }
 
     /**
@@ -4895,6 +4910,16 @@ private MRIRecursionGuard oldRecursionGuard() {
 
     private RubyThreadGroup defaultThreadGroup;
 
+    private StructLayout.FieldIO structLayoutDefaultIO;
+
+    public void setStructLayoutDefaultIO(StructLayout.FieldIO defaultIO) {
+        this.structLayoutDefaultIO = defaultIO;
+    }
+
+    public StructLayout.FieldIO getStructLayoutDefaultIO() {
+        return structLayoutDefaultIO;
+    }
+
     /**
      * All the core classes we keep hard references to. These are here largely
      * so that if someone redefines String or Array we won't start blowing up
@@ -5175,7 +5200,8 @@ protected TypePopulator computeValue(Class<?> type) {
         }
     };
 
-    public final JavaSites sites = new JavaSites();
+    // FIXME: Removed final here but we cannot setup sites until we have RubySymbol bootstrapped
+    public JavaSites sites;
 
     private volatile MRIRecursionGuard mriRecursionGuard;
 

diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -2370,7 +2370,7 @@ public IRubyObject methods19(ThreadContext context, IRubyObject[] args) {
 
     final IRubyObject methodsImpl(ThreadContext context, final boolean all) {
         final RubyArray methods = RubyArray.newArray(context.runtime);
-        final Set<String> seen = new HashSet<>();
+        final Set<RubySymbol> seen = new HashSet<>();
 
         RubyClass metaClass = getMetaClass();
         if (metaClass.isSingleton()) {
@@ -2494,20 +2494,20 @@ public RubyArray singleton_methods(ThreadContext context, IRubyObject[] args) {
 
         if (klass.isSingleton()) {
             Set<RubySymbol> names = new HashSet<>();
-            for (Map.Entry<String, DynamicMethod> entry : klass.getMethods().entrySet()) {
+            for (Map.Entry<RubySymbol, DynamicMethod> entry : klass.getMethods().entrySet()) {
                 if (entry.getValue().getVisibility() == PRIVATE) continue;
                 // TODO: needs to use method_entry_i logic from MRI
-                names.add(runtime.newSymbol(entry.getKey()));
+                names.add(entry.getKey());
             }
 
             if (all) {
                 klass = klass.getSuperClass();
                 while (klass != null && (klass.isSingleton() || klass.isIncluded())) {
                     if (klass != origin) {
-                        for (Map.Entry<String, DynamicMethod> entry : klass.getMethods().entrySet()) {
+                        for (Map.Entry<RubySymbol, DynamicMethod> entry : klass.getMethods().entrySet()) {
                             if (entry.getValue().getVisibility() == PRIVATE) continue;
                             // TODO: needs to use method_entry_i logic from MRI
-                            names.add(runtime.newSymbol(entry.getKey()));
+                            names.add(entry.getKey());
                         }
                     }
                     klass = klass.getSuperClass();

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -91,6 +91,7 @@
 import org.jruby.util.ClassDefiningClassLoader;
 import org.jruby.util.CodegenUtils;
 import org.jruby.util.JavaNameMangler;
+import org.jruby.util.StringSupport;
 import org.jruby.util.collections.WeakHashSet;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
@@ -237,14 +238,6 @@ public IRubyObject allocate() {
         return obj;
     }
 
-    public CallSite getBaseCallSite(int idx) {
-        return baseCallSites[idx];
-    }
-
-    public CallSite[] getBaseCallSites() {
-        return baseCallSites;
-    }
-
     public CallSite[] getExtraCallSites() {
         return extraCallSites;
     }
@@ -734,9 +727,11 @@ private IRubyObject checkFuncallDefault(ThreadContext context, IRubyObject self,
 
         DynamicMethod me = sites.site.retrieveCache(klass).method;
         if (!checkFuncallCallable(context, me, CallType.FUNCTIONAL, self)) {
-            return checkFuncallMissing(context, klass, self, sites.methodName, sites.respond_to_missing, sites.method_missing, args);
+            // FIXME: Broken for mbc strings which are not Java charsets
+            return checkFuncallMissing(context, klass, self, sites.methodName.asJavaString(), sites.respond_to_missing, sites.method_missing, args);
         }
-        return me.call(context, self, klass, sites.methodName, args);
+        // FIXME: Broken for mbc strings which are not Java charsets
+        return me.call(context, self, klass, sites.methodName.asJavaString(), args);
     }
 
     // MRI: rb_check_funcall_default
@@ -746,9 +741,11 @@ private IRubyObject checkFuncallDefault(ThreadContext context, IRubyObject self,
 
         DynamicMethod me = sites.site.retrieveCache(klass).method;
         if (!checkFuncallCallable(context, me, CallType.FUNCTIONAL, self)) {
-            return checkFuncallMissing(context, klass, self, sites.methodName, sites.respond_to_missing, sites.method_missing);
+            // FIXME: Broken for mbc strings which are not Java charsets
+            return checkFuncallMissing(context, klass, self, sites.methodName.asJavaString(), sites.respond_to_missing, sites.method_missing);
         }
-        return me.call(context, self, klass, sites.methodName);
+        // FIXME: Broken for mbc strings which are not Java charsets
+        return me.call(context, self, klass, sites.methodName.asJavaString());
     }
 
     // MRI: check_funcall_exec
@@ -986,41 +983,52 @@ public IRubyObject invokeInherited(ThreadContext context, IRubyObject self, IRub
         return method.call(context, self, getMetaClass(), "inherited", subclass, Block.NULL_BLOCK);
     }
 
+    protected CacheEntry initializeCacheEntry(ThreadContext context) {
+        CacheEntry entry = initializeCallCacheEntry;
+        if (entry == null) {
+            DynamicMethod method = searchMethod(context.runtime.newSymbol("initialize"));
+            entry = new CacheEntry(method, getGeneration());
+            initializeCallCacheEntry = entry;
+        }
+
+        return entry;
+    }
+
     /** rb_class_new_instance
     *
     */
     @JRubyMethod(name = "new", omit = true)
     public IRubyObject newInstance(ThreadContext context, Block block) {
         IRubyObject obj = allocate();
-        baseCallSites[CS_IDX_INITIALIZE].call(context, obj, obj, block);
+        initializeCacheEntry(context).method.call(context, obj, this, "initialize", block);
         return obj;
     }
 
     @JRubyMethod(name = "new", omit = true)
     public IRubyObject newInstance(ThreadContext context, IRubyObject arg0, Block block) {
         IRubyObject obj = allocate();
-        baseCallSites[CS_IDX_INITIALIZE].call(context, obj, obj, arg0, block);
+        initializeCacheEntry(context).method.call(context, obj, this, "initialize", arg0, block);
         return obj;
     }
 
     @JRubyMethod(name = "new", omit = true)
     public IRubyObject newInstance(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) {
         IRubyObject obj = allocate();
-        baseCallSites[CS_IDX_INITIALIZE].call(context, obj, obj, arg0, arg1, block);
+        initializeCacheEntry(context).method.call(context, obj, this, "initialize", arg0, arg1, block);
         return obj;
     }
 
     @JRubyMethod(name = "new", omit = true)
     public IRubyObject newInstance(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
         IRubyObject obj = allocate();
-        baseCallSites[CS_IDX_INITIALIZE].call(context, obj, obj, arg0, arg1, arg2, block);
+        initializeCacheEntry(context).method.call(context, obj, this, "initialize", arg0, arg1, arg2, block);
         return obj;
     }
 
     @JRubyMethod(name = "new", rest = true, omit = true)
     public IRubyObject newInstance(ThreadContext context, IRubyObject[] args, Block block) {
         IRubyObject obj = allocate();
-        baseCallSites[CS_IDX_INITIALIZE].call(context, obj, obj, args, block);
+        initializeCacheEntry(context).method.call(context, obj, this, "initialize", args, block);
         return obj;
     }
 
@@ -1546,8 +1554,10 @@ byte[] reify(final String javaName, final String javaPath) {
             final Set<String> instanceMethods = new HashSet<String>(getMethods().size());
 
             // define instance methods
-            for (Map.Entry<String,DynamicMethod> methodEntry : getMethods().entrySet()) {
-                final String methodName = methodEntry.getKey();
+            for (Map.Entry<RubySymbol,DynamicMethod> methodEntry : getMethods().entrySet()) {
+                // FIXME: this unravels too much to convert this to Symbol.  Accept limitation for now plus
+                // we cannot reify all ruby method names so this might be a touch different?
+                final String methodName = StringSupport.byteListAsString(methodEntry.getKey().getBytes());
 
                 if ( ! JavaNameMangler.willMethodMangleOk(methodName) ) {
                     LOG.debug("{} method: '{}' won't be part of reified Java class", getName(), methodName);
@@ -1656,8 +1666,8 @@ byte[] reify(final String javaName, final String javaPath) {
             }
 
             // define class/static methods
-            for (Map.Entry<String,DynamicMethod> methodEntry : getMetaClass().getMethods().entrySet()) {
-                String methodName = methodEntry.getKey();
+            for (Map.Entry<RubySymbol,DynamicMethod> methodEntry : getMetaClass().getMethods().entrySet()) {
+                String methodName = StringSupport.byteListAsString(methodEntry.getKey().getBytes());
 
                 if (!JavaNameMangler.willMethodMangleOk(methodName)) continue;
 
@@ -2321,33 +2331,12 @@ public IRubyObject invoke(ThreadContext context, IRubyObject self, String name,
     private ObjectAllocator allocator; // the default allocator
     protected ObjectMarshal marshal;
     private Set<RubyClass> subclasses;
-    public static final int CS_IDX_INITIALIZE = 0;
-    public enum CS_NAMES {
-        INITIALIZE("initialize");
-
-        CS_NAMES(String id) {
-            this.id = id;
-        }
 
-        private static final CS_NAMES[] VALUES = values();
-        public static final int length = VALUES.length;
-
-        public static CS_NAMES fromOrdinal(int ordinal) {
-            if (ordinal < 0 || ordinal >= VALUES.length) {
-                throw new RuntimeException("invalid rest: " + ordinal);
-            }
-            return VALUES[ordinal];
-        }
-
-        public final String id;
-    }
-
-    private final CallSite[] baseCallSites = new CallSite[CS_NAMES.length];
-    {
-        for(int i = 0; i < baseCallSites.length; i++) {
-            baseCallSites[i] = MethodIndex.getFunctionalCallSite(CS_NAMES.fromOrdinal(i).id);
-        }
-    }
+    /**
+     * Because we need classes during bootstrap to callsite cache initialize and RubySymbol has not yet
+     * come into being we just maintain the cache entry manually.
+     */
+    private CacheEntry initializeCallCacheEntry;
 
     private CallSite[] extraCallSites;
 

diff --git a/core/src/main/java/org/jruby/RubyComplex.java b/core/src/main/java/org/jruby/RubyComplex.java
@@ -438,12 +438,9 @@ public static IRubyObject convert(ThreadContext context, IRubyObject recv, IRuby
     }
 
     private static boolean responds_to_to_c(ThreadContext context, IRubyObject obj) {
-        return respond_to_to_c.respondsTo(context, obj, obj);
+        return sites(context).respond_to_to_c.respondsTo(context, obj, obj);
     }
 
-    // TODO: wasn't sure whether to put this on NumericSites, here for now - should move
-    static final RespondToCallSite respond_to_to_c = new RespondToCallSite("to_c");
-
     /** nucomp_s_convert
      * 
      */