reformat

Author: Nicolas Laurent

src/main/java/org/truffleruby/core/exception/ExceptionNodes.java

@@ -152,7 +152,6 @@ protected Object backtrace(
             if (hasCustomBacktraceProfile.profile(customBacktrace != null)) {
                 return customBacktrace;
             } else if (hasBacktraceProfile.profile(Layouts.EXCEPTION.getBacktrace(exception) != null)) {
-                Backtrace backtrace = Layouts.EXCEPTION.getBacktrace(exception);
                 DynamicObject backtraceStringArray = Layouts.EXCEPTION.getBacktraceStringArray(exception);
                 if (backtraceStringArray == null) {
                     backtraceStringArray = getContext().getUserBacktraceFormatter().formatBacktraceAsRubyStringArray(
@@ -182,7 +181,7 @@ public abstract static class BacktraceLocationsNode extends CoreMethodArrayArgum
 
         @Specialization
         protected Object backtraceLocations(DynamicObject exception,
-                 @Cached("createBinaryProfile()") ConditionProfile hasBacktraceProfile,
+                @Cached("createBinaryProfile()") ConditionProfile hasBacktraceProfile,
                 @Cached("createBinaryProfile()") ConditionProfile hasLocationsProfile) {
             if (hasBacktraceProfile.profile(Layouts.EXCEPTION.getBacktrace(exception) != null)) {
                 DynamicObject backtraceLocations = Layouts.EXCEPTION.getBacktraceLocations(exception);

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

@@ -321,8 +321,8 @@ private DynamicObject innerCallerLocations(int omit, int length) {
 
             // We can't set an effective limit when dealing with negative range endings.
             final int limit = length < 0
-                ? GetBacktraceException.UNLIMITED
-                : omitted + length;
+                    ? GetBacktraceException.UNLIMITED
+                    : omitted + length;
 
             // Fill in the stack trace.
             backtrace.getActivations(new GetBacktraceException(this, limit));

src/main/java/org/truffleruby/core/thread/ThreadNodes.java

@@ -157,8 +157,8 @@ private DynamicObject backtraceLocationsInternal(DynamicObject rubyThread, int o
 
             // We can't set an effective limit when dealing with negative range endings.
             final int stackTraceElementsLimit = length < 0
-                ? GetBacktraceException.UNLIMITED
-                : omit + length;
+                    ? GetBacktraceException.UNLIMITED
+                    : omit + length;
 
             final SafepointAction safepointAction = (thread1, currentNode) -> {
                 final Backtrace backtrace = getContext().getCallStack().getBacktrace(this, omit);
@@ -167,8 +167,9 @@ private DynamicObject backtraceLocationsInternal(DynamicObject rubyThread, int o
                 backtrace.getActivations(new GetBacktraceException(this, stackTraceElementsLimit));
             };
 
-            getContext().getSafepointManager()
-                .pauseRubyThreadAndExecute(rubyThread, this, safepointAction);
+            getContext()
+                    .getSafepointManager()
+                    .pauseRubyThreadAndExecute(rubyThread, this, safepointAction);
 
             // If the thread is dead or aborting the SafepointAction will not run.
             if (backtraceMemo.get() == null) {

src/main/java/org/truffleruby/language/backtrace/Backtrace.java

@@ -185,7 +185,7 @@ public DynamicObject getBacktraceLocations(int length) {
         final int activationsLength = getActivations().length;
 
         // TODO(norswap, 24 Dec 2019)
-        //   This is an ugly stopgap solution — this doesn't seem solvable without refactoring #getActivations.
+        //   This is an ugly stopgap solution - this doesn't seem solvable without refactoring #getActivations.
         //   The issue is that omitting more locations than are available should return nil, while
         //   omitting exactly the number of available locations should return an empty array.
         //   This isn't even entirely correct: if we should ignore some frames from the stack trace,
@@ -203,14 +203,16 @@ public DynamicObject getBacktraceLocations(int length) {
         //  always respect TruffleException#getStackTraceElementLimit(), so we need to use Math#min.
         //  Haven't yet investigated why.
         final int locationsLength = length < 0
-            ? activationsLength + 1 + length
-            : Math.min(activationsLength, length);
+                ? activationsLength + 1 + length
+                : Math.min(activationsLength, length);
 
         final Object[] locations = new Object[locationsLength];
         final DynamicObjectFactory factory = context.getCoreLibrary().threadBacktraceLocationFactory;
         for (int i = 0; i < locationsLength; i++) {
             locations[i] = Layouts.THREAD_BACKTRACE_LOCATION.createThreadBacktraceLocation(
-                factory, this, i);
+                    factory,
+                    this,
+                    i);
         }
         return ArrayHelpers.createArray(context, locations, locations.length);
     }