jruby · Oct 17, 2014 · Oct 17, 2014 · Oct 17, 2014 · Oct 17, 2014 · Oct 20, 2014
diff --git a/core/src/main/java/org/jruby/compiler/JITCompiler.java b/core/src/main/java/org/jruby/compiler/JITCompiler.java
@@ -252,14 +252,9 @@ public void run() {
                 method.switchToJitted(
                         new CompiledIRMethod(
                                 handle,
-                                method.getName(),
-                                method.getFile(),
-                                method.getLine(),
-                                method.getStaticScope(),
+                                method.getIRMethod(),
                                 method.getVisibility(),
-                                method.getImplementationClass(),
-                                Helpers.encodeParameterList(method.getParameterList()),
-                                method.getIRMethod().hasExplicitCallProtocol()));
+                                method.getImplementationClass()));
 
                 return;
             } catch (Throwable t) {

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/CompiledIRMetaClassBody.java b/core/src/main/java/org/jruby/internal/runtime/methods/CompiledIRMetaClassBody.java
@@ -0,0 +1,65 @@
+package org.jruby.internal.runtime.methods;
+
+import org.jruby.RubyModule;
+import org.jruby.ir.IRFlags;
+import org.jruby.ir.IRMetaClassBody;
+import org.jruby.ir.IRScope;
+import org.jruby.ir.interpreter.InterpreterContext;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.lang.invoke.MethodHandle;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CompiledIRMetaClassBody extends CompiledIRMethod {
+    private final IRMetaClassBody irMetaClassBody;
+    private final boolean reuseParentDynScope;
+    private final boolean pushNewDynScope;
+    private final boolean popDynScope;
+
+    public CompiledIRMetaClassBody(MethodHandle handle, IRScope scope, RubyModule implementationClass) {
+        super(handle, scope, Visibility.PUBLIC, implementationClass);
+
+        irMetaClassBody = (IRMetaClassBody)scope;
+        this.reuseParentDynScope = scope.getFlags().contains(IRFlags.REUSE_PARENT_DYNSCOPE);
+        this.pushNewDynScope = !scope.getFlags().contains(IRFlags.DYNSCOPE_ELIMINATED) && !this.reuseParentDynScope;
+        this.popDynScope = this.pushNewDynScope || this.reuseParentDynScope;
+    }
+
+    public String[] getParameterList() {
+        return new String[0];
+    }
+
+    @Override
+    protected void post(ThreadContext context) {
+        // update call stacks (pop: ..)
+        context.popFrame();
+        if (popDynScope) {
+            context.popScope();
+        }
+    }
+
+    @Override
+    protected void pre(ThreadContext context, IRubyObject self, String name, Block block) {
+        // update call stacks (push: frame, class, scope, etc.)
+        context.preMethodFrameOnly(getImplementationClass(), name, self, block);
+        if (pushNewDynScope) {
+            // Add a parent-link to current dynscope to support non-local returns cheaply
+            // This doesn't affect variable scoping since local variables will all have
+            // the right scope depth.
+            context.pushScope(DynamicScope.newDynamicScope(method.getStaticScope(), context.getCurrentScope()));
+        }
+        context.setCurrentVisibility(getVisibility());
+    }
+
+    @Override
+    public DynamicMethod dup() {
+        CompiledIRMetaClassBody x = new CompiledIRMetaClassBody(handle, method, implementationClass);
+
+        return x;
+    }
+}
diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/CompiledIRMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/CompiledIRMethod.java
@@ -1,6 +1,8 @@
 package org.jruby.internal.runtime.methods;
 
 import org.jruby.RubyModule;
+import org.jruby.ir.IRMethod;
+import org.jruby.ir.IRScope;
 import org.jruby.ir.runtime.IRRuntimeHelpers;
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.Arity;
@@ -13,55 +15,46 @@
 import org.jruby.util.log.LoggerFactory;
 
 import java.lang.invoke.MethodHandle;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.jruby.runtime.Helpers;
 
-public class CompiledIRMethod extends JavaMethod implements Cloneable, PositionAware, MethodArgs2 {
+public class CompiledIRMethod extends JavaMethod implements MethodArgs2, PositionAware {
     private static final Logger LOG = LoggerFactory.getLogger("CompiledIRMethod");
 
-    private final MethodHandle method;
-    private final String name;
-    private final String file;
-    private final int line;
-    private final StaticScope scope;
-    private Arity arity;
-    private final boolean hasExplicitCallProtocol;
-
-    public CompiledIRMethod(MethodHandle method, String name, String file, int line, StaticScope scope,
-                            Visibility visibility, RubyModule implementationClass, String parameterDesc, boolean hasExplicitCallProtocol) {
-        super(implementationClass, visibility, CallConfiguration.FrameNoneScopeNone);
+    protected final MethodHandle handle;
+
+    protected final IRScope method;
+    private final Arity arity;
+    private String[] parameterList;
+
+    public CompiledIRMethod(MethodHandle handle, IRScope method, Visibility visibility, RubyModule implementationClass) {
+        super(implementationClass, visibility, CallConfiguration.FrameNoneScopeNone, method.getName());
+        this.handle = handle;
         this.method = method;
-        this.name = name;
-        this.file = file;
-        this.line = line;
-        this.scope = scope;
-        this.scope.determineModule();
+        this.method.getStaticScope().determineModule();
         this.arity = calculateArity();
-        this.hasExplicitCallProtocol = hasExplicitCallProtocol;
 
-        setParameterDesc(parameterDesc);
+        setHandle(handle);
+    }
 
-        setHandle(method);
+    public IRScope getIRMethod() {
+        return method;
     }
 
-    public CompiledIRMethod(MethodHandle method, String name, String file, int line, StaticScope scope,
-                            Visibility visibility, RubyModule implementationClass, String[] parameterList, boolean hasExplicitCallProtocol) {
-        super(implementationClass, visibility, CallConfiguration.FrameNoneScopeNone);
-        this.method = method;
-        this.name = name;
-        this.file = file;
-        this.line = line;
-        this.scope = scope;
-        this.scope.determineModule();
-        this.arity = calculateArity();
-        this.hasExplicitCallProtocol = hasExplicitCallProtocol;
+    public StaticScope getStaticScope() {
+        return method.getStaticScope();
+    }
 
-        setParameterList(parameterList);
+    public String[] getParameterList() {
+        if (parameterList != null) return parameterList;
 
-        setHandle(method);
+        return parameterList = Helpers.irMethodArgsToParameters(((IRMethod)method).getArgDesc());
     }
 
     private Arity calculateArity() {
-        StaticScope s = scope;
+        StaticScope s = getStaticScope();
         if (s.getOptionalArgs() > 0 || s.getRestArg() >= 0) return Arity.required(s.getRequiredArgs());
 
         return Arity.createArity(s.getRequiredArgs());
@@ -72,158 +65,54 @@ public Arity getArity() {
         return this.arity;
     }
 
-    @Override
-    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) {
-        if (IRRuntimeHelpers.isDebug()) {
-            // FIXME: name should probably not be "" ever.
-            String realName = name == null || "".equals(name) ? this.name : name;
-            LOG.info("Executing '" + realName + "'");
-        }
-
-        if (!hasExplicitCallProtocol) {
-            // update call stacks (push: frame, class, scope, etc.)
-            RubyModule implementationClass = getImplementationClass();
-            context.preMethodFrameAndScope(implementationClass, name, self, block, scope);
-            // FIXME: does not seem right to use this method's visibility as current!!!
-            // See also PushFrame instruction in org.jruby.ir.targets.JVMVisitor
-            context.setCurrentVisibility(Visibility.PUBLIC);
-        }
-
-        try {
-            return (IRubyObject)this.method.invokeExact(context, scope, self, args, block, implementationClass);
-        } catch (Throwable t) {
-            Helpers.throwException(t);
-            // not reached
-            return null;
-        } finally {
-            if (!hasExplicitCallProtocol) {
-                // update call stacks (pop: ..)
-                context.popFrame();
-                context.postMethodScopeOnly();
-            }
-        }
-    }
-
-    public boolean hasExplicitCallProtocol() {
-        return hasExplicitCallProtocol;
-    }
-// Because compiled IR methods have been simplified to just use IRubyObject[], we have no specific-arity paths.
-// This will come later by specializing the IR.
-/*
-    @Override
-    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, Block block) {
-        if (IRRuntimeHelpers.isDebug()) {
-            // FIXME: name should probably not be "" ever.
-            String realName = name == null || "".equals(name) ? this.name : name;
-            LOG.info("Executing '" + realName + "'");
-        }
-
-        try {
-            // update call stacks (push: frame, class, scope, etc.)
-            RubyModule implementationClass = getImplementationClass();
-            context.preMethodFrameAndScope(implementationClass, name, self, block, scope);
-            context.setCurrentVisibility(getVisibility());
-            return (IRubyObject)this.method.invokeWithArguments(context, scope, self, block);
-        } catch (Throwable t) {
-            Helpers.throwException(t);
-            // not reached
-            return null;
-        } finally {
+    protected void post(ThreadContext context) {
+        if (!method.hasExplicitCallProtocol()) {
             // update call stacks (pop: ..)
             context.popFrame();
             context.postMethodScopeOnly();
         }
     }
 
-    @Override
-    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, Block block) {
-        if (IRRuntimeHelpers.isDebug()) {
-            // FIXME: name should probably not be "" ever.
-            String realName = name == null || "".equals(name) ? this.name : name;
-            LOG.info("Executing '" + realName + "'");
-        }
-
-        try {
+    protected void pre(ThreadContext context, IRubyObject self, String name, Block block) {
+        if (!method.hasExplicitCallProtocol()) {
             // update call stacks (push: frame, class, scope, etc.)
             RubyModule implementationClass = getImplementationClass();
-            context.preMethodFrameAndScope(implementationClass, name, self, block, scope);
-            context.setCurrentVisibility(getVisibility());
-            return (IRubyObject)this.method.invokeWithArguments(context, scope, self, arg0, block);
-        } catch (Throwable t) {
-            Helpers.throwException(t);
-            // not reached
-            return null;
-        } finally {
-            // update call stacks (pop: ..)
-            context.popFrame();
-            context.postMethodScopeOnly();
+            context.preMethodFrameAndScope(implementationClass, name, self, block, method.getStaticScope());
+            // FIXME: does not seem right to use this method's visibility as current!!!
+            // See also PushFrame instruction in org.jruby.ir.targets.JVMVisitor
+            context.setCurrentVisibility(Visibility.PUBLIC);
         }
     }
 
     @Override
-    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, IRubyObject arg1, Block block) {
-        if (IRRuntimeHelpers.isDebug()) {
-            // FIXME: name should probably not be "" ever.
-            String realName = name == null || "".equals(name) ? this.name : name;
-            LOG.info("Executing '" + realName + "'");
-        }
+    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) {
+        pre(context, self, name, block);
 
         try {
-            // update call stacks (push: frame, class, scope, etc.)
-            RubyModule implementationClass = getImplementationClass();
-            context.preMethodFrameAndScope(implementationClass, name, self, block, scope);
-            context.setCurrentVisibility(getVisibility());
-            return (IRubyObject)this.method.invokeWithArguments(context, scope, self, arg0, arg1, block);
+            return (IRubyObject)this.handle.invokeExact(context, method.getStaticScope(), self, args, block, implementationClass);
         } catch (Throwable t) {
             Helpers.throwException(t);
             // not reached
             return null;
         } finally {
-            // update call stacks (pop: ..)
-            context.popFrame();
-            context.postMethodScopeOnly();
+            post(context);
         }
     }
 
-    @Override
-    public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
-        if (IRRuntimeHelpers.isDebug()) {
-            // FIXME: name should probably not be "" ever.
-            String realName = name == null || "".equals(name) ? this.name : name;
-            LOG.info("Executing '" + realName + "'");
-        }
-
-        try {
-            // update call stacks (push: frame, class, scope, etc.)
-            RubyModule implementationClass = getImplementationClass();
-            context.preMethodFrameAndScope(implementationClass, name, self, block, scope);
-            context.setCurrentVisibility(getVisibility());
-            return (IRubyObject)this.method.invokeWithArguments(context, scope, self, arg0, arg1, arg2, block);
-        } catch (Throwable t) {
-            Helpers.throwException(t);
-            // not reached
-            return null;
-        } finally {
-            // update call stacks (pop: ..)
-            context.popFrame();
-            context.postMethodScopeOnly();
-        }
+    public boolean hasExplicitCallProtocol() {
+        return method.hasExplicitCallProtocol();
     }
-*/
+
     @Override
     public DynamicMethod dup() {
-        return new CompiledIRMethod(method, name, file, line, scope, visibility, implementationClass, getParameterList(), hasExplicitCallProtocol);
+        return new CompiledIRMethod(handle, method, visibility, implementationClass);
     }
 
     public String getFile() {
-        return file;
+        return method.getFileName();
     }
 
     public int getLine() {
-        return line;
-	}
-
-    public StaticScope getStaticScope() {
-        return scope;
+        return method.getLineNumber();
     }
 }
diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/IRMethodArgs.java b/core/src/main/java/org/jruby/internal/runtime/methods/IRMethodArgs.java
@@ -4,4 +4,8 @@
 
 public interface IRMethodArgs {
     public List<String[]> getParameterList();
+
+    public enum ArgType {
+        key, keyrest, block, opt, rest, req
+    }
 }