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/truffle/nodes/ReadConstantNode.java b/core/src/main/java/org/jruby/truffle/nodes/ReadConstantNode.java
@@ -12,44 +12,50 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.source.*;
 import com.oracle.truffle.api.frame.*;
-import com.oracle.truffle.api.nodes.UnexpectedResultException;
-import org.jruby.truffle.nodes.*;
-import org.jruby.truffle.nodes.cast.BoxingNode;
 import org.jruby.truffle.nodes.dispatch.Dispatch;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNode;
 import org.jruby.truffle.runtime.*;
 import org.jruby.truffle.runtime.control.*;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
 import org.jruby.truffle.runtime.core.RubyModule;
+import org.jruby.truffle.runtime.methods.MethodLike;
+import org.jruby.truffle.runtime.LexicalScope;
 
 public class ReadConstantNode extends RubyNode {
 
-    private final boolean isLiteral;
     private final String name;
     @Child protected RubyNode receiver;
     @Child protected DispatchHeadNode dispatch;
 
-    public ReadConstantNode(RubyContext context, SourceSection sourceSection, boolean isLiteral, String name, RubyNode receiver) {
+    public ReadConstantNode(RubyContext context, SourceSection sourceSection, String name, RubyNode receiver) {
         super(context, sourceSection);
-        this.isLiteral = isLiteral;
         this.name = name;
         this.receiver = receiver;
         dispatch = new DispatchHeadNode(context, Dispatch.MissingBehavior.CALL_CONST_MISSING);
     }
 
+    private LexicalScope getLexicalScope(VirtualFrame frame) {
+        MethodLike method = RubyArguments.getMethod(frame.getArguments());
+        if (method != null) {
+            return method.getSharedMethodInfo().getLexicalScope();
+        }
+        return null;
+    }
+
     @Override
     public Object execute(VirtualFrame frame) {
         final Object receiverObject = receiver.execute(frame);
 
-        if (isLiteral && !(receiverObject instanceof RubyModule)) {
+        if (!(receiverObject instanceof RubyModule)) {
             CompilerDirectives.transferToInterpreter();
             throw new RaiseException(getContext().getCoreLibrary().typeErrorIsNotA(receiverObject.toString(), "class/module", this));
         }
 
+        LexicalScope lexicalScope = getLexicalScope(frame);
+
         return dispatch.dispatch(
                 frame,
                 getContext().getCoreLibrary().getNilObject(),
-                RubyArguments.getSelf(frame.getArguments()),
+                lexicalScope,
                 receiverObject,
                 name,
                 null,
@@ -74,10 +80,10 @@ public Object isDefined(VirtualFrame frame) {
             return context.makeString("constant");
         }
 
-        Object value;
+        Object receiverObject;
 
         try {
-            value = ModuleOperations.lookupConstant(context.getCoreLibrary().box(receiver.execute(frame)).getMetaClass(), name);
+            receiverObject = receiver.execute(frame);
         } catch (RaiseException e) {
             /*
              * If we are looking up a constant in a constant that is itself undefined, we return Nil
@@ -91,6 +97,9 @@ public Object isDefined(VirtualFrame frame) {
             throw e;
         }
 
+        LexicalScope lexicalScope = getLexicalScope(frame);
+        Object value = ModuleOperations.lookupConstant(lexicalScope, (RubyModule) receiverObject, name);
+
         if (value == null) {
             return getContext().getCoreLibrary().getNilObject();
         } else {

diff --git a/core/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java b/core/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java
@@ -25,6 +25,7 @@
 import org.jruby.truffle.runtime.core.RubyArray;
 import org.jruby.truffle.runtime.methods.*;
 import org.jruby.truffle.runtime.util.ArrayUtils;
+import org.jruby.truffle.runtime.LexicalScope;
 
 import java.util.Arrays;
 
@@ -204,7 +205,7 @@ public Object isDefined(VirtualFrame frame) {
             }
         } else if (method.isUndefined()) {
             return getContext().getCoreLibrary().getNilObject();
-        } else if (!ignoreVisibility && !method.isVisibleTo(this, self)) {
+        } else if (!ignoreVisibility && !method.isVisibleTo(this, self.getMetaClass())) {
             return getContext().getCoreLibrary().getNilObject();
         }
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/core/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -18,6 +18,7 @@
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
 import org.jruby.truffle.nodes.dispatch.Dispatch;
 import org.jruby.truffle.nodes.yield.YieldDispatchNode;
+import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.RubyCallStack;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.UndefinedPlaceholder;
@@ -198,6 +199,10 @@ public Dispatch.DispatchAction executeDispatchAction(VirtualFrame frame) {
         throw new UnsupportedOperationException();
     }
 
+    public LexicalScope executeLexicalScope(VirtualFrame frame) {
+        throw new UnsupportedOperationException();
+    }
+
     public void executeVoid(VirtualFrame frame) {
         execute(frame);
     }

diff --git a/core/src/main/java/org/jruby/truffle/nodes/RubyTypes.java b/core/src/main/java/org/jruby/truffle/nodes/RubyTypes.java
@@ -20,6 +20,7 @@
 import org.jruby.truffle.runtime.core.RubyBasicObject;
 import org.jruby.truffle.runtime.rubinius.RubiniusByteArray;
 import org.jruby.truffle.runtime.rubinius.RubiniusChannel;
+import org.jruby.truffle.runtime.LexicalScope;
 
 import java.math.BigInteger;
 
@@ -29,6 +30,7 @@
  */
 @TypeSystem({ //
                 Dispatch.DispatchAction.class, //
+                LexicalScope.class, //
                 UndefinedPlaceholder.class, //
                 boolean.class, //
                 int.class, //

diff --git a/core/src/main/java/org/jruby/truffle/nodes/WriteConstantNode.java b/core/src/main/java/org/jruby/truffle/nodes/WriteConstantNode.java
@@ -15,6 +15,7 @@
 import com.oracle.truffle.api.nodes.*;
 import org.jruby.truffle.nodes.*;
 import org.jruby.truffle.runtime.*;
+import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.*;
 
 /**
@@ -37,16 +38,22 @@ public WriteConstantNode(RubyContext context, SourceSection sourceSection, Strin
     public Object execute(VirtualFrame frame) {
         notDesignedForCompilation();
 
-        // TODO(cs): can module ever not evaluate to a RubyModule?
-
-        final RubyModule moduleObject = (RubyModule) module.execute(frame);
-
+        // Evaluate RHS first.
         final Object rhsValue = rhs.execute(frame);
 
         assert rhsValue != null;
         assert !(rhsValue instanceof String);
 
-        moduleObject.setModuleConstant(this, name, rhsValue);
+        final Object receiverObject = module.execute(frame);
+
+        if (!(receiverObject instanceof RubyModule)) {
+            CompilerDirectives.transferToInterpreter();
+            throw new RaiseException(getContext().getCoreLibrary().typeErrorIsNotA(receiverObject.toString(), "class/module", this));
+        }
+
+        final RubyModule module = (RubyModule) receiverObject;
+
+        module.setModuleConstant(this, name, rhsValue);
 
         return rhsValue;
     }

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java
@@ -2320,7 +2320,7 @@ public MaxBlock(RubyContext context) {
             frameDescriptor = new FrameDescriptor();
             frameSlot = frameDescriptor.addFrameSlot("maximum_memo");
 
-            sharedMethodInfo = new SharedMethodInfo(sourceSection, "max", false, null);
+            sharedMethodInfo = SharedMethodInfo.generated(sourceSection, "max");
 
             callTarget = Truffle.getRuntime().createCallTarget(new RubyRootNode(
                     context, sourceSection, null, sharedMethodInfo,
@@ -2433,7 +2433,7 @@ public MinBlock(RubyContext context) {
             frameDescriptor = new FrameDescriptor();
             frameSlot = frameDescriptor.addFrameSlot("minimum_memo");
 
-            sharedMethodInfo = new SharedMethodInfo(sourceSection, "min", false, null);
+            sharedMethodInfo = SharedMethodInfo.generated(sourceSection, "min");
 
             callTarget = Truffle.getRuntime().createCallTarget(new RubyRootNode(
                     context, sourceSection, null, sharedMethodInfo,

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java b/core/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java
@@ -64,7 +64,7 @@ private static void addMethod(RubyClass rubyObjectClass, MethodDetails methodDet
             module = rubyObjectClass;
 
             for (String moduleName : methodDetails.getClassAnnotation().name().split("::")) {
-                module = (RubyModule) ModuleOperations.lookupConstant(module, moduleName).getValue();
+                module = (RubyModule) ModuleOperations.lookupConstant(null, module, moduleName).getValue();
             }
         }
 
@@ -120,7 +120,7 @@ private static void addMethod(RubyModule module, RubyMethod method, List<String>
     private static RubyRootNode makeGenericMethod(RubyContext context, MethodDetails methodDetails, boolean needsSelf) {
         final CoreSourceSection sourceSection = new CoreSourceSection(methodDetails.getClassAnnotation().name(), methodDetails.getMethodAnnotation().names()[0]);
 
-        final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(sourceSection, methodDetails.getIndicativeName(), false, null);
+        final SharedMethodInfo sharedMethodInfo = SharedMethodInfo.generated(sourceSection, methodDetails.getIndicativeName());
 
         final Arity arity = new Arity(methodDetails.getMethodAnnotation().minArgs(), methodDetails.getMethodAnnotation().maxArgs());
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -590,7 +590,7 @@ private static void exec(RubyContext context, String[] commandLine) {
             final ProcessBuilder builder = new ProcessBuilder(commandLine);
             builder.inheritIO();
 
-            final RubyHash env = (RubyHash) ModuleOperations.lookupConstant(context.getCoreLibrary().getObjectClass(), "ENV").getValue();
+            final RubyHash env = (RubyHash) ModuleOperations.lookupConstant(null, context.getCoreLibrary().getObjectClass(), "ENV").getValue();
 
             // TODO(CS): cast
             for (Map.Entry<Object, Object> entry : ((LinkedHashMap<Object, Object>) env.getStore()).entrySet()) {

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java b/core/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java
@@ -227,7 +227,7 @@ public static void attrReader(RubyNode currentNode, RubyContext context, SourceS
 
             final String indicativeName = name + "(attr_reader)";
 
-            final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(sourceSection, indicativeName, false, null);
+            final SharedMethodInfo sharedMethodInfo = SharedMethodInfo.generated(sourceSection, indicativeName);
             final RubyRootNode rootNode = new RubyRootNode(context, sourceSection, null, sharedMethodInfo, block);
             final CallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
             final RubyMethod method = new RubyMethod(sharedMethodInfo, name, module, Visibility.PUBLIC, false, callTarget, null);
@@ -280,7 +280,7 @@ public static void attrWriter(RubyNode currentNode, RubyContext context, SourceS
 
             final String indicativeName = name + "(attr_writer)";
 
-            final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(sourceSection, indicativeName, false, null);
+            final SharedMethodInfo sharedMethodInfo = SharedMethodInfo.generated(sourceSection, indicativeName);
             final RubyRootNode rootNode = new RubyRootNode(context, sourceSection, null, sharedMethodInfo, block);
             final CallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
             final RubyMethod method = new RubyMethod(sharedMethodInfo, name + "=", module, Visibility.PUBLIC, false, callTarget, null);
@@ -449,15 +449,15 @@ public ConstDefinedNode(ConstDefinedNode prev) {
         public boolean isConstDefined(RubyModule module, RubyString name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) {
             notDesignedForCompilation();
 
-            return ModuleOperations.lookupConstant(module, name.toString()) != null;
+            return ModuleOperations.lookupConstant(null, module, name.toString()) != null;
         }
 
         @Specialization
         public boolean isConstDefined(RubyModule module, RubyString name, boolean inherit) {
             notDesignedForCompilation();
 
             if (inherit) {
-                return ModuleOperations.lookupConstant(module, name.toString()) != null;
+                return ModuleOperations.lookupConstant(null, module, name.toString()) != null;
             } else {
                 return module.getConstants().containsKey(name.toString());
             }
@@ -467,7 +467,7 @@ public boolean isConstDefined(RubyModule module, RubyString name, boolean inheri
         public boolean isConstDefined(RubyModule module, RubySymbol name, @SuppressWarnings("unused") UndefinedPlaceholder inherit) {
             notDesignedForCompilation();
 
-            return ModuleOperations.lookupConstant(module, name.toString()) != null;
+            return ModuleOperations.lookupConstant(null, module, name.toString()) != null;
         }
 
     }
@@ -509,6 +509,13 @@ public RubyModule setConstant(RubyModule module, RubyString name, Object object)
             return module;
         }
 
+        @Specialization
+        public RubyModule setConstant(RubyModule module, RubySymbol name, Object object) {
+            notDesignedForCompilation();
+
+            module.setConstant(this, name.toString(), object);
+            return module;
+        }
     }
 
     @CoreMethod(names = "class_variable_get", minArgs = 1, maxArgs = 1)
@@ -792,13 +799,16 @@ public RubyArray nesting() {
 
             final List<RubyModule> modules = new ArrayList<>();
 
-            RubyModule module = RubyCallStack.getCallingMethod().getDeclaringModule();
+            MethodLike method = RubyCallStack.getCallingMethod();
+            LexicalScope lexicalScope = method == null ? null : method.getSharedMethodInfo().getLexicalScope();
             RubyClass object = getContext().getCoreLibrary().getObjectClass();
 
-            for (RubyModule englobing : module.lexicalAncestors()) {
-                if (englobing == object)
+            while (lexicalScope != null) {
+                RubyModule enclosing = lexicalScope.getLiveModule();
+                if (enclosing == object)
                     break;
-                modules.add(englobing);
+                modules.add(enclosing);
+                lexicalScope = lexicalScope.getParent();
             }
 
             return RubyArray.fromObjects(getContext().getCoreLibrary().getArrayClass(), modules.toArray(new Object[modules.size()]));

diff --git a/core/src/main/java/org/jruby/truffle/nodes/core/SystemNode.java b/core/src/main/java/org/jruby/truffle/nodes/core/SystemNode.java
@@ -40,7 +40,7 @@ public Object execute(VirtualFrame frame) {
 
         final RubyContext context = getContext();
 
-        final RubyHash env = (RubyHash) ModuleOperations.lookupConstant(getContext().getCoreLibrary().getObjectClass(), "ENV").getValue();
+        final RubyHash env = (RubyHash) ModuleOperations.lookupConstant(null, getContext().getCoreLibrary().getObjectClass(), "ENV").getValue();
 
         final List<String> envp = new ArrayList<>();
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/dispatch/CachedBooleanDispatchNode.java b/core/src/main/java/org/jruby/truffle/nodes/dispatch/CachedBooleanDispatchNode.java
@@ -19,6 +19,7 @@
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.nodes.InvalidAssumptionException;
 import com.oracle.truffle.api.utilities.BranchProfile;
+import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.core.*;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
@@ -80,7 +81,7 @@ public CachedBooleanDispatchNode(CachedBooleanDispatchNode prev) {
     public Object dispatch(
             VirtualFrame frame,
             RubyNilClass methodReceiverObject,
-            Object callingSelf,
+            LexicalScope lexicalScope,
             boolean receiverObject,
             Object methodName,
             Object blockObject,
@@ -97,7 +98,7 @@ public Object dispatch(
                 return resetAndDispatch(
                         frame,
                         methodReceiverObject,
-                        callingSelf,
+                        lexicalScope,
                         receiverObject,
                         methodName,
                         CompilerDirectives.unsafeCast(blockObject, RubyProc.class, true, false),
@@ -131,7 +132,7 @@ public Object dispatch(
                 return resetAndDispatch(
                         frame,
                         methodReceiverObject,
-                        callingSelf,
+                        lexicalScope,
                         receiverObject,
                         methodName,
                         CompilerDirectives.unsafeCast(blockObject, RubyProc.class, true, false),
@@ -163,7 +164,7 @@ public Object dispatch(
     public Object dispatch(
             VirtualFrame frame,
             Object methodReceiverObject,
-            Object callingSelf,
+            LexicalScope lexicalScope,
             Object receiverObject,
             Object methodName,
             Object blockObject,
@@ -172,7 +173,7 @@ public Object dispatch(
         return next.executeDispatch(
                 frame,
                 methodReceiverObject,
-                callingSelf,
+                lexicalScope,
                 receiverObject,
                 methodName,
                 blockObject,