Apply optional dependency to kotlin support related dependency

core/pom.xml

@@ -38,24 +38,28 @@
       <groupId>org.jetbrains.kotlin</groupId>
       <artifactId>kotlin-stdlib-jdk8</artifactId>
       <version>${kotlin.version}</version>
+      <optional>true</optional>
     </dependency>
 
     <dependency>
       <groupId>org.jetbrains.kotlin</groupId>
       <artifactId>kotlin-reflect</artifactId>
       <version>${kotlin.version}</version>
+      <optional>true</optional>
     </dependency>
 
     <dependency>
       <groupId>org.jetbrains.kotlinx</groupId>
       <artifactId>kotlinx-coroutines-jdk8</artifactId>
       <version>${kotlinx.coroutines.version}</version>
+      <optional>true</optional>
     </dependency>
 
     <dependency>
       <groupId>org.jetbrains.kotlinx</groupId>
       <artifactId>kotlinx-coroutines-reactor</artifactId>
       <version>${kotlinx.coroutines.version}</version>
+      <optional>true</optional>
     </dependency>
 
     <dependency>

core/src/main/java/feign/AsyncResponseHandler.java

@@ -18,7 +18,7 @@
 import feign.Logger.Level;
 import feign.codec.Decoder;
 import feign.codec.ErrorDecoder;
-import kotlin.Unit;
+import feign.kotlinSupport.KotlinDetector;
 
 import java.io.IOException;
 import java.lang.reflect.Type;
@@ -56,7 +56,7 @@ class AsyncResponseHandler {
   }
 
   boolean isVoidType(Type returnType) {
-    return Void.class == returnType || void.class == returnType || Unit.class == returnType;
+    return Void.class == returnType || void.class == returnType || KotlinDetector.isUnitType(returnType);
   }
 
   void handleResponse(CompletableFuture<Object> resultFuture,

core/src/main/java/feign/MethodInfo.java

@@ -13,6 +13,9 @@
  */
 package feign;
 
+import feign.kotlinSupport.KotlinDetector;
+import feign.kotlinSupport.MethodKt;
+
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -35,7 +38,7 @@ class MethodInfo {
 
     final Type type = Types.resolve(targetType, targetType, method.getGenericReturnType());
 
-    if (MethodKt.isSuspend(method)) {
+    if (KotlinDetector.isSuspendingFunction(method)) {
       this.asyncReturnType = true;
       this.underlyingReturnType = MethodKt.getKotlinMethodReturnType(method);
       if (this.underlyingReturnType == null) {

core/src/main/java/feign/ReflectiveAsyncFeign.java

@@ -13,6 +13,8 @@
  */
 package feign;
 
+import feign.kotlinSupport.KotlinDetector;
+import feign.kotlinSupport.MethodKt;
 import kotlin.coroutines.Continuation;
 import kotlinx.coroutines.future.FutureKt;
 
@@ -66,7 +68,7 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
 
       setInvocationContext(new AsyncInvocation<>(context, methodInfo));
       try {
-        if (MethodKt.isSuspend(method)) {
+        if (KotlinDetector.isSuspendingFunction(method)) {
           CompletableFuture<?> result = (CompletableFuture<?>) method.invoke(instance, args);
           Continuation<Object> continuation = (Continuation<Object>) args[args.length - 1];
           return FutureKt.await(result, continuation);

core/src/main/java/feign/kotlinSupport/Assert.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package feign.kotlinSupport;
+
+/**
+ * Assertion utility class that assists in validating arguments.
+ *
+ * <p>Useful for identifying programmer errors early and clearly at runtime.
+ *
+ * <p>For example, if the contract of a public method states it does not
+ * allow {@code null} arguments, {@code Assert} can be used to validate that
+ * contract. Doing this clearly indicates a contract violation when it
+ * occurs and protects the class's invariants.
+ *
+ * <p>Typically used to validate method arguments rather than configuration
+ * properties, to check for cases that are usually programmer errors rather
+ * than configuration errors. In contrast to configuration initialization
+ * code, there is usually no point in falling back to defaults in such methods.
+ *
+ * <p>This class is similar to JUnit's assertion library. If an argument value is
+ * deemed invalid, an {@link IllegalArgumentException} is thrown (typically).
+ * For example:
+ *
+ * <pre class="code">
+ * Assert.notNull(clazz, "The class must not be null");
+ * Assert.isTrue(i &gt; 0, "The value must be greater than zero");</pre>
+ *
+ * <p>Mainly for internal use within the framework; for a more comprehensive suite
+ * of assertion utilities consider {@code org.apache.commons.lang3.Validate} from
+ * <a href="https://commons.apache.org/proper/commons-lang/">Apache Commons Lang</a>,
+ * Google Guava's
+ * <a href="https://github.com/google/guava/wiki/PreconditionsExplained">Preconditions</a>,
+ * or similar third-party libraries.
+ *
+ * @author Keith Donald
+ * @author Juergen Hoeller
+ * @author Sam Brannen
+ * @author Colin Sampaleanu
+ * @author Rob Harrop
+ * @since 1.1.2
+ */
+public abstract class Assert {
+
+	/**
+	 * Assert that an object is not {@code null}.
+	 * <pre class="code">Assert.notNull(clazz, "The class must not be null");</pre>
+	 * @param object the object to check
+	 * @param message the exception message to use if the assertion fails
+	 * @throws IllegalArgumentException if the object is {@code null}
+	 */
+	public static void notNull(Object object, String message) {
+		if (object == null) {
+			throw new IllegalArgumentException(message);
+		}
+	}
+
+}