defined? must swallow all exceptions

This further lets us simplify the logic, as it's no longer requirement to wrap
exceptions from autoloaded modules.

Author: Nicolas Laurent

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

@@ -44,25 +44,12 @@ public Object execute(VirtualFrame frame) {
             return writeConstant.execute(frame);
         }
 
-        // Conceptually, we want to rewrite `<x>::Foo ||= <y>` to `(<x>.isDefined && <x>) || (<x>::Foo = <y>)`
+        // Conceptually, we want to rewrite `<x>::Foo ||= <y>` to `(defined?(<x>) && <x>) || (<x>::Foo = <y>)`
         // BUT, we want the side-effects of <x> (the module part) to be only triggered once.
-        //
-        // To do so, we start by evaluating the module part.
-        // Possible issues:
-        //     - An exception is raised (not during module autoloading)
-        //         -> let it go through
-        //     - An exception is raised (during module autoloading)
-        //         -> capture the exception, evaluate the right-hand, then throw the exception.
-        //       Normally, this would be swallowed by `isDefined`, but because it causes the left of `||` to be false,
-        //       it will be thrown again when evaluating the left-hand side of the assignment.
-        //       We do need to evaluate the right-hand side because of Ruby semantics.
-        final RubyModule module;
-        try {
-            module = readConstant.evaluateModuleWrappingAutoloadExceptions(frame);
-        } catch (AutoloadException e) {
-            writeConstant.evaluateValue(frame);
-            throw e.raiseException;
-        }
+        // We do let any exception raised bubble through. Normally they would be swallowed by `defined?`, but
+        // MRI raises them anyway, *before* evaluation the right-hand side (which is a different behaviour from
+        // regular constant assignment, which evaluates the right-hand side first).
+        final RubyModule module = readConstant.evaluateModule(frame);
 
         // Next we check if the constant itself is defined, and if it is, we get its value.
         final RubyConstant constant = readConstant.getConstantIfDefined(module);

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

@@ -75,31 +75,9 @@ private LookupConstantNode getLookupConstantNode() {
         return lookupConstantNode;
     }
 
-    /** Reads the constant value, wrapping any exception occuring during module autoloading in an
-     * {@link AutoloadException}. */
-    private Object readConstantWrappingAutoloadExceptions(VirtualFrame frame) {
-        final Object moduleObject = moduleNode instanceof ReadConstantNode
-                ? ((ReadConstantNode) moduleNode).readConstantWrappingAutoloadExceptions(frame)
-                : moduleNode.execute(frame);
-        final RubyModule module = checkModule(moduleObject);
-        final RubyConstant constant = getLookupConstantNode().lookupConstant(LexicalScope.IGNORE, module, name, true);
-        try {
-            return getConstant(module, constant);
-        } catch (RaiseException e) {
-            if (constant.isAutoload()) {
-                throw new AutoloadException(e);
-            }
-            throw e;
-        }
-    }
-
-    /** Returns the evaluated module part, wrapping any exception occuring during module autoloading in an
-     * {@link AutoloadException}. */
-    public RubyModule evaluateModuleWrappingAutoloadExceptions(VirtualFrame frame) {
-        final Object moduleObject = moduleNode instanceof ReadConstantNode
-                ? ((ReadConstantNode) moduleNode).readConstantWrappingAutoloadExceptions(frame)
-                : moduleNode.execute(frame);
-        return checkModule(moduleObject);
+    /** Evaluate the module part of the constant read. */
+    public RubyModule evaluateModule(VirtualFrame frame) {
+        return checkModule(moduleNode.execute(frame));
     }
 
     /** Whether the module part of this constant read is undefined, without attempting to evaluate it. */
@@ -109,26 +87,16 @@ public boolean isModuleTriviallyUndefined(VirtualFrame frame, RubyLanguage langu
 
     @Override
     public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) {
-        final RubyConstant constant = getConstantIfDefined(frame, language, context);
-        return constant == null ? nil : coreStrings().CONSTANT.createInstance(getContext());
-    }
-
-    /** Returns the constant, it it is defined. Otherwise returns {@code null}. */
-    private RubyConstant getConstantIfDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) {
         if (isModuleTriviallyUndefined(frame, language, context)) {
-            return null;
+            return nil;
         }
-
-        final RubyModule module;
         try {
-            module = evaluateModuleWrappingAutoloadExceptions(frame);
-        } catch (AutoloadException e) {
-            // If autoloading a module raised an exception,
-            // MRI dictates that we should swallow the exception and return `nil`.
-            return null;
+            final RubyModule module = checkModule(moduleNode.execute(frame));
+            final RubyConstant constant = getConstantIfDefined(module);
+            return constant == null ? nil : coreStrings().CONSTANT.createInstance(getContext());
+        } catch (RaiseException e) {
+            return nil; // MRI swallows all exceptions in defined? (MRI Bug#5786)
         }
-
-        return getConstantIfDefined(module);
     }
 
     /** Given the module, returns the constant, it it is defined. Otherwise returns {@code null}. */

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

@@ -51,10 +51,6 @@ public Object execute(VirtualFrame frame, RubyModule module) {
         return value;
     }
 
-    public void evaluateValue(VirtualFrame frame) {
-        valueNode.execute(frame);
-    }
-
     @Override
     public void assign(VirtualFrame frame, Object value) {
         final Object moduleObject = moduleNode.execute(frame);