Fix reassignment in static LexicalScope when loading the same file multiple times

* Fixes #2408

Author: eregon

CHANGELOG.md

@@ -12,6 +12,7 @@ Bug fixes:
 * Fix `Dir.mkdir` error handling for `Pathname` paths (#2397).
 * `BasicSocket#*_nonblock(exception: false)` now only return `:wait_readable/:wait_writable` for `EAGAIN`/`EWOULDBLOCK` like MRI (#2400).
 * Fix issue with `strspn` used in the `date` C extension compiled as a macro on older glibc and then missing the `__strspn_c1` symbol on newer glibc (#2406).
+* Fix constant lookup when loading the same file multiple times (#2408).
 
 Compatibility:
 

src/main/java/org/truffleruby/language/LexicalScope.java

@@ -9,6 +9,7 @@
  */
 package org.truffleruby.language;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import org.truffleruby.core.module.RubyModule;
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
@@ -44,7 +45,20 @@ public RubyModule getLiveModule() {
     }
 
     public void unsafeSetLiveModule(RubyModule liveModule) {
-        this.liveModule = liveModule;
+        final RubyModule previous = this.liveModule;
+        if (previous == null) {
+            this.liveModule = liveModule;
+        } else if (previous == liveModule) {
+            // Can be the same module for code like 2.times { module M } (at the toplevel)
+        } else {
+            throw CompilerDirectives.shouldNotReachHere(
+                    "Overriding module for static LexicalScope, old=" + moduleToDebugString(previous) +
+                            ", new=" + moduleToDebugString(liveModule));
+        }
+    }
+
+    private static String moduleToDebugString(RubyModule module) {
+        return module + "@" + Integer.toHexString(module.hashCode());
     }
 
     @Override

src/main/java/org/truffleruby/language/loader/CodeLoader.java

@@ -34,11 +34,16 @@
 import com.oracle.truffle.api.nodes.IndirectCallNode;
 import com.oracle.truffle.api.nodes.Node;
 
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
 public class CodeLoader {
 
     private final RubyLanguage language;
     private final RubyContext context;
 
+    private final Set<String> alreadyLoadedInContext = ConcurrentHashMap.newKeySet();
+
     public CodeLoader(RubyLanguage language, RubyContext context) {
         this.language = language;
         this.context = context;
@@ -49,6 +54,16 @@ public RootCallTarget parseTopLevelWithCache(Pair<Source, Rope> sourceRopePair,
         final Source source = sourceRopePair.getLeft();
         final Rope rope = sourceRopePair.getRight();
 
+        final String path = RubyLanguage.getPath(source);
+        if (language.singleContext && !alreadyLoadedInContext.add(language.getPathRelativeToHome(path))) {
+            /* Duplicate load of the same file in the same context, we cannot use the cache because it would re-assign
+             * the live modules of static LexicalScopes and we cannot/do not want to invalidate static LexicalScopes, so
+             * there the static lexical scope and its module are constants and need no checks in single context (e.g.,
+             * in LookupConstantWithLexicalScopeNode). */
+            final RubySource rubySource = new RubySource(source, path, rope);
+            return parse(rubySource, ParserContext.TOP_LEVEL, null, context.getRootLexicalScope(), true, currentNode);
+        }
+
         language.parsingRequestParams.set(new ParsingParameters(currentNode, rope, source));
         try {
             return (RootCallTarget) context.getEnv().parseInternal(source);