diff --git a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/GenericDebuggerRunner.java b/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/GenericDebuggerRunner.java
index c7e386ed3..1ea48c2a4 100644
--- a/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/GenericDebuggerRunner.java
+++ b/java-debugger-impl/src/main/java/com/intellij/java/debugger/impl/GenericDebuggerRunner.java
@@ -24,6 +24,7 @@
 import com.intellij.java.execution.configurations.*;
 import com.intellij.java.execution.runners.JavaPatchableProgramRunner;
 import consulo.annotation.component.ExtensionImpl;
+import consulo.application.Application;
 import consulo.document.FileDocumentManager;
 import consulo.execution.DefaultExecutionResult;
 import consulo.execution.ExecutionResult;
@@ -44,7 +45,7 @@
 @ExtensionImpl(id = "defaultJavaDebugRunner")
 public class GenericDebuggerRunner extends JavaPatchableProgramRunner<GenericDebuggerRunnerSettings> {
     @Override
-    public boolean canRun(@Nonnull final String executorId, @Nonnull final RunProfile profile) {
+    public boolean canRun(@Nonnull String executorId, @Nonnull RunProfile profile) {
         return executorId.equals(DefaultDebugExecutor.EXECUTOR_ID) && profile instanceof GenericDebugRunnerConfiguration;
     }
 
@@ -61,21 +62,28 @@ protected RunContentDescriptor doExecute(@Nonnull RunProfileState state, @Nonnul
     }
 
     @Nullable
-    protected RunContentDescriptor createContentDescriptor(@Nonnull RunProfileState state,
-                                                           @Nonnull ExecutionEnvironment environment) throws ExecutionException {
-        if (state instanceof JavaCommandLine) {
-            final OwnJavaParameters parameters = ((JavaCommandLine) state).getJavaParameters();
+    protected RunContentDescriptor createContentDescriptor(
+        @Nonnull RunProfileState state,
+        @Nonnull ExecutionEnvironment environment
+    ) throws ExecutionException {
+        if (state instanceof JavaCommandLine commandLine) {
+            OwnJavaParameters parameters = commandLine.getJavaParameters();
             runCustomPatchers(parameters, environment.getExecutor(), environment.getRunProfile());
-            RemoteConnection connection =
-                DebuggerManagerImpl.createDebugParameters(parameters, true, DebuggerSettings.getInstance().DEBUGGER_TRANSPORT, "", false);
+            RemoteConnection connection = DebuggerManagerImpl.createDebugParameters(
+                parameters,
+                true,
+                DebuggerSettings.getInstance().DEBUGGER_TRANSPORT,
+                "",
+                false
+            );
             return attachVirtualMachine(state, environment, connection, true);
         }
         if (state instanceof PatchedRunnableState) {
-            final RemoteConnection connection = doPatch(new OwnJavaParameters(), environment.getRunnerSettings());
+            RemoteConnection connection = doPatch(new OwnJavaParameters(), environment.getRunnerSettings());
             return attachVirtualMachine(state, environment, connection, true);
         }
-        if (state instanceof RemoteState) {
-            final RemoteConnection connection = createRemoteDebugConnection((RemoteState) state, environment.getRunnerSettings());
+        if (state instanceof RemoteState remoteState) {
+            RemoteConnection connection = createRemoteDebugConnection(remoteState, environment.getRunnerSettings());
             return attachVirtualMachine(state, environment, connection, false);
         }
 
@@ -83,17 +91,19 @@ protected RunContentDescriptor createContentDescriptor(@Nonnull RunProfileState
     }
 
     @Nullable
-    protected RunContentDescriptor attachVirtualMachine(RunProfileState state,
-                                                        @Nonnull ExecutionEnvironment env,
-                                                        RemoteConnection connection,
-                                                        boolean pollConnection) throws ExecutionException {
+    protected RunContentDescriptor attachVirtualMachine(
+        RunProfileState state,
+        @Nonnull ExecutionEnvironment env,
+        RemoteConnection connection,
+        boolean pollConnection
+    ) throws ExecutionException {
         DebugEnvironment environment = new DefaultDebugEnvironment(env, state, connection, pollConnection);
-        final DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(env.getProject()).attachVirtualMachine(environment);
+        DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(env.getProject()).attachVirtualMachine(environment);
         if (debuggerSession == null) {
             return null;
         }
 
-        final DebugProcessImpl debugProcess = debuggerSession.getProcess();
+        DebugProcessImpl debugProcess = debuggerSession.getProcess();
         if (debugProcess.isDetached() || debugProcess.isDetaching()) {
             debuggerSession.dispose();
             return null;
@@ -108,16 +118,16 @@ protected RunContentDescriptor attachVirtualMachine(RunProfileState state,
             ExecutionResult executionResult = debugProcess.getExecutionResult();
             session.addExtraActions(executionResult.getActions());
             if (executionResult instanceof DefaultExecutionResult) {
-                session.addRestartActions(((DefaultExecutionResult) executionResult).getRestartActions());
+                session.addRestartActions(((DefaultExecutionResult)executionResult).getRestartActions());
             }
             return JavaDebugProcess.create(session, debuggerSession);
         }).getRunContentDescriptor();
     }
 
-    private static RemoteConnection createRemoteDebugConnection(RemoteState connection, final RunnerSettings settings) {
-        final RemoteConnection remoteConnection = connection.getRemoteConnection();
+    private static RemoteConnection createRemoteDebugConnection(RemoteState connection, RunnerSettings settings) {
+        RemoteConnection remoteConnection = connection.getRemoteConnection();
 
-        GenericDebuggerRunnerSettings debuggerRunnerSettings = (GenericDebuggerRunnerSettings) settings;
+        GenericDebuggerRunnerSettings debuggerRunnerSettings = (GenericDebuggerRunnerSettings)settings;
 
         if (debuggerRunnerSettings != null) {
             remoteConnection.setUseSockets(debuggerRunnerSettings.getTransport() == DebuggerSettings.SOCKET_TRANSPORT);
@@ -133,16 +143,22 @@ public GenericDebuggerRunnerSettings createConfigurationData(ConfigurationInfoPr
     }
 
     @Override
-    public void patch(OwnJavaParameters javaParameters,
-                      RunnerSettings settings,
-                      RunProfile runProfile,
-                      final boolean beforeExecution) throws ExecutionException {
+    public void patch(
+        OwnJavaParameters javaParameters,
+        RunnerSettings settings,
+        RunProfile runProfile,
+        boolean beforeExecution
+    ) throws ExecutionException {
         doPatch(javaParameters, settings);
-        runCustomPatchers(javaParameters, Executor.EP_NAME.findExtension(DefaultDebugExecutor.class), runProfile);
+        runCustomPatchers(
+            javaParameters,
+            Application.get().getExtensionPoint(Executor.class).findExtension(DefaultDebugExecutor.class),
+            runProfile
+        );
     }
 
-    private static RemoteConnection doPatch(final OwnJavaParameters javaParameters, final RunnerSettings settings) throws ExecutionException {
-        final GenericDebuggerRunnerSettings debuggerSettings = ((GenericDebuggerRunnerSettings) settings);
+    private static RemoteConnection doPatch(OwnJavaParameters javaParameters, RunnerSettings settings) throws ExecutionException {
+        GenericDebuggerRunnerSettings debuggerSettings = ((GenericDebuggerRunnerSettings)settings);
         if (StringUtil.isEmpty(debuggerSettings.getDebugPort())) {
             debuggerSettings.setDebugPort(DebuggerUtils.getInstance().findAvailableDebugAddress(debuggerSettings.getTransport()).address());
         }
@@ -150,11 +166,10 @@ private static RemoteConnection doPatch(final OwnJavaParameters javaParameters,
     }
 
     @Override
-    public SettingsEditor<GenericDebuggerRunnerSettings> getSettingsEditor(final Executor executor, RunConfiguration configuration) {
-        if (configuration instanceof RunConfigurationWithRunnerSettings) {
-            if (((RunConfigurationWithRunnerSettings) configuration).isSettingsNeeded()) {
-                return new GenericDebuggerParametersRunnerConfigurable(configuration.getProject());
-            }
+    public SettingsEditor<GenericDebuggerRunnerSettings> getSettingsEditor(Executor executor, RunConfiguration configuration) {
+        if (configuration instanceof RunConfigurationWithRunnerSettings runConfigurationWithRunnerSettings
+            && runConfigurationWithRunnerSettings.isSettingsNeeded()) {
+            return new GenericDebuggerParametersRunnerConfigurable(configuration.getProject());
         }
         return null;
     }