Fix linter warnings

Author: bryce-anderson

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/AbstractCompletableAndSingleConcatenated.java

@@ -26,7 +26,8 @@ abstract class AbstractCompletableAndSingleConcatenated<T> extends AbstractNoHan
     @Override
     protected void handleSubscribe(final Subscriber<? super T> subscriber,
                                    final CapturedContext capturedContext, final AsyncContextProvider contextProvider) {
-        final Subscriber<? super T> wrappedSubscriber = contextProvider.wrapSingleSubscriber(subscriber, capturedContext);
+        final Subscriber<? super T> wrappedSubscriber =
+                contextProvider.wrapSingleSubscriber(subscriber, capturedContext);
         delegateSubscribeToOriginal(wrappedSubscriber, capturedContext, contextProvider);
     }
 

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/CapturedContext.java

@@ -25,7 +25,7 @@ interface CapturedContext {
 
     /**
      * The {@link ContextMap} that was captured as part of the context.
-     * @return
+     * @return {@link ContextMap} that was captured as part of the context.
      */
     ContextMap captured();
 

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/CompletableConcatWithCompletables.java

@@ -39,7 +39,8 @@ final class CompletableConcatWithCompletables extends AbstractNoHandleSubscribeC
     protected void handleSubscribe(Subscriber subscriber, CapturedContext capturedContext,
                                    AsyncContextProvider contextProvider) {
         Subscriber wrappedSubscriber = contextProvider.wrapCompletableSubscriber(subscriber, capturedContext);
-        original.delegateSubscribe(new ConcatWithSubscriber(wrappedSubscriber, nexts), capturedContext, contextProvider);
+        original.delegateSubscribe(
+                new ConcatWithSubscriber(wrappedSubscriber, nexts), capturedContext, contextProvider);
     }
 
     private static final class ConcatWithSubscriber implements Subscriber {

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/CompletableConcatWithSingle.java

@@ -35,8 +35,10 @@ final class CompletableConcatWithSingle<T> extends AbstractCompletableAndSingleC
 
     @Override
     void delegateSubscribeToOriginal(final Subscriber<? super T> offloadSubscriber,
-                                     final CapturedContext capturedContext, final AsyncContextProvider contextProvider) {
-        original.delegateSubscribe(new ConcatWithSubscriber<>(offloadSubscriber, next), capturedContext, contextProvider);
+                                     final CapturedContext capturedContext,
+                                     final AsyncContextProvider contextProvider) {
+        original.delegateSubscribe(new ConcatWithSubscriber<>(offloadSubscriber, next),
+                capturedContext, contextProvider);
     }
 
     private static final class ConcatWithSubscriber<T> extends AbstractConcatWithSubscriber<T> {

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/CompletableMergeWithPublisher.java

@@ -184,7 +184,8 @@ private static final class Merger<T> implements Subscriber<T> {
         private Throwable completableError;
         private volatile int state;
 
-        Merger(Subscriber<? super T> subscriber, CapturedContext capturedContext, AsyncContextProvider contextProvider) {
+        Merger(Subscriber<? super T> subscriber, CapturedContext capturedContext,
+               AsyncContextProvider contextProvider) {
             this.wrappedSubscriber = contextProvider.wrapPublisherSubscriber(subscriber, capturedContext);
             completableSubscriber = new CompletableSubscriber();
         }

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/CompletableToPublisher.java

@@ -56,7 +56,8 @@ private static final class ConversionSubscriber<T> extends SequentialCancellable
         private volatile int terminated;
 
         private ConversionSubscriber(Subscriber<? super T> subscriber,
-                                     final CapturedContext capturedContext, final AsyncContextProvider contextProvider) {
+                                     final CapturedContext capturedContext,
+                                     final AsyncContextProvider contextProvider) {
             this.subscriber = subscriber;
             this.capturedContext = capturedContext;
             this.contextProvider = contextProvider;

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/ContextPreservingCompletableFuture.java

@@ -107,8 +107,8 @@ public CompletableFuture<Void> thenRunAsync(final Runnable action) {
 
     @Override
     public CompletableFuture<Void> thenRunAsync(final Runnable action, final java.util.concurrent.Executor executor) {
-        return newContextPreservingFuture(delegate.thenRunAsync(AsyncContext.provider().wrapRunnable(action, capturedContext),
-                executor), capturedContext);
+        return newContextPreservingFuture(delegate.thenRunAsync(
+                AsyncContext.provider().wrapRunnable(action, capturedContext), executor), capturedContext);
     }
 
     @Override
@@ -239,13 +239,14 @@ public CompletableFuture<Void> runAfterEitherAsync(final CompletionStage<?> othe
 
     @Override
     public <U> CompletableFuture<U> thenCompose(final Function<? super T, ? extends CompletionStage<U>> fn) {
-        return newContextPreservingFuture(delegate.thenCompose(AsyncContext.provider().wrapFunction(fn, capturedContext)), capturedContext);
+        return newContextPreservingFuture(delegate.thenCompose(
+                AsyncContext.provider().wrapFunction(fn, capturedContext)), capturedContext);
     }
 
     @Override
     public <U> CompletableFuture<U> thenComposeAsync(final Function<? super T, ? extends CompletionStage<U>> fn) {
-        return newContextPreservingFuture(delegate.thenComposeAsync(AsyncContext.provider().wrapFunction(fn, capturedContext)),
-                capturedContext);
+        return newContextPreservingFuture(delegate.thenComposeAsync(
+                AsyncContext.provider().wrapFunction(fn, capturedContext)), capturedContext);
     }
 
     @Override
@@ -257,14 +258,14 @@ public <U> CompletableFuture<U> thenComposeAsync(final Function<? super T, ? ext
 
     @Override
     public CompletableFuture<T> exceptionally(final Function<Throwable, ? extends T> fn) {
-        return newContextPreservingFuture(delegate.exceptionally(AsyncContext.provider().wrapFunction(fn, capturedContext)),
-                capturedContext);
+        return newContextPreservingFuture(delegate.exceptionally(
+                AsyncContext.provider().wrapFunction(fn, capturedContext)), capturedContext);
     }
 
     @Override
     public CompletableFuture<T> whenComplete(final BiConsumer<? super T, ? super Throwable> action) {
-        return newContextPreservingFuture(delegate.whenComplete(AsyncContext.provider().wrapBiConsumer(action, capturedContext)),
-                capturedContext);
+        return newContextPreservingFuture(delegate.whenComplete(
+                AsyncContext.provider().wrapBiConsumer(action, capturedContext)), capturedContext);
     }
 
     @Override
@@ -282,13 +283,14 @@ public CompletableFuture<T> whenCompleteAsync(final BiConsumer<? super T, ? supe
 
     @Override
     public <U> CompletableFuture<U> handle(final BiFunction<? super T, Throwable, ? extends U> fn) {
-        return newContextPreservingFuture(delegate.handle(AsyncContext.provider().wrapBiFunction(fn, capturedContext)), capturedContext);
+        return newContextPreservingFuture(delegate.handle(
+                AsyncContext.provider().wrapBiFunction(fn, capturedContext)), capturedContext);
     }
 
     @Override
     public <U> CompletableFuture<U> handleAsync(final BiFunction<? super T, Throwable, ? extends U> fn) {
-        return newContextPreservingFuture(delegate.handleAsync(AsyncContext.provider().wrapBiFunction(fn, capturedContext)),
-                capturedContext);
+        return newContextPreservingFuture(delegate.handleAsync(
+                AsyncContext.provider().wrapBiFunction(fn, capturedContext)), capturedContext);
     }
 
     @Override

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/DefaultAsyncContextProvider.java

@@ -20,12 +20,10 @@
 import io.servicetalk.concurrent.SingleSource;
 import io.servicetalk.context.api.ContextMap;
 import io.servicetalk.context.api.ContextMapHolder;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
@@ -50,7 +48,6 @@ class DefaultAsyncContextProvider implements AsyncContextProvider {
     protected DefaultAsyncContextProvider() {
     }
 
-    @Nonnull
     @Override
     public final ContextMap context() {
         final Thread t = Thread.currentThread();
@@ -68,13 +65,11 @@ public final ContextMap context() {
     }
 
     @Override
-    public final void context(@Nullable ContextMap contextMap) {
+    public final void context(ContextMap contextMap) {
         final Thread currentThread = Thread.currentThread();
         if (currentThread instanceof ContextMapHolder) {
             final ContextMapHolder asyncContextMapHolder = (ContextMapHolder) currentThread;
             asyncContextMapHolder.context(contextMap);
-        } else if (contextMap == null) {
-            CONTEXT_THREAD_LOCAL.remove();
         } else {
             CONTEXT_THREAD_LOCAL.set(contextMap);
         }
@@ -209,7 +204,8 @@ public final <T> SingleSource.Subscriber<T> wrapSingleSubscriberAndCancellable(
     }
 
     @Override
-    public final <T> PublisherSource.Subscriber<T> wrapSubscription(final PublisherSource.Subscriber<T> subscriber, final CapturedContext context) {
+    public final <T> PublisherSource.Subscriber<T> wrapSubscription(
+            final PublisherSource.Subscriber<T> subscriber, final CapturedContext context) {
         if (subscriber instanceof ContextPreservingSubscriber) {
             final ContextPreservingSubscriber<T> s = (ContextPreservingSubscriber<T>) subscriber;
             if (s.capturedContext == context) {
@@ -226,7 +222,8 @@ public final <T> PublisherSource.Subscriber<T> wrapSubscription(final PublisherS
     }
 
     @Override
-    public final <T> PublisherSource.Subscriber<T> wrapPublisherSubscriber(final PublisherSource.Subscriber<T> subscriber, final CapturedContext context) {
+    public final <T> PublisherSource.Subscriber<T> wrapPublisherSubscriber(
+            final PublisherSource.Subscriber<T> subscriber, final CapturedContext context) {
         if (subscriber instanceof ContextPreservingSubscriptionSubscriber) {
             final ContextPreservingSubscriptionSubscriber<T> s =
                     (ContextPreservingSubscriptionSubscriber<T>) subscriber;
@@ -243,8 +240,8 @@ public final <T> PublisherSource.Subscriber<T> wrapPublisherSubscriber(final Pub
     }
 
     @Override
-    public final <T> PublisherSource.Subscriber<T> wrapPublisherSubscriberAndSubscription(final PublisherSource.Subscriber<T> subscriber,
-                                                                                          final CapturedContext context) {
+    public final <T> PublisherSource.Subscriber<T> wrapPublisherSubscriberAndSubscription(
+            final PublisherSource.Subscriber<T> subscriber, final CapturedContext context) {
         if (subscriber instanceof ContextPreservingSubscriber) {
             final ContextPreservingSubscriber<T> s = (ContextPreservingSubscriber<T>) subscriber;
             if (s.capturedContext == context) {
@@ -272,7 +269,8 @@ public final ExecutorService wrapJdkExecutorService(final ExecutorService execut
     }
 
     @Override
-    public final io.servicetalk.concurrent.api.Executor wrapExecutor(final io.servicetalk.concurrent.api.Executor executor) {
+    public final io.servicetalk.concurrent.api.Executor wrapExecutor(
+            final io.servicetalk.concurrent.api.Executor executor) {
         return ContextPreservingStExecutor.of(executor);
     }
 
@@ -308,12 +306,14 @@ public final <T, U> Function<T, U> wrapFunction(final Function<T, U> func, final
     }
 
     @Override
-    public final <T, U> BiConsumer<T, U> wrapBiConsumer(final BiConsumer<T, U> consumer, final CapturedContext context) {
+    public final <T, U> BiConsumer<T, U> wrapBiConsumer(
+            final BiConsumer<T, U> consumer, final CapturedContext context) {
         return new ContextPreservingBiConsumer<>(consumer, context);
     }
 
     @Override
-    public final <T, U, V> BiFunction<T, U, V> wrapBiFunction(final BiFunction<T, U, V> func, final CapturedContext context) {
+    public final <T, U, V> BiFunction<T, U, V> wrapBiFunction(
+            final BiFunction<T, U, V> func, final CapturedContext context) {
         return new ContextPreservingBiFunction<>(func, context);
     }
 
@@ -356,11 +356,9 @@ private static ContextMap exchangeContext(ContextMap contextMap) {
 
     private static void detachContext(ContextMap expectedContext, ContextMap toRestore) {
         ContextMap current = exchangeContext(toRestore);
-        if (current != expectedContext) {
-            if (!NO_DEBUG_LOGGING) {
-                LOGGER.debug("Current context didn't match the expected context. current: {}, expected: {}",
-                        current, expectedContext, new Throwable("stack trace"));
-            }
+        if (current != expectedContext && !NO_DEBUG_LOGGING) {
+            LOGGER.debug("Current context didn't match the expected context. current: {}, expected: {}",
+                    current, expectedContext, new Throwable("stack trace"));
         }
     }
 

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/PublisherGroupBy.java

@@ -42,8 +42,9 @@ final class PublisherGroupBy<Key, T> extends AbstractPublisherGroupBy<Key, T> {
     @Override
     void handleSubscribe(Subscriber<? super GroupedPublisher<Key, T>> subscriber,
                          CapturedContext capturedContext, AsyncContextProvider contextProvider) {
-        original.delegateSubscribe(new GroupBySubscriber(subscriber, queueLimit, initialCapacityForGroups, capturedContext,
-                contextProvider), capturedContext, contextProvider);
+        original.delegateSubscribe(new GroupBySubscriber(
+                    subscriber, queueLimit, initialCapacityForGroups, capturedContext, contextProvider),
+                capturedContext, contextProvider);
     }
 
     private final class GroupBySubscriber extends AbstractGroupBySubscriber<Key, T> {

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/RepeatWhenSingle.java

@@ -147,7 +147,8 @@ public void onComplete() {
                                 // Either we copy the map up front before subscribe, or we just re-use the same map and
                                 // let the async source at the top of the chain reset if necessary. We currently choose
                                 // the second option.
-                                outer.original.delegateSubscribe(RepeatSubscriber.this, capturedContext, contextProvider);
+                                outer.original.delegateSubscribe(
+                                        RepeatSubscriber.this, capturedContext, contextProvider);
                             }
                             break;
                         }

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/RetrySingle.java

@@ -43,8 +43,9 @@ void handleSubscribe(final Subscriber<? super T> subscriber,
         // resubscribe. This allows for async context to be shared across each request retry, and follows the same
         // shared state model as the request object on the client. If copy-on-each-resubscribe is desired this could
         // be provided by an independent operator, or manually cleared/overwritten.
-        original.delegateSubscribe(new RetrySubscriber<>(new SequentialCancellable(), this, subscriber, 0, capturedContext,
-                contextProvider), capturedContext, contextProvider);
+        original.delegateSubscribe(new RetrySubscriber<>(
+                new SequentialCancellable(), this, subscriber, 0, capturedContext, contextProvider),
+                capturedContext, contextProvider);
     }
 
     abstract static class AbstractRetrySubscriber<T> implements Subscriber<T> {

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/SingleConcatWithCompletable.java

@@ -35,7 +35,8 @@ final class SingleConcatWithCompletable<T> extends AbstractCompletableAndSingleC
 
     @Override
     void delegateSubscribeToOriginal(final Subscriber<? super T> offloadSubscriber,
-                                     final CapturedContext capturedContext, final AsyncContextProvider contextProvider) {
+                                     final CapturedContext capturedContext,
+                                     final AsyncContextProvider contextProvider) {
         original.delegateSubscribe(new ConcatWithSubscriber<>(offloadSubscriber, next), capturedContext,
                 contextProvider);
     }

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/SingleToCompletableFuture.java

@@ -18,7 +18,6 @@
 import io.servicetalk.concurrent.Cancellable;
 import io.servicetalk.concurrent.SingleSource.Subscriber;
 import io.servicetalk.concurrent.internal.SequentialCancellable;
-import io.servicetalk.context.api.ContextMap;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;

servicetalk-concurrent-api/src/main/java/io/servicetalk/concurrent/api/TimeoutSingle.java

@@ -92,7 +92,8 @@ private TimeoutSubscriber(TimeoutSingle<X> parent, Subscriber<? super X> target,
         }
 
         static <X> TimeoutSubscriber<X> newInstance(TimeoutSingle<X> parent, Subscriber<? super X> target,
-                                                    CapturedContext capturedContext, AsyncContextProvider contextProvider) {
+                                                    CapturedContext capturedContext,
+                                                    AsyncContextProvider contextProvider) {
             TimeoutSubscriber<X> s = new TimeoutSubscriber<>(parent, target, contextProvider);
             Cancellable localTimerCancellable;
             try {