[GR-18163] Set $! global variable when an at_exit hook raises an exception

PullRequest: truffleruby/4255

Author: andrykonchin

CHANGELOG.md

@@ -20,6 +20,7 @@ Compatibility:
 * Add `Regexp.linear_time?` method (#3039, @andrykonchin).
 * Allow null encoding pointer in `rb_enc_interned_str_cstr` (@thomasmarshall).
 * Allow anonymous memberless Struct (@simonlevasseur).
+* Set `$!` when a `Kernel#at_exit` hook raises an exception (#3535, @andrykonchin).
 
 Performance:
 * Fix inline caching for Regexp creation from Strings (#3492, @andrykonchin, @eregon).

spec/ruby/shared/kernel/at_exit.rb

@@ -30,6 +30,12 @@
     result.lines.should.include?("The exception matches: true (message=foo)\n")
   end
 
+  it "gives access to an exception raised in a previous handler" do
+    code = "#{@method} { print '$!.message = ' + $!.message }; #{@method} { raise 'foo' }"
+    result = ruby_exe(code, args: "2>&1", exit_status: 1)
+    result.lines.should.include?("$!.message = foo")
+  end
+
   it "both exceptions in a handler and in the main script are printed" do
     code = "#{@method} { raise 'at_exit_error' }; raise 'main_script_error'"
     result = ruby_exe(code, args: "2>&1", exit_status: 1)

spec/tags/core/kernel/at_exit_tags.txt

@@ -7,3 +7,4 @@ slow:Kernel.at_exit decides the exit status if both at_exit and the main script
 slow:Kernel.at_exit runs all handlers even if some raise exceptions
 slow:Kernel.at_exit runs handlers even if the main script fails to parse
 slow:Kernel.at_exit calls the nested handler right after the outer one if a handler is nested into another handler
+slow:Kernel.at_exit gives access to an exception raised in a previous handler

spec/tags/language/END_tags.txt

@@ -11,3 +11,4 @@ slow:The END keyword runs only once for multiple calls
 slow:The END keyword warns when END is used in a method
 slow:The END keyword END blocks and at_exit callbacks are mixed runs them all in reverse order of registration
 slow:The END keyword is affected by the toplevel assignment
+slow:The END keyword gives access to an exception raised in a previous handler

src/main/java/org/truffleruby/RubyContext.java

@@ -118,7 +118,7 @@ public final class RubyContext {
     private final MarkingService markingService;
     private final ObjectSpaceManager objectSpaceManager = new ObjectSpaceManager();
     private final SharedObjects sharedObjects = new SharedObjects(this);
-    private final AtExitManager atExitManager = new AtExitManager(this);
+    private final AtExitManager atExitManager;
     private final CallStackManager callStack;
     private final CoreExceptions coreExceptions;
     private final EncodingManager encodingManager;
@@ -202,6 +202,7 @@ public RubyContext(RubyLanguage language, TruffleLanguage.Env env) {
         finalizationService = new FinalizationService(referenceProcessor);
         markingService = new MarkingService();
         dataObjectFinalizationService = new DataObjectFinalizationService(language, referenceProcessor);
+        atExitManager = new AtExitManager(this, language);
 
         // We need to construct this at runtime
         random = createRandomInstance();

src/main/java/org/truffleruby/core/kernel/AtExitManager.java

@@ -16,6 +16,8 @@
 
 import com.oracle.truffle.api.exception.AbstractTruffleException;
 import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
+import org.truffleruby.core.exception.ExceptionOperations;
 import org.truffleruby.core.exception.RubyException;
 import org.truffleruby.core.exception.RubySystemExit;
 import org.truffleruby.core.proc.ProcOperations;
@@ -31,12 +33,14 @@
 public final class AtExitManager {
 
     private final RubyContext context;
+    private final RubyLanguage language;
 
     private final Deque<RubyProc> atExitHooks = new ConcurrentLinkedDeque<>();
     private final Deque<RubyProc> systemExitHooks = new ConcurrentLinkedDeque<>();
 
-    public AtExitManager(RubyContext context) {
+    public AtExitManager(RubyContext context, RubyLanguage language) {
         this.context = context;
+        this.language = language;
     }
 
     public void add(RubyProc block, boolean always) {
@@ -74,7 +78,7 @@ private AbstractTruffleException runExitHooks(Deque<RubyProc> stack) {
             try {
                 ProcOperations.rootCall(block, NoKeywordArgumentsDescriptor.INSTANCE, RubyBaseNode.EMPTY_ARGUMENTS);
             } catch (AbstractTruffleException e) {
-                handleAtExitException(context, e);
+                handleAtExitException(context, language, e);
                 lastException = e;
             }
         }
@@ -99,7 +103,12 @@ public static boolean isSilentException(RubyContext context, AbstractTruffleExce
                 rubyException.getLogicalClass() == context.getCoreLibrary().signalExceptionClass;
     }
 
-    private static void handleAtExitException(RubyContext context, AbstractTruffleException exception) {
+    private static void handleAtExitException(RubyContext context, RubyLanguage language,
+            AbstractTruffleException exception) {
+        // Set $! for the next at_exit handlers
+        language.getCurrentThread().threadLocalGlobals.setLastException(ExceptionOperations
+                .getExceptionObject(exception));
+
         if (!isSilentException(context, exception)) {
             context.getDefaultBacktraceFormatter().printRubyExceptionOnEnvStderr("", exception);
         }