[GR-32501] Correctly compute the LexicalScope for Module#module_eval when isDynamicConstantLookup()

eregon · eregon · commit 710a1a2038c9 · 2021-07-15T22:22:11.000Z
PullRequest: truffleruby/2811
diff --git a/spec/truffle/methods_spec.rb b/spec/truffle/methods_spec.rb
@@ -39,7 +39,7 @@
 requires = %w[digest socket]
 requires_code = requires.map { |lib| "require #{lib.inspect}" }.join("\n")
 
-guard -> { !defined?(SlowSpecsTagger) } do
+guard -> { !defined?(SKIP_SLOW_SPECS) } do
   if RUBY_ENGINE == "ruby"
     modules.each do |mod|
       file = File.expand_path("../methods/#{mod}.txt", __FILE__)
diff --git a/spec/truffleruby.mspec b/spec/truffleruby.mspec
@@ -154,6 +154,8 @@ if MSpecScript.child_process?
 end
 
 if i = ARGV.index('slow') and ARGV[i-1] == '--excl-tag' and MSpecScript.child_process?
+  SKIP_SLOW_SPECS = true
+
   require 'mspec'
   require 'timeout'
   require 'objspace'
diff --git a/src/main/java/org/truffleruby/RubyLanguage.java b/src/main/java/org/truffleruby/RubyLanguage.java
@@ -88,6 +88,7 @@
 import org.truffleruby.extra.RubyConcurrentMap;
 import org.truffleruby.extra.ffi.RubyPointer;
 import org.truffleruby.core.string.ImmutableRubyString;
+import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.RubyEvalInteractiveRootNode;
@@ -465,11 +466,12 @@ protected RootCallTarget parse(ParsingRequest request) {
             final ParserContext parserContext = MIME_TYPE_MAIN_SCRIPT.equals(source.getMimeType())
                     ? ParserContext.TOP_LEVEL_FIRST
                     : ParserContext.TOP_LEVEL;
+            final LexicalScope lexicalScope = contextIfSingleContext.map(RubyContext::getRootLexicalScope).orElse(null);
             return RubyLanguage.getCurrentContext().getCodeLoader().parse(
                     rubySource,
                     parserContext,
                     null,
-                    null,
+                    lexicalScope,
                     true,
                     parsingParameters.getCurrentNode());
         }
diff --git a/src/main/java/org/truffleruby/core/CoreLibrary.java b/src/main/java/org/truffleruby/core/CoreLibrary.java
@@ -771,7 +771,8 @@ public void loadRubyCoreLibraryAndPostBoot() {
                         ParserContext.TOP_LEVEL,
                         DeclarationContext.topLevel(context),
                         null,
-                        context.getCoreLibrary().mainObject);
+                        context.getCoreLibrary().mainObject,
+                        context.getRootLexicalScope());
 
                 TranslatorDriver.printParseTranslateExecuteMetric("before-execute", context, source);
                 deferredCall.callWithoutCallNode();
diff --git a/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java b/src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java
@@ -40,6 +40,7 @@
 import org.truffleruby.core.rope.RopeOperations;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.language.ImmutableRubyObject;
+import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyDynamicObject;
@@ -392,12 +393,13 @@ private Object instanceEvalHelper(MaterializedFrame callerFrame, Object receiver
 
             final RubySource source = EvalLoader
                     .createEvalSource(getContext(), stringRope, "instance_eval", fileNameString, line, this);
+            final LexicalScope lexicalScope = RubyArguments.getMethod(callerFrame).getLexicalScope();
 
             final RootCallTarget callTarget = getContext().getCodeLoader().parse(
                     source,
                     ParserContext.EVAL,
                     callerFrame,
-                    null,
+                    lexicalScope,
                     true,
                     this);
 
@@ -411,7 +413,8 @@ private Object instanceEvalHelper(MaterializedFrame callerFrame, Object receiver
                     ParserContext.EVAL,
                     declarationContext,
                     callerFrame,
-                    receiver);
+                    receiver,
+                    lexicalScope);
 
             return deferredCall.call(callNode);
         }
diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java
@@ -95,6 +95,7 @@
 import org.truffleruby.interop.ToJavaStringNode;
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.language.ImmutableRubyObject;
+import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyBaseNode;
@@ -882,12 +883,14 @@ private CodeLoader.DeferredCall doEvalX(RubyContext context, Object self, Rope s
             if (assignsNewUserVariables(descriptor)) {
                 binding.setFrame(frame);
             }
+            final LexicalScope lexicalScope = RubyArguments.getMethod(frame).getLexicalScope();
             return context.getCodeLoader().prepareExecute(
                     callTarget,
                     ParserContext.EVAL,
                     declarationContext,
                     frame,
-                    self);
+                    self,
+                    lexicalScope);
         }
 
         protected RootCallTarget parse(RubyContext context, Rope sourceText, MaterializedFrame parentFrame, Rope file,
@@ -897,9 +900,10 @@ protected RootCallTarget parse(RubyContext context, Rope sourceText, Materialize
             final String sourceFile = RopeOperations.decodeRope(file).intern();
             final RubySource source = EvalLoader
                     .createEvalSource(context, sourceText, "eval", sourceFile, line, this);
+            final LexicalScope lexicalScope = RubyArguments.getMethod(parentFrame).getLexicalScope();
             return context
                     .getCodeLoader()
-                    .parse(source, ParserContext.EVAL, parentFrame, null, ownScopeForAssignments, this);
+                    .parse(source, ParserContext.EVAL, parentFrame, lexicalScope, ownScopeForAssignments, this);
         }
 
         protected RootCallTarget compileSource(RubyContext context, Rope sourceText, MaterializedFrame parentFrame,
diff --git a/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java b/src/main/java/org/truffleruby/core/kernel/TruffleKernelNodes.java
@@ -32,6 +32,7 @@
 import org.truffleruby.core.rope.Rope;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.language.FrameOrVariablesReadingNode;
+import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.ReadOwnFrameAndVariablesNode;
 import org.truffleruby.language.RubyContextNode;
@@ -115,21 +116,24 @@ protected boolean load(Object file, boolean wrap,
             final RootCallTarget callTarget;
             final DeclarationContext declarationContext;
             final Object self;
+            final LexicalScope lexicalScope;
             if (!wrap) {
+                lexicalScope = getContext().getRootLexicalScope();
                 callTarget = getContext().getCodeLoader().parseTopLevelWithCache(sourceRopePair, this);
 
                 declarationContext = DeclarationContext.topLevel(getContext());
                 self = mainObject;
             } else {
                 final RubyModule wrapModule = ModuleNodes
                         .createModule(getContext(), null, coreLibrary().moduleClass, null, null, this);
+                lexicalScope = new LexicalScope(getContext().getRootLexicalScope(), wrapModule);
                 final RubySource rubySource = new RubySource(
                         sourceRopePair.getLeft(),
                         feature,
                         sourceRopePair.getRight());
                 callTarget = getContext()
                         .getCodeLoader()
-                        .parse(rubySource, ParserContext.TOP_LEVEL, null, wrapModule, true, this);
+                        .parse(rubySource, ParserContext.TOP_LEVEL, null, lexicalScope, true, this);
 
                 declarationContext = DeclarationContext.topLevel(wrapModule);
                 self = DispatchNode.getUncached().call(mainObject, "clone");
@@ -141,7 +145,8 @@ protected boolean load(Object file, boolean wrap,
                     ParserContext.TOP_LEVEL,
                     declarationContext,
                     null,
-                    self);
+                    self,
+                    lexicalScope);
 
             deferredCall.call(callNode);
 
diff --git a/src/main/java/org/truffleruby/core/module/ModuleNodes.java b/src/main/java/org/truffleruby/core/module/ModuleNodes.java
@@ -675,17 +675,8 @@ protected Object isAutoload(RubyModule module, String name, boolean inherit) {
     @CoreMethod(names = { "class_eval", "module_eval" }, optional = 3, lowerFixnum = 3, needsBlock = true)
     public abstract static class ClassEvalNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private ToStrNode toStrNode;
         @Child private ReadCallerFrameNode readCallerFrameNode = ReadCallerFrameNode.create();
 
-        protected Object toStr(VirtualFrame frame, Object object) {
-            if (toStrNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                toStrNode = insert(ToStrNode.create());
-            }
-            return toStrNode.execute(object);
-        }
-
         @Specialization(guards = { "libCode.isRubyString(code)" })
         protected Object classEval(
                 VirtualFrame frame, RubyModule module, Object code, NotProvided file, NotProvided line, Nil block,
@@ -720,17 +711,19 @@ protected Object classEval(VirtualFrame frame, RubyModule module, Object code, O
         @Specialization(guards = "wasProvided(code)")
         protected Object classEval(
                 VirtualFrame frame, RubyModule module, Object code, NotProvided file, NotProvided line, Nil block,
-                @Cached IndirectCallNode callNode) {
-            return classEvalSource(frame, module, toStr(frame, code), "(eval)", callNode);
+                @Cached IndirectCallNode callNode,
+                @Cached ToStrNode toStrNode) {
+            return classEvalSource(frame, module, toStrNode.execute(code), "(eval)", callNode);
         }
 
         @Specialization(guards = { "libCode.isRubyString(code)", "wasProvided(file)" })
         protected Object classEval(
                 VirtualFrame frame, RubyModule module, Object code, Object file, NotProvided line, Nil block,
                 @CachedLibrary(limit = "2") RubyStringLibrary stringLibrary,
                 @Cached IndirectCallNode callNode,
-                @CachedLibrary(limit = "2") RubyStringLibrary libCode) {
-            final String javaString = stringLibrary.getJavaString(toStr(frame, file));
+                @CachedLibrary(limit = "2") RubyStringLibrary libCode,
+                @Cached ToStrNode toStrNode) {
+            final String javaString = stringLibrary.getJavaString(toStrNode.execute(file));
             return classEvalSource(frame, module, code, javaString, callNode);
         }
 
@@ -758,12 +751,15 @@ private CodeLoader.DeferredCall classEvalSourceInternal(RubyModule module, Objec
                     file,
                     line,
                     this);
+            final LexicalScope lexicalScope = new LexicalScope(
+                    RubyArguments.getMethod(callerFrame).getLexicalScope(),
+                    module);
 
             final RootCallTarget callTarget = getContext().getCodeLoader().parse(
                     source,
                     ParserContext.MODULE,
                     callerFrame,
-                    null,
+                    lexicalScope,
                     true,
                     this);
 
@@ -775,7 +771,8 @@ private CodeLoader.DeferredCall classEvalSourceInternal(RubyModule module, Objec
                             new FixedDefaultDefinee(module),
                             DeclarationContext.NO_REFINEMENTS),
                     callerFrame,
-                    module);
+                    module,
+                    lexicalScope);
         }
 
         @Specialization
diff --git a/src/main/java/org/truffleruby/debug/DebugHelpers.java b/src/main/java/org/truffleruby/debug/DebugHelpers.java
@@ -12,6 +12,7 @@
 import com.oracle.truffle.api.RootCallTarget;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
+import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -43,6 +44,7 @@ public static Object eval(RubyContext context, String code, Object... arguments)
 
         final DeclarationContext declarationContext = RubyArguments.getDeclarationContext(currentFrame);
 
+        final LexicalScope lexicalScope = RubyArguments.getMethod(currentFrame).getLexicalScope();
         final Object[] packedArguments = RubyArguments.pack(
                 null,
                 null,
@@ -74,14 +76,15 @@ public static Object eval(RubyContext context, String code, Object... arguments)
 
         final RootCallTarget callTarget = context
                 .getCodeLoader()
-                .parse(new RubySource(source, "debug-eval"), ParserContext.INLINE, evalFrame, null, true, null);
+                .parse(new RubySource(source, "debug-eval"), ParserContext.INLINE, evalFrame, lexicalScope, true, null);
 
         final CodeLoader.DeferredCall deferredCall = context.getCodeLoader().prepareExecute(
                 callTarget,
                 ParserContext.INLINE,
                 declarationContext,
                 evalFrame,
-                RubyArguments.getSelf(evalFrame));
+                RubyArguments.getSelf(evalFrame),
+                lexicalScope);
 
         return deferredCall.callWithoutCallNode();
     }
diff --git a/src/main/java/org/truffleruby/language/RubyInlineParsingRequestNode.java b/src/main/java/org/truffleruby/language/RubyInlineParsingRequestNode.java
@@ -51,7 +51,7 @@ public RubyInlineParsingRequestNode(
                 ParserContext.INLINE,
                 null,
                 currentFrame,
-                null,
+                RubyArguments.getMethod(currentFrame).getLexicalScope(),
                 false,
                 null);
 
diff --git a/src/main/java/org/truffleruby/language/RubyParsingRequestNode.java b/src/main/java/org/truffleruby/language/RubyParsingRequestNode.java
@@ -49,7 +49,7 @@ public RubyParsingRequestNode(RubyLanguage language, RubyContext context, Source
                 ParserContext.TOP_LEVEL,
                 argumentNames,
                 null,
-                null,
+                context.getRootLexicalScope(), // This is a top-level parse, so the lexical scope is always the root one
                 true,
                 null);
 
diff --git a/src/main/java/org/truffleruby/language/TruffleBootNodes.java b/src/main/java/org/truffleruby/language/TruffleBootNodes.java
@@ -147,7 +147,8 @@ protected int main(Object kind, Object toExecute,
                             ParserContext.TOP_LEVEL_FIRST,
                             DeclarationContext.topLevel(getContext()),
                             null,
-                            coreLibrary().mainObject);
+                            coreLibrary().mainObject,
+                            getContext().getRootLexicalScope());
 
                     deferredCall.call(callNode);
                 }
@@ -294,7 +295,7 @@ protected Object innerCheckSyntax(RubySource source) {
             RubyContext context = getContext();
             RootCallTarget callTarget = context
                     .getCodeLoader()
-                    .parse(source, ParserContext.TOP_LEVEL, null, null, true, null);
+                    .parse(source, ParserContext.TOP_LEVEL, null, context.getRootLexicalScope(), true, null);
             RubyRootNode rubyRootNode = RubyRootNode.of(callTarget);
             EmitWarningsNode emitWarningsNode = NodeUtil.findFirstNodeInstance(rubyRootNode, EmitWarningsNode.class);
             if (emitWarningsNode != null) {
diff --git a/src/main/java/org/truffleruby/language/loader/CodeLoader.java b/src/main/java/org/truffleruby/language/loader/CodeLoader.java
@@ -61,37 +61,33 @@ public RootCallTarget parseTopLevelWithCache(Pair<Source, Rope> sourceRopePair,
     public RootCallTarget parse(RubySource source,
             ParserContext parserContext,
             MaterializedFrame parentFrame,
-            RubyModule wrap,
+            LexicalScope lexicalScope,
             boolean ownScopeForAssignments,
             Node currentNode) {
         final TranslatorDriver translator = new TranslatorDriver(context, source);
-        return translator.parse(source, parserContext, null, parentFrame, wrap, ownScopeForAssignments, currentNode);
+        return translator
+                .parse(source, parserContext, null, parentFrame, lexicalScope, ownScopeForAssignments, currentNode);
     }
 
     @TruffleBoundary
     public DeferredCall prepareExecute(RootCallTarget callTarget,
             ParserContext parserContext,
             DeclarationContext declarationContext,
             MaterializedFrame parentFrame,
-            Object self) {
+            Object self,
+            LexicalScope lexicalScope) {
         final RubyRootNode rootNode = RubyRootNode.of(callTarget);
+        final InternalMethod parentMethod = parentFrame == null ? null : RubyArguments.getMethod(parentFrame);
 
         final RubyModule declaringModule;
         if (parserContext == ParserContext.EVAL && parentFrame != null) {
-            declaringModule = RubyArguments.getMethod(parentFrame).getDeclaringModule();
+            declaringModule = parentMethod.getDeclaringModule();
         } else if (parserContext == ParserContext.MODULE) {
             declaringModule = (RubyModule) self;
         } else {
             declaringModule = context.getCoreLibrary().objectClass;
         }
 
-        final LexicalScope lexicalScope;
-        if (parentFrame != null) {
-            lexicalScope = RubyArguments.getMethod(parentFrame).getLexicalScope();
-        } else {
-            lexicalScope = context.getRootLexicalScope();
-        }
-
         final InternalMethod method = new InternalMethod(
                 context,
                 rootNode.getSharedMethodInfo(),
diff --git a/src/main/java/org/truffleruby/language/loader/RequireNode.java b/src/main/java/org/truffleruby/language/loader/RequireNode.java
@@ -225,7 +225,8 @@ private boolean parseAndCall(String feature, String expandedPath) {
                     ParserContext.TOP_LEVEL,
                     DeclarationContext.topLevel(getContext()),
                     null,
-                    coreLibrary().mainObject);
+                    coreLibrary().mainObject,
+                    getContext().getRootLexicalScope());
 
             requireMetric("before-execute-" + feature);
             try {
diff --git a/src/main/java/org/truffleruby/parser/TranslatorDriver.java b/src/main/java/org/truffleruby/parser/TranslatorDriver.java
diff --git a/src/test/java/org/truffleruby/RubyTest.java b/src/test/java/org/truffleruby/RubyTest.java
