diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ModuleRunConfigurationManager.java b/platform/lang-impl/src/com/intellij/execution/impl/ModuleRunConfigurationManager.java
index 2610b38eff39..84815333a681 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/ModuleRunConfigurationManager.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/ModuleRunConfigurationManager.java
@@ -28,8 +28,10 @@ import com.intellij.openapi.module.ModuleComponent;
 import com.intellij.openapi.project.ModuleAdapter;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashSet;
 import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
@@ -37,6 +39,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
@@ -51,19 +54,23 @@ import java.util.Set;
 public final class ModuleRunConfigurationManager extends ModuleAdapter implements ModuleComponent, PersistentStateComponent<Element> {
   private static final Logger LOG = Logger.getInstance(ModuleRunConfigurationManager.class);
   @NonNls static final String COMPONENT_NAME = "ModuleRunConfigurationManager";
-
-  final Object myRemoverKey;
+  @NotNull
+  private final Condition<RunnerAndConfigurationSettings> myModuleConfigCondition = new Condition<RunnerAndConfigurationSettings>() {
+    @Override
+    public boolean value(@Nullable RunnerAndConfigurationSettings settings) {
+      return settings != null && usesMyModule(settings.getConfiguration());
+    }
+  };
   @NotNull
   private final Module myModule;
   @NotNull
-  final RunManagerImpl myManager;
+  private final RunManagerImpl myManager;
   @Nullable
   private List<Element> myUnloadedElements = null;
 
   public ModuleRunConfigurationManager(@NotNull final Module module, @NotNull final RunManagerImpl runManager) {
     myModule = module;
     myManager = runManager;
-    myRemoverKey = new Object();
   }
 
   @Override
@@ -118,6 +125,11 @@ public final class ModuleRunConfigurationManager extends ModuleAdapter implement
     }
   }
 
+  @NotNull
+  private Collection<? extends RunnerAndConfigurationSettings> getModuleRunConfigurationSettings() {
+    return ContainerUtil.filter(myManager.getConfigurationSettings(), myModuleConfigCondition);
+  }
+
   private boolean usesMyModule(RunConfiguration config) {
     return config instanceof ModuleBasedConfiguration
            && myModule.equals(((ModuleBasedConfiguration)config).getConfigurationModule().getModule());
@@ -125,7 +137,7 @@ public final class ModuleRunConfigurationManager extends ModuleAdapter implement
 
   public void writeExternal(@NotNull final Element element) throws WriteExternalException {
     LOG.debug("writeExternal(" + myModule + ")");
-    for (final RunnerAndConfigurationSettings settings : myManager.getExternalSettings(myRemoverKey)) {
+    for (final RunnerAndConfigurationSettings settings : getModuleRunConfigurationSettings()) {
       myManager.addConfigurationElement(element, settings);
     }
     if (myUnloadedElements != null) {
@@ -142,7 +154,7 @@ public final class ModuleRunConfigurationManager extends ModuleAdapter implement
 
     final List children = element.getChildren();
     for (final Object child : children) {
-      final RunnerAndConfigurationSettings configuration = myManager.loadConfiguration(myRemoverKey, (Element)child, true);
+      final RunnerAndConfigurationSettings configuration = myManager.loadConfiguration((Element)child, true);
       if (configuration == null && Comparing.strEqual(element.getName(), RunManagerImpl.CONFIGURATION)) {
         if (myUnloadedElements == null) myUnloadedElements = new ArrayList<Element>(2);
         myUnloadedElements.add(element);
@@ -170,7 +182,10 @@ public final class ModuleRunConfigurationManager extends ModuleAdapter implement
   @Override
   public void moduleRemoved(Project project, Module module) {
     if (myModule.equals(module)) {
-      myManager.removeExternalSettings(myRemoverKey);
+      LOG.debug("time to remove something from project (" + project + ")");
+      for (final RunnerAndConfigurationSettings settings : getModuleRunConfigurationSettings()) {
+        myManager.removeConfiguration(settings);
+      }
     }
   }
 }
diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
index f645686e5884..cc1a3d4d9d1b 100644
--- a/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
+++ b/platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java
@@ -49,8 +49,6 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     new HashMap<String, RunnerAndConfigurationSettings>();
   private final Map<String, RunnerAndConfigurationSettings> myConfigurations =
     new LinkedHashMap<String, RunnerAndConfigurationSettings>(); // template configurations are not included here
-  final Map<Object, List<RunnerAndConfigurationSettings>> myExternalSettings =
-    new java.util.HashMap<Object, List<RunnerAndConfigurationSettings>>();
   private final Map<String, Boolean> mySharedConfigurations = new TreeMap<String, Boolean>();
   private final Map<RunConfiguration, List<BeforeRunTask>> myConfigurationToBeforeTasksMap = new WeakHashMap<RunConfiguration, List<BeforeRunTask>>();
 
@@ -223,11 +221,6 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     return list.toArray(new RunConfiguration[list.size()]);
   }
 
-  @NotNull
-  public List<RunnerAndConfigurationSettings> getExternalSettings(@NotNull Object key) {
-    return myExternalSettings.containsKey(key) ? myExternalSettings.get(key) : Collections.<RunnerAndConfigurationSettings>emptyList();
-  }
-
   @NotNull
   @Override
   public List<RunnerAndConfigurationSettings> getAllSettings() {
@@ -403,9 +396,6 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
   @Override
   public void removeConfiguration(@Nullable RunnerAndConfigurationSettings settings) {
     if (settings == null) return;
-    for (Map.Entry<Object, List<RunnerAndConfigurationSettings>> entry : myExternalSettings.entrySet()) {
-      if (entry.getValue().remove(settings)) break;
-    }
 
     for (Iterator<RunnerAndConfigurationSettings> it = getSortedConfigurations().iterator(); it.hasNext(); ) {
       final RunnerAndConfigurationSettings configuration = it.next();
@@ -786,21 +776,8 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
     fireRunConfigurationsRemoved(configurations);
   }
 
-  public void removeExternalSettings(@NotNull Object removerKey) {
-    List<RunnerAndConfigurationSettings> settingsList = getExternalSettings(removerKey);
-    for (RunnerAndConfigurationSettings each : settingsList) {
-      removeConfiguration(each);
-    }
-    myExternalSettings.remove(removerKey);
-  }
-
   @Nullable
   public RunnerAndConfigurationSettings loadConfiguration(final Element element, boolean isShared) throws InvalidDataException {
-    return loadConfiguration(null, element, isShared);
-  }
-
-  @Nullable
-  public RunnerAndConfigurationSettings loadConfiguration(@Nullable final Object removerKey, final Element element, boolean isShared) throws InvalidDataException {
     final RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(this);
     settings.readExternal(element);
     ConfigurationFactory factory = settings.getFactory();
@@ -808,13 +785,6 @@ public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable,
       return null;
     }
 
-    if (removerKey !=null) {
-      if (!myExternalSettings.containsKey(removerKey)) {
-        myExternalSettings.put(removerKey, new ArrayList<RunnerAndConfigurationSettings>());
-      }
-      myExternalSettings.get(removerKey).add(settings);
-    }
-
     final Element methodsElement = element.getChild(METHOD);
     final List<BeforeRunTask> tasks = readStepsBeforeRun(methodsElement, settings);
     if (settings.isTemplate()) {
diff --git a/platform/lang-impl/testSources/com/intellij/execution/impl/ModuleRunConfigurationManagerTest.java b/platform/lang-impl/testSources/com/intellij/execution/impl/ModuleRunConfigurationManagerTest.java
index 943cbbf2f172..d82590750f8c 100644
--- a/platform/lang-impl/testSources/com/intellij/execution/impl/ModuleRunConfigurationManagerTest.java
+++ b/platform/lang-impl/testSources/com/intellij/execution/impl/ModuleRunConfigurationManagerTest.java
@@ -68,7 +68,6 @@ public class ModuleRunConfigurationManagerTest extends LightPlatformTestCase {
       createSettings("other-module-run", new MyModuleBasedConfiguration("other-module-run-config", getProject(), getModule())),
       mySettings
     );
-    myManager.myManager.myExternalSettings.put(myManager.myRemoverKey, Collections.singletonList(mySettings));
     myConfigurations = Collections.unmodifiableCollection(configs);
   }
 
@@ -106,13 +105,13 @@ public class ModuleRunConfigurationManagerTest extends LightPlatformTestCase {
     assertSameElements("One config should be added to state", myAddedElements, Collections.singleton(mySettings));
   }
 
-  public void testBeforeOtherModuleRemoved() throws Exception {
+  public void testOtherModuleRemoved() throws Exception {
     myRemovedSettings.clear();
     myManager.moduleRemoved(getProject(), getModule());
     assertEmpty("No settings should be removed", myRemovedSettings);
   }
 
-  public void testBeforeMyModuleRemoved() throws Exception {
+  public void testMyModuleRemoved() throws Exception {
     myRemovedSettings.clear();
     myManager.moduleRemoved(getProject(), myModule);
     assertSameElements("one run config should be removed", myRemovedSettings, Collections.singleton(mySettings));