Remove the constant if an autoload fails

* Previously it would be undefined but this behavior was changed in 3.1:
  https://bugs.ruby-lang.org/issues/15790

Author: eregon

src/main/java/org/truffleruby/core/module/ConstantLookupResult.java

@@ -29,7 +29,7 @@ public ConstantLookupResult(RubyConstant constant, Assumption... assumptions) {
     }
 
     public boolean isFound() {
-        return constant != null && !constant.isUndefined();
+        return constant != null;
     }
 
     public boolean isDeprecated() {

src/main/java/org/truffleruby/core/module/ModuleFields.java

@@ -716,15 +716,11 @@ public void deprecateConstant(RubyContext context, Node currentNode, String name
     }
 
     @TruffleBoundary
-    public boolean undefineConstantIfStillAutoload(RubyConstant autoloadConstant) {
+    public boolean removeConstantIfStillAutoload(RubyConstant autoloadConstant) {
         final ConstantEntry constantEntry = constants.get(autoloadConstant.getName());
         final boolean replace = constantEntry != null && constantEntry.getConstant() == autoloadConstant;
-        if (replace &&
-                constants.replace(
-                        autoloadConstant.getName(),
-                        constantEntry,
-                        new ConstantEntry(autoloadConstant.undefined()))) {
-            constantEntry.invalidate("undefine if still autoload", rubyModule, autoloadConstant.getName());
+        if (replace && constants.remove(autoloadConstant.getName(), constantEntry)) {
+            constantEntry.invalidate("remove if still autoload", rubyModule, autoloadConstant.getName());
             return true;
         } else {
             return false;

src/main/java/org/truffleruby/core/module/ModuleNodes.java

@@ -2196,7 +2196,7 @@ protected Object removeConstant(RubyModule module, String name) {
                         getContext(),
                         coreExceptions().nameErrorConstantNotDefined(module, name, this));
             } else {
-                if (oldConstant.isAutoload() || oldConstant.isUndefined()) {
+                if (oldConstant.isAutoload()) {
                     return nil;
                 } else {
                     return oldConstant.getValue();

src/main/java/org/truffleruby/core/module/ModuleOperations.java

@@ -114,9 +114,8 @@ public static Iterable<Entry<String, ConstantEntry>> getAllConstants(RubyModule
         return constants.entrySet();
     }
 
-    /** NOTE: This method returns false for an undefined RubyConstant */
     public static boolean isConstantDefined(RubyConstant constant) {
-        return constant != null && !constant.isUndefined() &&
+        return constant != null &&
                 !(constant.isAutoload() && constant.getAutoloadConstant().isAutoloadingThreadAndUnset());
     }
 

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

@@ -31,9 +31,6 @@ public class RubyConstant implements ObjectGraphNode {
     private final boolean isDeprecated;
 
     private final AutoloadConstant autoloadConstant;
-    /** A autoload constant can become "undefined" after the autoload loads the file but the constant is not defined by
-     * the file */
-    private final boolean undefined;
 
     private final SourceSection sourceSection;
 
@@ -45,41 +42,18 @@ public RubyConstant(
             AutoloadConstant autoloadConstant,
             boolean isDeprecated,
             SourceSection sourceSection) {
-        this(
-                declaringModule,
-                name,
-                value,
-                isPrivate,
-                autoloadConstant,
-                false,
-                isDeprecated,
-                sourceSection);
-    }
-
-    private RubyConstant(
-            RubyModule declaringModule,
-            String name,
-            Object value,
-            boolean isPrivate,
-            AutoloadConstant autoloadConstant,
-            boolean undefined,
-            boolean isDeprecated,
-            SourceSection sourceSection) {
-        assert !undefined || autoloadConstant == null : "undefined and autoload are exclusive";
-
         this.declaringModule = declaringModule;
         this.name = name;
         this.value = value;
         this.isPrivate = isPrivate;
         this.isDeprecated = isDeprecated;
         this.autoloadConstant = autoloadConstant;
-        this.undefined = undefined;
         this.sourceSection = sourceSection;
     }
 
     public RubyConstant copy(RubyModule declaringModule) {
         assert !isAutoload();
-        return new RubyConstant(declaringModule, name, value, isPrivate, null, undefined, isDeprecated, sourceSection);
+        return new RubyConstant(declaringModule, name, value, isPrivate, null, isDeprecated, sourceSection);
     }
 
     public RubyModule getDeclaringModule() {
@@ -91,7 +65,7 @@ public String getName() {
     }
 
     public boolean hasValue() {
-        return !isAutoload() && !undefined;
+        return !isAutoload();
     }
 
     public Object getValue() {
@@ -121,7 +95,6 @@ public RubyConstant withPrivate(boolean isPrivate) {
                     value,
                     isPrivate,
                     autoloadConstant,
-                    undefined,
                     isDeprecated,
                     sourceSection);
         }
@@ -137,17 +110,11 @@ public RubyConstant withDeprecated() {
                     value,
                     isPrivate,
                     autoloadConstant,
-                    undefined,
                     true,
                     sourceSection);
         }
     }
 
-    public RubyConstant undefined() {
-        assert isAutoload();
-        return new RubyConstant(declaringModule, name, null, isPrivate, null, true, isDeprecated, sourceSection);
-    }
-
     @TruffleBoundary
     public boolean isVisibleTo(RubyContext context, LexicalScope lexicalScope, RubyModule module) {
         assert lexicalScope == null || lexicalScope.getLiveModule() == module;
@@ -183,10 +150,6 @@ public boolean isVisibleTo(RubyContext context, LexicalScope lexicalScope, RubyM
         return false;
     }
 
-    public boolean isUndefined() {
-        return undefined;
-    }
-
     public boolean isAutoload() {
         return autoloadConstant != null;
     }

src/main/java/org/truffleruby/language/constants/GetConstantNode.java

@@ -163,20 +163,18 @@ public static void autoloadConstantStop(RubyConstant autoloadConstant) {
 
     /** Subset of {@link #autoloadResolveConstant} which does not try to resolve the constant. */
     @TruffleBoundary
-    public static boolean autoloadUndefineConstantIfStillAutoload(RubyConstant autoloadConstant) {
+    public static boolean autoloadRemoveConstantIfStillAutoload(RubyConstant autoloadConstant) {
         final RubyModule autoloadConstantModule = autoloadConstant.getDeclaringModule();
         final ModuleFields fields = autoloadConstantModule.fields;
-        return fields.undefineConstantIfStillAutoload(autoloadConstant);
+        return fields.removeConstantIfStillAutoload(autoloadConstant);
     }
 
     @TruffleBoundary
-    public static void logAutoloadResult(RubyContext context, RubyConstant constant, boolean undefined) {
+    public static void logAutoloadResult(RubyContext context, RubyConstant constant, boolean removed) {
         if (context.getOptions().LOG_AUTOLOAD) {
             final SourceSection section = context.getCallStack().getTopMostUserSourceSection();
             final String message = context.fileLine(section) + ": " + constant + " " +
-                    (undefined
-                            ? "was marked as undefined as it was not assigned in "
-                            : "was successfully autoloaded from ") +
+                    (removed ? "was removed as it was not assigned in " : "was successfully autoloaded from ") +
                     constant.getAutoloadConstant().getAutoloadPath();
             RubyLanguage.LOGGER.info(message);
         }
@@ -197,19 +195,19 @@ public Object autoloadResolveConstant(LexicalScope lexicalScope, RubyModule modu
             // all is good, just return that constant
             logAutoloadResult(getContext(), autoloadConstant, false);
         } else {
-            // If the autoload constant was not set in the ancestors, undefine the constant
-            boolean undefined = fields.undefineConstantIfStillAutoload(autoloadConstant);
-            logAutoloadResult(getContext(), autoloadConstant, undefined);
+            // If the autoload constant was not set in the ancestors, remove the constant
+            boolean removed = fields.removeConstantIfStillAutoload(autoloadConstant);
+            logAutoloadResult(getContext(), autoloadConstant, removed);
 
-            // redo lookup, to consider the undefined constant
+            // redo lookup, to consider the removed constant
             resolvedConstant = lookupConstantNode.lookupConstant(lexicalScope, module, name, true);
         }
 
         return executeGetConstant(lexicalScope, module, name, resolvedConstant, lookupConstantNode, callConstMissing);
     }
 
     @Specialization(
-            guards = { "isNullOrUndefined(constant)", "guardName(node, name, cachedName, sameNameProfile)" },
+            guards = { "constant == null", "guardName(node, name, cachedName, sameNameProfile)" },
             limit = "getCacheLimit()")
     protected static Object missingConstantCached(
             LexicalScope lexicalScope,
@@ -226,7 +224,7 @@ protected static Object missingConstantCached(
         return doMissingConstant(module, name, symbolName, callConstMissing, constMissingNode.get(node));
     }
 
-    @Specialization(guards = "isNullOrUndefined(constant)")
+    @Specialization(guards = "constant == null")
     protected Object missingConstantUncached(
             LexicalScope lexicalScope,
             RubyModule module,
@@ -248,10 +246,6 @@ private static Object doMissingConstant(RubyModule module, String name, RubySymb
         }
     }
 
-    protected boolean isNullOrUndefined(Object constant) {
-        return constant == null || ((RubyConstant) constant).isUndefined();
-    }
-
     @SuppressFBWarnings("ES")
     protected boolean guardName(Node node, String name, String cachedName, InlinedConditionProfile sameNameProfile) {
         // This is likely as for literal constant lookup the name does not change and Symbols

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

@@ -133,8 +133,8 @@ private boolean requireConsideringAutoload(String feature, String expandedPath,
                         constant.getAutoloadConstant().publish(getContext(), constant);
                     }
 
-                    final boolean undefined = GetConstantNode.autoloadUndefineConstantIfStillAutoload(constant);
-                    GetConstantNode.logAutoloadResult(getContext(), constant, undefined);
+                    final boolean removed = GetConstantNode.autoloadRemoveConstantIfStillAutoload(constant);
+                    GetConstantNode.logAutoloadResult(getContext(), constant, removed);
                     GetConstantNode.autoloadConstantStop(constant);
                     featureLoader.removeAutoload(constant);
                 }