external system: use platform modifiable models during project import;

move modifiable models provider from maven to external system API for reuse
2026-09-27 10:03:11 +07:00 · 2015-09-15 14:42:32 +03:00
parent b2451065c7
commit 6d50f65056
60 changed files with 1334 additions and 1806 deletions
@@ -19,7 +19,7 @@ import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.Key;
 import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService;
 import com.intellij.openapi.externalSystem.util.DisposeAwareProjectChange;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
@@ -53,8 +53,7 @@ public class JavaProjectDataService extends AbstractProjectDataService<JavaProje
  public void importData(@NotNull final Collection<DataNode<JavaProjectData>> toImport,
                         @Nullable final ProjectData projectData,
                         @NotNull final Project project,
-                         @NotNull final PlatformFacade platformFacade,
-                         final boolean synchronous) {
+                         @NotNull final IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty() || projectData == null) {
      return;
    }
@@ -93,7 +92,7 @@ public class JavaProjectDataService extends AbstractProjectDataService<JavaProje
      }
    }
    // Language level.
-    setLanguageLevel(javaProjectData.getLanguageLevel(), project, synchronous);
+    setLanguageLevel(javaProjectData.getLanguageLevel(), project);
  }

  @Nullable
@@ -114,12 +113,12 @@ public class JavaProjectDataService extends AbstractProjectDataService<JavaProje
  }

  @SuppressWarnings("MethodMayBeStatic")
-  public void setLanguageLevel(@NotNull final LanguageLevel languageLevel, @NotNull Project project, boolean synchronous) {
+  public void setLanguageLevel(@NotNull final LanguageLevel languageLevel, @NotNull Project project) {
    final LanguageLevelProjectExtension languageLevelExtension = LanguageLevelProjectExtension.getInstance(project);
    if (languageLevelExtension.getLanguageLevel().isAtLeast(languageLevel)) {
      return;
    }
-    ExternalSystemApiUtil.executeProjectChangeAction(synchronous, new DisposeAwareProjectChange(project) {
+    ExternalSystemApiUtil.executeProjectChangeAction(new DisposeAwareProjectChange(project) {
      @Override
      public void execute() {
        languageLevelExtension.setLanguageLevel(languageLevel);
@@ -13,5 +13,6 @@
    <orderEntry type="module" module-name="projectModel-api" />
    <orderEntry type="module" module-name="platform-api" />
    <orderEntry type="module" module-name="lang-api" />
+    <orderEntry type="module" module-name="compiler-openapi" />
  </component>
 </module>
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2000-2015 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 com.intellij.openapi.externalSystem.service.project;
+
+import com.intellij.packaging.artifacts.Artifact;
+import com.intellij.packaging.artifacts.ModifiableArtifactModel;
+import com.intellij.packaging.elements.PackagingElement;
+import com.intellij.packaging.elements.PackagingElementResolvingContext;
+import com.intellij.packaging.ui.ManifestFileConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * @author Vladislav.Soroka
+ * @since 9/11/2015
+ */
+public interface ArtifactExternalDependenciesImporter {
+  @Nullable
+  public ManifestFileConfiguration getManifestFile(@NotNull Artifact artifact, @NotNull PackagingElementResolvingContext context);
+
+  List<PackagingElement<?>> getExternalDependenciesList(@NotNull Artifact artifact);
+
+  void applyChanges(ModifiableArtifactModel artifactModel, PackagingElementResolvingContext context);
+}
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2000-2015 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 com.intellij.openapi.externalSystem.service.project;
+
+import com.intellij.openapi.externalSystem.model.project.*;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.roots.ModuleOrderEntry;
+import com.intellij.openapi.roots.OrderEntry;
+import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author Vladislav.Soroka
+ * @since 9/11/2015
+ */
+public interface IdeModelsProvider {
+  @NotNull
+  Module[] getModules();
+
+  @NotNull
+  Module[] getModules(@NotNull ProjectData projectData);
+
+  @NotNull
+  OrderEntry[] getOrderEntries(@NotNull Module module);
+
+  @Nullable
+  Module findIdeModule(@NotNull ModuleData module);
+
+  @Nullable
+  Module findIdeModule(@NotNull String ideModuleName);
+
+  @Nullable
+  Library findIdeLibrary(@NotNull LibraryData libraryData);
+
+  @Nullable
+  ModuleOrderEntry findIdeModuleDependency(@NotNull ModuleDependencyData dependency, @NotNull Module module);
+
+  @Nullable
+  OrderEntry findIdeModuleOrderEntry(LibraryDependencyData data);
+
+  @NotNull
+  VirtualFile[] getContentRoots(Module module);
+
+  @NotNull
+  Library[] getAllLibraries();
+
+  @Nullable
+  Library getLibraryByName(String name);
+
+  @NotNull
+  String[] getLibraryUrls(@NotNull Library library, @NotNull OrderRootType type);
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2015 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -13,52 +13,56 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-package org.jetbrains.idea.maven.importing;
+package com.intellij.openapi.externalSystem.service.project;

 import com.intellij.facet.ModifiableFacetModel;
 import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTable;
 import com.intellij.packaging.artifacts.ModifiableArtifactModel;
 import com.intellij.packaging.elements.PackagingElementResolvingContext;
+import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.idea.maven.project.MavenModelsProvider;

-public interface MavenModifiableModelsProvider extends MavenModelsProvider {
-  ModifiableModuleModel getModuleModel();
+/**
+ * @author Vladislav.Soroka
+ * @since 9/11/2015
+ */
+public interface IdeModifiableModelsProvider extends IdeModelsProvider {
+  @NotNull
+  Module newModule(@NotNull @NonNls String filePath, final String moduleTypeId);

-  ModifiableRootModel getRootModel(Module module);
+  @NotNull
+  ModifiableModuleModel getModifiableModuleModel();

-  ModifiableFacetModel getFacetModel(Module module);
+  @NotNull
+  ModifiableRootModel getModifiableRootModel(Module module);

-  ModifiableArtifactModel getArtifactModel();
+  @NotNull
+  ModifiableFacetModel getModifiableFacetModel(Module module);

-  PackagingElementResolvingContext getPackagingElementResolvingContext();
+  @NotNull
+  LibraryTable.ModifiableModel getModifiableProjectLibrariesModel();

-  ArtifactExternalDependenciesImporter getArtifactExternalDependenciesImporter();
+  Library.ModifiableModel getModifiableLibraryModel(Library library);

-  LibraryTable.ModifiableModel getProjectLibrariesModel();
-
-  Library[] getAllLibraries();
-
-  Library getLibraryByName(String name);
+  @NotNull
+  ModifiableArtifactModel getModifiableArtifactModel();

  Library createLibrary(String name);

  void removeLibrary(Library library);

-  Library.ModifiableModel getLibraryModel(Library library);
+  ModalityState getModalityStateForQuestionDialogs();

-  @NotNull
-  String[] getLibraryUrls(@NotNull Library library, @NotNull OrderRootType type);
+  ArtifactExternalDependenciesImporter getArtifactExternalDependenciesImporter();
+
+  PackagingElementResolvingContext getPackagingElementResolvingContext();

  void commit();

  void dispose();
-
-  ModalityState getModalityStateForQuestionDialogs();
 }
@@ -1,96 +0,0 @@
-package com.intellij.openapi.externalSystem.service.project;
-
-import com.intellij.openapi.externalSystem.model.project.*;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.ModuleOrderEntry;
-import com.intellij.openapi.roots.OrderEntry;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-
-/**
- * IntelliJ Platform code provides a lot of statical bindings to the interested pieces of data. For example we need to execute code
- * like below to get list of modules for the target project:
- * <pre>
- *   ModuleManager.getInstance(project).getModules()
- * </pre>
- * That means that it's not possible to test target classes in isolation if corresponding infrastructure is not set up.
- * However, we don't want to set it up if we execute a simple standalone test.
- * <p/>
- * This interface is intended to encapsulate access to the underlying ide platform functionality.
- * <p/>
- * Implementations of this interface are expected to be thread-safe.
- * 
- * @author Denis Zhdanov
- * @since 1/26/12 11:32 AM
- */
-public interface PlatformFacade {
-
-  @NotNull
-  LibraryTable getProjectLibraryTable(@NotNull Project project);
-  
-  @NotNull
-  Collection<Module> getModules(@NotNull Project project);
-
-  @NotNull
-  Collection<Module> getModules(@NotNull Project project, @NotNull ProjectData projectData);
-
-  @NotNull
-  Collection<OrderEntry> getOrderEntries(@NotNull Module module);
-
-  /**
-   * Allows to derive from the given VFS file path that may be compared to the path used by the gradle api.
-   * <p/>
-   * Generally, this method is necessary for processing binary library paths - they point to jar files and VFS uses
-   * <code>'!'</code> marks in their paths internally.
-   * 
-   * @param file  target file
-   * @return      given file's path that may be compared to the one used by the gradle api
-   */
-  @NotNull
-  String getLocalFileSystemPath(@NotNull VirtualFile file);
-
-  /**
-   * Creates a module of the specified type at the specified path and adds it to the project
-   * to which the module manager is related.
-   *
-   *
-   * @param project
-   * @param filePath the path at which the module is created.
-   * @param moduleTypeId the ID of the module type to create.
-   * @return the module instance.
-   */
-  Module newModule(Project project, @NotNull @NonNls String filePath, final String moduleTypeId);
-
-  ModifiableRootModel getModuleModifiableModel(Module module);
-
-  @Nullable
-  Module findIdeModule(@NotNull ModuleData module, @NotNull Project ideProject);
-
-  @Nullable
-  Module findIdeModule(@NotNull String ideModuleName, @NotNull Project ideProject);
-
-  @Nullable
-  Library findIdeLibrary(@NotNull LibraryData libraryData, @NotNull Project ideProject);
-
-  @SuppressWarnings("MethodMayBeStatic")
-  @Nullable
-  ModuleOrderEntry findIdeModuleDependency(@NotNull ModuleDependencyData dependency, @NotNull ModifiableRootModel model);
-
-  @Nullable
-  OrderEntry findIdeModuleOrderEntry(LibraryDependencyData data, Project project);
-
-  void updateModule(@NotNull Module module, @NotNull Consumer<ModifiableRootModel> task);
-
-  void updateLibraryTable(@NotNull Project project, @NotNull Consumer<LibraryTable.ModifiableModel> task);
-
-  void updateLibrary(@NotNull Library library, @NotNull Consumer<Library.ModifiableModel> task);
-}
@@ -18,7 +18,7 @@ package com.intellij.openapi.externalSystem.service.project.manage;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.Key;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
@@ -31,7 +31,7 @@ import java.util.Collections;
 * @author Vladislav.Soroka
 * @since 5/5/2015
 */
-public abstract class AbstractProjectDataService<E, I> implements ProjectDataServiceEx<E, I> {
+public abstract class AbstractProjectDataService<E, I> implements ProjectDataService<E, I> {

  public final Computable.PredefinedValueComputable<Collection<I>> EMPTY_LIST =
    new Computable.PredefinedValueComputable<Collection<I>>(Collections.<I>emptyList());
@@ -44,8 +44,7 @@ public abstract class AbstractProjectDataService<E, I> implements ProjectDataSer
  public void importData(@NotNull Collection<DataNode<E>> toImport,
                         @Nullable ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
  }

  @NotNull
@@ -53,7 +52,7 @@ public abstract class AbstractProjectDataService<E, I> implements ProjectDataSer
  public Computable<Collection<I>> computeOrphanData(@NotNull Collection<DataNode<E>> toImport,
                                                     @NotNull ProjectData projectData,
                                                     @NotNull Project project,
-                                                     @NotNull PlatformFacade platformFacade) {
+                                                     @NotNull IdeModifiableModelsProvider modelsProvider) {
    return EMPTY_LIST;
  }

@@ -62,23 +61,6 @@ public abstract class AbstractProjectDataService<E, I> implements ProjectDataSer
                         @NotNull Collection<DataNode<E>> toIgnore,
                         @NotNull ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
-  }
-
-  /**
-   * @deprecated to be removed in v15
-   */
-  @Deprecated
-  @Override
-  public void importData(@NotNull Collection<DataNode<E>> toImport, @NotNull Project project, boolean synchronous) {
-  }
-
-  /**
-   * @deprecated to be removed in v15
-   */
-  @Deprecated
-  @Override
-  public void removeData(@NotNull Collection<? extends I> toRemove, @NotNull Project project, boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
  }
 }
@@ -18,9 +18,13 @@ package com.intellij.openapi.externalSystem.service.project.manage;
 import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.Key;
+import com.intellij.openapi.externalSystem.model.project.ProjectData;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.Order;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

 import java.util.Collection;

@@ -75,9 +79,20 @@ public interface ProjectDataService<E, I> {
   * 
   * @param toImport
   * @param project
-   * @param synchronous
   */
-  void importData(@NotNull Collection<DataNode<E>> toImport, @NotNull Project project, boolean synchronous);
+  void importData(@NotNull Collection<DataNode<E>> toImport,
+                  @Nullable ProjectData projectData,
+                  @NotNull Project project,
+                  @NotNull IdeModifiableModelsProvider modelsProvider);
+
+  /**
+   * Compute orphan data.
+   */
+  @NotNull
+  Computable<Collection<I>> computeOrphanData(@NotNull Collection<DataNode<E>> toImport,
+                                              @NotNull ProjectData projectData,
+                                              @NotNull Project project,
+                                              @NotNull IdeModifiableModelsProvider modelsProvider);

  /**
   * Asks to remove all given ide project entities.
@@ -88,7 +103,10 @@ public interface ProjectDataService<E, I> {
   * 
   * @param toRemove     project entities to remove
   * @param project      target project
-   * @param synchronous  flag which defines if entities removal should be synchronous
   */
-  void removeData(@NotNull Collection<? extends I> toRemove, @NotNull Project project, boolean synchronous);
+  void removeData(@NotNull Computable<Collection<I>> toRemove,
+                  @NotNull Collection<DataNode<E>> toIgnore,
+                  @NotNull ProjectData projectData,
+                  @NotNull Project project,
+                  @NotNull IdeModifiableModelsProvider modelsProvider);
 }
@@ -1,52 +0,0 @@
-/*
- * Copyright 2000-2015 JetBrains s.r.o.
- *
- * 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
- *
- * http://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 com.intellij.openapi.externalSystem.service.project.manage;
-
-import com.intellij.openapi.externalSystem.model.DataNode;
-import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Computable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-
-/**
- * @author Vladislav.Soroka
- * @since 4/13/2015
- */
-public interface ProjectDataServiceEx<E, I> extends ProjectDataService<E, I> {
-
-  void importData(@NotNull Collection<DataNode<E>> toImport,
-                  @Nullable ProjectData projectData,
-                  @NotNull Project project,
-                  @NotNull PlatformFacade platformFacade,
-                  boolean synchronous);
-
-  @NotNull
-  Computable<Collection<I>> computeOrphanData(@NotNull Collection<DataNode<E>> toImport,
-                                              @NotNull ProjectData projectData,
-                                              @NotNull Project project,
-                                              @NotNull PlatformFacade platformFacade);
-
-  void removeData(@NotNull Computable<Collection<I>> toRemove,
-                  @NotNull Collection<DataNode<E>> toIgnore,
-                  @NotNull ProjectData projectData,
-                  @NotNull Project project,
-                  @NotNull PlatformFacade platformFacade,
-                  boolean synchronous);
-}
@@ -21,11 +21,11 @@ import com.intellij.openapi.externalSystem.model.execution.ExternalTaskExecution
 import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo;
 import com.intellij.openapi.externalSystem.model.project.ExternalProjectBuildClasspathPojo;
 import com.intellij.openapi.externalSystem.model.project.ExternalProjectPojo;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.view.ExternalProjectsViewState;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.util.SystemProperties;
 import com.intellij.util.containers.ContainerUtilRt;
@@ -80,15 +80,12 @@ public abstract class AbstractExternalSystemLocalSettings {

  @NotNull private final ProjectSystemId myExternalSystemId;
  @NotNull private final Project         myProject;
-  @NotNull private final PlatformFacade  myPlatformFacade;

  protected AbstractExternalSystemLocalSettings(@NotNull ProjectSystemId externalSystemId,
-                                                @NotNull Project project,
-                                                @NotNull PlatformFacade facade)
+                                                @NotNull Project project)
  {
    myExternalSystemId = externalSystemId;
    myProject = project;
-    myPlatformFacade = facade;
  }

  /**
@@ -254,7 +251,7 @@ public abstract class AbstractExternalSystemLocalSettings {
    for (ExternalProjectSettings projectSettings : settings.getLinkedProjectsSettings()) {
      pathsToForget.remove(projectSettings.getExternalProjectPath());
    }
-    for (Module module : myPlatformFacade.getModules(myProject)) {
+    for (Module module : ModuleManager.getInstance(myProject).getModules()) {
      String id = module.getOptionValue(ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY);
      if (!myExternalSystemId.toString().equals(id)) {
        continue;
@@ -21,7 +21,6 @@ import com.intellij.openapi.application.Application;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.ExternalSystemAutoImportAware;
 import com.intellij.openapi.externalSystem.ExternalSystemManager;
@@ -32,13 +31,13 @@ import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.model.settings.ExternalSystemExecutionSettings;
 import com.intellij.openapi.externalSystem.service.ParametersEnhancer;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemLocalSettings;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemSettings;
 import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
 import com.intellij.openapi.externalSystem.settings.ExternalSystemSettingsListener;
 import com.intellij.openapi.fileTypes.FileTypes;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.OrderRootType;
@@ -501,7 +500,7 @@ public class ExternalSystemApiUtil {
  }

  public static void executeProjectChangeAction(@NotNull final DisposeAwareProjectChange task) {
-    executeProjectChangeAction(false, task);
+    executeProjectChangeAction(true, task);
  }

  public static void executeProjectChangeAction(boolean synchronous, @NotNull final DisposeAwareProjectChange task) {
@@ -660,8 +659,7 @@ public class ExternalSystemApiUtil {
    }
    externalModulePaths.remove(linkedExternalProjectPath);

-    PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class);
-    for (Module module : platformFacade.getModules(ideProject)) {
+    for (Module module : ModuleManager.getInstance(ideProject).getModules()) {
      String path = getExternalProjectPath(module);
      if (!StringUtil.isEmpty(path) && !externalModulePaths.remove(path)) {
        return false;
@@ -670,6 +668,8 @@ public class ExternalSystemApiUtil {
    return externalModulePaths.isEmpty();
  }

+
+
  public static void storeLastUsedExternalProjectPath(@Nullable String path, @NotNull ProjectSystemId externalSystemId) {
    if (path != null) {
      PropertiesComponent.getInstance().setValue(LAST_USED_PROJECT_PATH_PREFIX + externalSystemId.getReadableName(), path);
@@ -24,7 +24,7 @@
    <orderEntry type="library" scope="TEST" name="JUnit4" level="project" />
    <orderEntry type="module" module-name="testFramework" scope="TEST" />
    <orderEntry type="module" module-name="testFramework-java" scope="TEST" />
-    <orderEntry type="module" module-name="compiler-impl" scope="TEST" />
+    <orderEntry type="module" module-name="compiler-impl" />
    <orderEntry type="module" module-name="java-impl" />
    <orderEntry type="module" module-name="openapi" />
  </component>
@@ -37,7 +37,7 @@ import com.intellij.projectImport.ProjectImportProvider;
 * @author Denis Zhdanov
 * @since 6/14/13 1:28 PM
 */
-public class AttachExternalProjectAction extends AnAction implements DumbAware {
+public class AttachExternalProjectAction extends AnAction {

  public AttachExternalProjectAction() {
    getTemplatePresentation().setText(ExternalSystemBundle.message("action.attach.external.project.text", "external"));
@@ -17,20 +17,19 @@ package com.intellij.openapi.externalSystem.action;

 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.actionSystem.AnActionEvent;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.ExternalSystemDataKeys;
 import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.ProjectSystemId;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
 import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManager;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemBundle;
 import com.intellij.openapi.externalSystem.view.ProjectNode;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.SystemInfoRt;
@@ -44,7 +43,7 @@ import java.util.List;
 * @author Denis Zhdanov
 * @since 6/13/13 5:42 PM
 */
-public class DetachExternalProjectAction extends ExternalSystemNodeAction<ProjectData> implements DumbAware {
+public class DetachExternalProjectAction extends ExternalSystemNodeAction<ProjectData> {

  public DetachExternalProjectAction() {
    super(ProjectData.class);
@@ -79,9 +78,8 @@ public class DetachExternalProjectAction extends ExternalSystemNodeAction<Projec
    ExternalProjectsManager.getInstance(project).forgetExternalProjectData(projectSystemId, projectData.getLinkedExternalProjectPath());

    // Process orphan modules.
-    PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class);
    List<Module> orphanModules = ContainerUtilRt.newArrayList();
-    for (Module module : platformFacade.getModules(project)) {
+    for (Module module : ModuleManager.getInstance(project).getModules()) {
      if (!ExternalSystemApiUtil.isExternalSystemAwareModule(projectSystemId, module)) continue;

      String path = ExternalSystemApiUtil.getExternalRootProjectPath(module);
@@ -27,7 +27,7 @@ import java.util.List;
 * @author Denis Zhdanov
 * @since 1/23/12 3:48 PM
 */
-public class RefreshAllExternalProjectsAction extends AnAction implements DumbAware, AnAction.TransparentUpdate {
+public class RefreshAllExternalProjectsAction extends AnAction implements AnAction.TransparentUpdate {

  public RefreshAllExternalProjectsAction() {
    getTemplatePresentation().setText(ExternalSystemBundle.message("action.refresh.all.projects.text", "external"));
@@ -22,13 +22,13 @@ import org.jetbrains.annotations.NotNull;
 import java.util.List;

 /**
- * * Forces the ide to retrieve the most up-to-date info about the linked external project and updates project state if necessary
+ * Forces the ide to retrieve the most up-to-date info about the linked external project and updates project state if necessary
 * (e.g. imports missing libraries).
 *
 * @author Vladislav.Soroka
 * @since 9/18/13
 */
-public class RefreshExternalProjectAction extends ExternalSystemNodeAction<AbstractExternalEntityData> implements DumbAware {
+public class RefreshExternalProjectAction extends ExternalSystemNodeAction<AbstractExternalEntityData> {

  public RefreshExternalProjectAction() {
    super(AbstractExternalEntityData.class);
@@ -0,0 +1,428 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 com.intellij.openapi.externalSystem.service.project;
+
+import com.intellij.facet.Facet;
+import com.intellij.facet.FacetModel;
+import com.intellij.facet.FacetTypeId;
+import com.intellij.facet.ModifiableFacetModel;
+import com.intellij.openapi.application.ModalityState;
+import com.intellij.openapi.externalSystem.model.project.*;
+import com.intellij.openapi.module.ModifiableModuleModel;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
+import com.intellij.openapi.roots.impl.ModifiableModelCommitter;
+import com.intellij.openapi.roots.impl.ModuleRootManagerImpl;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.libraries.LibraryTable;
+import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
+import com.intellij.openapi.roots.ui.configuration.FacetsProvider;
+import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
+import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.packaging.artifacts.ArtifactModel;
+import com.intellij.packaging.artifacts.ModifiableArtifactModel;
+import com.intellij.packaging.elements.ManifestFileProvider;
+import com.intellij.packaging.elements.PackagingElementResolvingContext;
+import com.intellij.packaging.impl.artifacts.DefaultManifestFileProvider;
+import com.intellij.util.containers.ContainerUtil;
+import gnu.trove.THashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil.*;
+
+public abstract class AbstractIdeModifiableModelsProvider implements IdeModifiableModelsProvider {
+  @NotNull
+  protected final Project myProject;
+  private ModifiableModuleModel myModifiableModuleModel;
+  private Map<Module, ModifiableRootModel> myModifiableRootModels = new THashMap<Module, ModifiableRootModel>();
+  private Map<Module, ModifiableFacetModel> myModifiableFacetModels = new THashMap<Module, ModifiableFacetModel>();
+  private Map<Library, Library.ModifiableModel> myModifiableLibraryModels = new IdentityHashMap<Library, Library.ModifiableModel>();
+  private ModifiableArtifactModel myModifiableArtifactModel;
+  private AbstractIdeModifiableModelsProvider.MyPackagingElementResolvingContext myPackagingElementResolvingContext;
+  private final ArtifactExternalDependenciesImporter myArtifactExternalDependenciesImporter;
+
+  public AbstractIdeModifiableModelsProvider(@NotNull Project project) {
+    myProject = project;
+    myArtifactExternalDependenciesImporter = new ArtifactExternalDependenciesImporterImpl();
+  }
+
+  protected abstract ModifiableArtifactModel doGetModifiableArtifactModel();
+
+  protected abstract ModifiableModuleModel doGetModifiableModuleModel();
+
+  protected abstract ModifiableRootModel doGetModifiableRootModel(Module module);
+
+  protected abstract ModifiableFacetModel doGetModifiableFacetModel(Module module);
+
+  protected abstract Library.ModifiableModel doGetModifiableLibraryModel(Library library);
+
+  @NotNull
+  @Override
+  public abstract LibraryTable.ModifiableModel getModifiableProjectLibrariesModel();
+
+  @NotNull
+  @Override
+  public Module[] getModules() {
+    return myModifiableModuleModel == null ? ModuleManager.getInstance(myProject).getModules() : getModifiableModuleModel().getModules();
+  }
+
+  @NotNull
+  @Override
+  public Module[] getModules(@NotNull final ProjectData projectData) {
+    final List<Module> modules = ContainerUtil.filter(getModules(), new Condition<Module>() {
+      @Override
+      public boolean value(Module module) {
+        return isExternalSystemAwareModule(projectData.getOwner(), module) &&
+               StringUtil.equals(projectData.getLinkedExternalProjectPath(), getExternalRootProjectPath(module));
+      }
+    });
+    return ContainerUtil.toArray(modules, new Module[modules.size()]);
+  }
+
+  protected void processExternalArtifactDependencies() {
+    myArtifactExternalDependenciesImporter.applyChanges(getModifiableArtifactModel(), getPackagingElementResolvingContext());
+  }
+
+  @Override
+  public PackagingElementResolvingContext getPackagingElementResolvingContext() {
+    if (myPackagingElementResolvingContext == null) {
+      myPackagingElementResolvingContext = new MyPackagingElementResolvingContext();
+    }
+    return myPackagingElementResolvingContext;
+  }
+
+  @NotNull
+  @Override
+  public OrderEntry[] getOrderEntries(@NotNull Module module) {
+    return getRootModel(module, false).getOrderEntries();
+  }
+
+  @NotNull
+  @Override
+  public Module newModule(@NotNull final String filePath, final String moduleTypeId) {
+    Module module = getModifiableModuleModel().newModule(filePath, moduleTypeId);
+    // set module type id explicitly otherwise it can not be set if there is an existing module (with the same filePath) and w/o 'type' attribute
+    module.setOption(Module.ELEMENT_TYPE, moduleTypeId);
+    return module;
+  }
+
+  @Nullable
+  @Override
+  public Module findIdeModule(@NotNull ModuleData module) {
+    final Module ideModule = findIdeModule(module.getInternalName());
+    return isExternalSystemAwareModule(module.getOwner(), ideModule) ? ideModule : null;
+  }
+
+  @Nullable
+  @Override
+  public Module findIdeModule(@NotNull String ideModuleName) {
+    for (Module module : getModules()) {
+      if (ideModuleName.equals(module.getName())) {
+        return module;
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public Library findIdeLibrary(@NotNull LibraryData libraryData) {
+    final LibraryTable.ModifiableModel libraryTable = getModifiableProjectLibrariesModel();
+    for (Library ideLibrary : libraryTable.getLibraries()) {
+      if (isRelated(ideLibrary, libraryData)) return ideLibrary;
+    }
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public ModuleOrderEntry findIdeModuleDependency(@NotNull ModuleDependencyData dependency, @NotNull Module module) {
+    for (OrderEntry entry : getRootModel(module, false).getOrderEntries()) {
+      if (entry instanceof ModuleOrderEntry) {
+        ModuleOrderEntry candidate = (ModuleOrderEntry)entry;
+        if (dependency.getInternalName().equals(candidate.getModuleName()) && dependency.getScope().equals(candidate.getScope())) {
+          return candidate;
+        }
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public OrderEntry findIdeModuleOrderEntry(LibraryDependencyData data) {
+    Module ownerIdeModule = findIdeModule(data.getOwnerModule());
+    if (ownerIdeModule == null) return null;
+    for (OrderEntry entry : getOrderEntries(ownerIdeModule)) {
+      if (entry instanceof LibraryOrderEntry) {
+        if (((LibraryOrderEntry)entry).isModuleLevel() && data.getLevel() != LibraryLevel.MODULE) continue;
+      }
+
+      if (data.getInternalName().equals(entry.getPresentableName())) {
+        return entry;
+      }
+    }
+    return null;
+  }
+
+  @Override
+  @NotNull
+  public VirtualFile[] getContentRoots(Module module) {
+    return getRootModel(module, false).getContentRoots();
+  }
+
+  @NotNull
+  @Override
+  public ModifiableModuleModel getModifiableModuleModel() {
+    if (myModifiableModuleModel == null) {
+      myModifiableModuleModel = doGetModifiableModuleModel();
+    }
+    return myModifiableModuleModel;
+  }
+
+  @Override
+  @NotNull
+  public ModifiableRootModel getModifiableRootModel(Module module) {
+    return (ModifiableRootModel)getRootModel(module, true);
+  }
+
+  @NotNull
+  private ModuleRootModel getRootModel(Module module, boolean modifiableModelNeeded) {
+    ModifiableRootModel result = myModifiableRootModels.get(module);
+    if (result == null) {
+      if (!modifiableModelNeeded) return ModuleRootManager.getInstance(module);
+      result = doGetModifiableRootModel(module);
+      myModifiableRootModels.put(module, result);
+    }
+    return result;
+  }
+
+  @Override
+  @NotNull
+  public ModifiableFacetModel getModifiableFacetModel(Module module) {
+    ModifiableFacetModel result = myModifiableFacetModels.get(module);
+    if (result == null) {
+      result = doGetModifiableFacetModel(module);
+      myModifiableFacetModels.put(module, result);
+    }
+    return result;
+  }
+
+  @Override
+  @NotNull
+  public ModifiableArtifactModel getModifiableArtifactModel() {
+    if (myModifiableArtifactModel == null) {
+      myModifiableArtifactModel = doGetModifiableArtifactModel();
+    }
+    return myModifiableArtifactModel;
+  }
+
+  @Override
+  @NotNull
+  public Library[] getAllLibraries() {
+    return getModifiableProjectLibrariesModel().getLibraries();
+  }
+
+  @Override
+  @Nullable
+  public Library getLibraryByName(String name) {
+    return getModifiableProjectLibrariesModel().getLibraryByName(name);
+  }
+
+  @Override
+  public Library createLibrary(String name) {
+    return getModifiableProjectLibrariesModel().createLibrary(name);
+  }
+
+  @Override
+  public void removeLibrary(Library library) {
+    getModifiableProjectLibrariesModel().removeLibrary(library);
+  }
+
+  @Override
+  public Library.ModifiableModel getModifiableLibraryModel(Library library) {
+    Library.ModifiableModel result = myModifiableLibraryModels.get(library);
+    if (result == null) {
+      result = doGetModifiableLibraryModel(library);
+      myModifiableLibraryModels.put(library, result);
+    }
+    return result;
+  }
+
+  @NotNull
+  @Override
+  public String[] getLibraryUrls(@NotNull Library library, @NotNull OrderRootType type) {
+    final Library.ModifiableModel model = myModifiableLibraryModels.get(library);
+    if (model != null) {
+      return model.getUrls(type);
+    }
+    return library.getUrls(type);
+  }
+
+  @Override
+  public ModalityState getModalityStateForQuestionDialogs() {
+    return ModalityState.NON_MODAL;
+  }
+
+  @Override
+  public ArtifactExternalDependenciesImporter getArtifactExternalDependenciesImporter() {
+    return myArtifactExternalDependenciesImporter;
+  }
+
+  private class MyPackagingElementResolvingContext implements PackagingElementResolvingContext {
+    private final ModulesProvider myModulesProvider = new MyModulesProvider();
+    private final MyFacetsProvider myFacetsProvider = new MyFacetsProvider();
+    private final ManifestFileProvider myManifestFileProvider = new DefaultManifestFileProvider(this);
+
+    @NotNull
+    public Project getProject() {
+      return myProject;
+    }
+
+    @NotNull
+    public ArtifactModel getArtifactModel() {
+      return AbstractIdeModifiableModelsProvider.this.getModifiableArtifactModel();
+    }
+
+    @NotNull
+    public ModulesProvider getModulesProvider() {
+      return myModulesProvider;
+    }
+
+    @NotNull
+    public FacetsProvider getFacetsProvider() {
+      return myFacetsProvider;
+    }
+
+    public Library findLibrary(@NotNull String level, @NotNull String libraryName) {
+      if (level.equals(LibraryTablesRegistrar.PROJECT_LEVEL)) {
+        return getLibraryByName(libraryName);
+      }
+      final LibraryTable table = LibraryTablesRegistrar.getInstance().getLibraryTableByLevel(level, myProject);
+      return table != null ? table.getLibraryByName(libraryName) : null;
+    }
+
+    @NotNull
+    @Override
+    public ManifestFileProvider getManifestFileProvider() {
+      return myManifestFileProvider;
+    }
+  }
+
+  private class MyModulesProvider implements ModulesProvider {
+    @NotNull
+    public Module[] getModules() {
+      return AbstractIdeModifiableModelsProvider.this.getModules();
+    }
+
+    public Module getModule(String name) {
+      return AbstractIdeModifiableModelsProvider.this.findIdeModule(name);
+    }
+
+    public ModuleRootModel getRootModel(@NotNull Module module) {
+      return AbstractIdeModifiableModelsProvider.this.getModifiableRootModel(module);
+    }
+
+    public FacetModel getFacetModel(@NotNull Module module) {
+      return AbstractIdeModifiableModelsProvider.this.getModifiableFacetModel(module);
+    }
+  }
+
+  private class MyFacetsProvider implements FacetsProvider {
+    @NotNull
+    public Facet[] getAllFacets(Module module) {
+      return getModifiableFacetModel(module).getAllFacets();
+    }
+
+    @NotNull
+    public <F extends Facet> Collection<F> getFacetsByType(Module module, FacetTypeId<F> type) {
+      return getModifiableFacetModel(module).getFacetsByType(type);
+    }
+
+    public <F extends Facet> F findFacet(Module module, FacetTypeId<F> type, String name) {
+      return getModifiableFacetModel(module).findFacet(type, name);
+    }
+  }
+
+  @Override
+  public void commit() {
+    ((ProjectRootManagerEx)ProjectRootManager.getInstance(myProject)).mergeRootsChangesDuring(new Runnable() {
+      public void run() {
+        processExternalArtifactDependencies();
+        for (Library.ModifiableModel each : myModifiableLibraryModels.values()) {
+          each.commit();
+        }
+        getModifiableProjectLibrariesModel().commit();
+
+        Collection<ModifiableRootModel> rootModels = myModifiableRootModels.values();
+        ModifiableRootModel[] rootModels1 = rootModels.toArray(new ModifiableRootModel[rootModels.size()]);
+        for (ModifiableRootModel model : rootModels1) {
+          assert !model.isDisposed() : "Already disposed: " + model;
+        }
+
+        if (myModifiableModuleModel != null) {
+          ModifiableModelCommitter.multiCommit(rootModels1, myModifiableModuleModel);
+        } else {
+          for (ModifiableRootModel model : rootModels1) {
+            model.commit();
+          }
+        }
+
+        for (Map.Entry<Module, ModifiableFacetModel> each : myModifiableFacetModels.entrySet()) {
+          if(!each.getKey().isDisposed()) {
+            each.getValue().commit();
+          }
+        }
+        if (myModifiableArtifactModel != null) {
+          myModifiableArtifactModel.commit();
+        }
+      }
+    });
+  }
+
+  @Override
+  public void dispose() {
+    for (ModifiableRootModel each : myModifiableRootModels.values()) {
+      if (each.isDisposed()) continue;
+      each.dispose();
+    }
+
+    for (Library.ModifiableModel each : myModifiableLibraryModels.values()) {
+      Disposer.dispose(each);
+    }
+
+    myModifiableModuleModel.dispose();
+    if (myModifiableArtifactModel != null) {
+      myModifiableArtifactModel.dispose();
+    }
+
+    myModifiableRootModels.clear();
+    myModifiableFacetModels.clear();
+    myModifiableLibraryModels.clear();
+  }
+}
@@ -13,7 +13,7 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-package org.jetbrains.idea.maven.importing;
+package com.intellij.openapi.externalSystem.service.project;

 import com.intellij.openapi.roots.ui.configuration.artifacts.ManifestFilesInfo;
 import com.intellij.openapi.util.Pair;
@@ -39,16 +39,18 @@ import java.util.Map;
 /**
 * @author nik
 */
-public class ArtifactExternalDependenciesImporter {
+public class ArtifactExternalDependenciesImporterImpl implements ArtifactExternalDependenciesImporter {
  private final ManifestFilesInfo myManifestFiles = new ManifestFilesInfo();
  private final Map<Artifact, List<PackagingElement<?>>> myExternalDependencies = new HashMap<Artifact, List<PackagingElement<?>>>();

  @Nullable
+  @Override
  public ManifestFileConfiguration getManifestFile(@NotNull Artifact artifact,
                                                   @NotNull PackagingElementResolvingContext context) {
    return myManifestFiles.getManifestFile(artifact.getRootElement(), artifact.getArtifactType(), context);
  }

+  @Override
  public List<PackagingElement<?>> getExternalDependenciesList(@NotNull Artifact artifact) {
    List<PackagingElement<?>> elements = myExternalDependencies.get(artifact);
    if (elements == null) {
@@ -58,6 +60,7 @@ public class ArtifactExternalDependenciesImporter {
    return elements;
  }

+  @Override
  public void applyChanges(ModifiableArtifactModel artifactModel, final PackagingElementResolvingContext context) {
    myManifestFiles.saveManifestFiles();
    final List<Pair<? extends CompositePackagingElement<?>, List<PackagingElement<?>>>> elementsToInclude =
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2000-2015 JetBrains s.r.o.
+ *
+ * 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
+ *
+ * http://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 com.intellij.openapi.externalSystem.service.project;
+
+import com.intellij.facet.FacetManager;
+import com.intellij.facet.ModifiableFacetModel;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.module.ModifiableModuleModel;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.ModuleRootManager;
+import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.libraries.LibraryTable;
+import com.intellij.openapi.util.Computable;
+import com.intellij.packaging.artifacts.ArtifactManager;
+import com.intellij.packaging.artifacts.ModifiableArtifactModel;
+import org.jetbrains.annotations.NotNull;
+
+public class IdeModifiableModelsProviderImpl extends AbstractIdeModifiableModelsProvider {
+
+  private final LibraryTable.ModifiableModel myLibrariesModel;
+
+  public IdeModifiableModelsProviderImpl(Project project) {
+    super(project);
+    myLibrariesModel = ProjectLibraryTable.getInstance(myProject).getModifiableModel();
+  }
+
+  @NotNull
+  @Override
+  public LibraryTable.ModifiableModel getModifiableProjectLibrariesModel() {
+    return myLibrariesModel;
+  }
+
+  @Override
+  protected ModifiableArtifactModel doGetModifiableArtifactModel() {
+    return ApplicationManager.getApplication().runReadAction(new Computable<ModifiableArtifactModel>() {
+      @Override
+      public ModifiableArtifactModel compute() {
+        return ArtifactManager.getInstance(myProject).createModifiableModel();
+      }
+    });
+  }
+
+  @Override
+  protected ModifiableModuleModel doGetModifiableModuleModel() {
+    return ApplicationManager.getApplication().runReadAction(new Computable<ModifiableModuleModel>() {
+      @Override
+      public ModifiableModuleModel compute() {
+        return ModuleManager.getInstance(myProject).getModifiableModel();
+      }
+    });
+  }
+
+  @Override
+  @NotNull
+  protected ModifiableRootModel doGetModifiableRootModel(@NotNull final Module module) {
+    return ApplicationManager.getApplication().runReadAction(new Computable<ModifiableRootModel>() {
+      @Override
+      public ModifiableRootModel compute() {
+        return ModuleRootManager.getInstance(module).getModifiableModel();
+      }
+    });
+  }
+
+  @Override
+  protected ModifiableFacetModel doGetModifiableFacetModel(Module module) {
+    return FacetManager.getInstance(module).createModifiableModel();
+  }
+
+  @Override
+  protected Library.ModifiableModel doGetModifiableLibraryModel(Library library) {
+    return library.getModifiableModel();
+  }
+}
@@ -13,7 +13,7 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-package org.jetbrains.idea.maven.importing;
+package com.intellij.openapi.externalSystem.service.project;

 import com.intellij.facet.ModifiableFacetModel;
 import com.intellij.openapi.application.ModalityState;
@@ -27,18 +27,18 @@ import com.intellij.openapi.roots.ui.configuration.ModulesConfigurator;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesModifiableModel;
 import com.intellij.openapi.roots.ui.configuration.projectRoot.ProjectLibrariesConfigurable;
 import com.intellij.packaging.artifacts.ModifiableArtifactModel;
-import org.jetbrains.idea.maven.utils.MavenUtil;
+import org.jetbrains.annotations.NotNull;

-public class MavenUIModifiableModelsProvider extends MavenBaseModifiableModelsProvider {
+public class IdeUIModifiableModelsProvider extends AbstractIdeModifiableModelsProvider {
  private final ModifiableModuleModel myModel;
  private final ModulesConfigurator myModulesConfigurator;
  private final ModifiableArtifactModel myModifiableArtifactModel;
  private final LibrariesModifiableModel myLibrariesModel;

-  public MavenUIModifiableModelsProvider(Project project,
-                                         ModifiableModuleModel model,
-                                         ModulesConfigurator modulesConfigurator,
-                                         ModifiableArtifactModel modifiableArtifactModel) {
+  public IdeUIModifiableModelsProvider(Project project,
+                                       ModifiableModuleModel model,
+                                       ModulesConfigurator modulesConfigurator,
+                                       ModifiableArtifactModel modifiableArtifactModel) {
    super(project);
    myModel = model;
    myModulesConfigurator = modulesConfigurator;
@@ -48,49 +48,34 @@ public class MavenUIModifiableModelsProvider extends MavenBaseModifiableModelsPr
    myLibrariesModel = configurable.getModelProvider().getModifiableModel();
  }

+  @NotNull
  @Override
-  protected ModifiableArtifactModel doGetArtifactModel() {
+  public LibraryTable.ModifiableModel getModifiableProjectLibrariesModel() {
+    return myLibrariesModel;
+  }
+
+  @Override
+  protected ModifiableArtifactModel doGetModifiableArtifactModel() {
    return myModifiableArtifactModel;
  }

  @Override
-  protected ModifiableModuleModel doGetModuleModel() {
+  protected ModifiableModuleModel doGetModifiableModuleModel() {
    return myModel;
  }

  @Override
-  protected ModifiableRootModel doGetRootModel(Module module) {
+  protected ModifiableRootModel doGetModifiableRootModel(Module module) {
    return myModulesConfigurator.getOrCreateModuleEditor(module).getModifiableRootModel();
  }

  @Override
-  protected ModifiableFacetModel doGetFacetModel(Module module) {
+  protected ModifiableFacetModel doGetModifiableFacetModel(Module module) {
    return (ModifiableFacetModel)myModulesConfigurator.getFacetModel(module);
  }

  @Override
-  public LibraryTable.ModifiableModel getProjectLibrariesModel() {
-    return myLibrariesModel;
-  }
-
-  public Library[] getAllLibraries() {
-    return myLibrariesModel.getLibraries();
-  }
-
-  public Library getLibraryByName(String name) {
-    return myLibrariesModel.getLibraryByName(name);
-  }
-
-  public Library createLibrary(String name) {
-    return myLibrariesModel.createLibrary(name);
-  }
-
-  public void removeLibrary(Library library) {
-    myLibrariesModel.removeLibrary(library);
-  }
-
-  @Override
-  protected Library.ModifiableModel doGetLibraryModel(Library library) {
+  protected Library.ModifiableModel doGetModifiableLibraryModel(Library library) {
    return myLibrariesModel.getLibraryModifiableModel(library);
  }

@@ -1,250 +0,0 @@
-package com.intellij.openapi.externalSystem.service.project;
-
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.externalSystem.model.project.*;
-import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.*;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
-import com.intellij.openapi.util.Computable;
-import com.intellij.openapi.util.Condition;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.Consumer;
-import com.intellij.util.ExceptionUtil;
-import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-import static com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil.*;
-
-/**
- * @author Denis Zhdanov
- * @since 1/26/12 11:54 AM
- */
-public class PlatformFacadeImpl implements PlatformFacade {
-
-  @NotNull
-  @Override
-  public LibraryTable getProjectLibraryTable(@NotNull Project project) {
-    return LibraryTablesRegistrar.getInstance().getLibraryTable(project);
-  }
-
-  @NotNull
-  @Override
-  public Collection<Module> getModules(@NotNull Project project) {
-    return Arrays.asList(ModuleManager.getInstance(project).getModules());
-  }
-
-  @NotNull
-  @Override
-  public Collection<Module> getModules(@NotNull Project project, @NotNull final ProjectData projectData) {
-    return ContainerUtil.filter(getModules(project), new Condition<Module>() {
-      @Override
-      public boolean value(Module module) {
-        return isExternalSystemAwareModule(projectData.getOwner(), module) &&
-               StringUtil.equals(projectData.getLinkedExternalProjectPath(), getExternalRootProjectPath(module));
-      }
-    });
-  }
-
-  @NotNull
-  @Override
-  public Collection<OrderEntry> getOrderEntries(@NotNull Module module) {
-    return Arrays.asList(ModuleRootManager.getInstance(module).getOrderEntries());
-  }
-
-  @NotNull
-  @Override
-  public String getLocalFileSystemPath(@NotNull VirtualFile file) {
-    return ExternalSystemApiUtil.getLocalFileSystemPath(file);
-  }
-
-  @Override
-  public Module newModule(Project project, @NotNull @NonNls final String filePath, final String moduleTypeId) {
-    final ModuleManager moduleManager = ModuleManager.getInstance(project);
-    Module module = doWriteAction(new Computable<Module>() {
-      @Override
-      public Module compute() {
-        return moduleManager.newModule(filePath, moduleTypeId);
-      }
-    });
-    // set module type id explicitly otherwise it can not be set if there is an existing module (with the same filePath) and w/o 'type' attribute
-    module.setOption(Module.ELEMENT_TYPE, moduleTypeId);
-    return module;
-  }
-
-  @Override
-  public ModifiableRootModel getModuleModifiableModel(Module module) {
-    final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
-    return ApplicationManager.getApplication().runReadAction(new Computable<ModifiableRootModel>() {
-      @Override
-      public ModifiableRootModel compute() {
-        return moduleRootManager.getModifiableModel();
-      }
-    });
-  }
-
-  @Nullable
-  @Override
-  public Module findIdeModule(@NotNull ModuleData module, @NotNull Project ideProject) {
-    final Module ideModule = findIdeModule(module.getInternalName(), ideProject);
-    return isExternalSystemAwareModule(module.getOwner(), ideModule) ? ideModule : null;
-  }
-
-  @Nullable
-  @Override
-  public Module findIdeModule(@NotNull String ideModuleName, @NotNull Project ideProject) {
-    for (Module module : getModules(ideProject)) {
-      if (ideModuleName.equals(module.getName())) {
-        return module;
-      }
-    }
-    return null;
-  }
-
-  @Nullable
-  @Override
-  public Library findIdeLibrary(@NotNull final LibraryData libraryData, @NotNull Project ideProject) {
-    final LibraryTable libraryTable = getProjectLibraryTable(ideProject);
-    for (Library ideLibrary : libraryTable.getLibraries()) {
-      if (isRelated(ideLibrary, libraryData)) return ideLibrary;
-    }
-    return null;
-  }
-
-  public boolean isOrphanProjectLibrary(@NotNull final Library library,
-                                               @NotNull final Iterable<Module> ideModules) {
-    RootPolicy<Boolean> visitor = new RootPolicy<Boolean>() {
-      @Override
-      public Boolean visitLibraryOrderEntry(LibraryOrderEntry ideDependency, Boolean value) {
-        return !ideDependency.isModuleLevel() && library == ideDependency.getLibrary();
-      }
-    };
-    for (Module module : ideModules) {
-      for (OrderEntry entry : ModuleRootManager.getInstance(module).getOrderEntries()) {
-        if (entry.accept(visitor, false)) return false;
-      }
-    }
-    return true;
-  }
-
-  @SuppressWarnings("MethodMayBeStatic")
-  @Nullable
-  @Override
-  public ModuleOrderEntry findIdeModuleDependency(@NotNull ModuleDependencyData dependency, @NotNull ModifiableRootModel model) {
-    for (OrderEntry entry : model.getOrderEntries()) {
-      if (entry instanceof ModuleOrderEntry) {
-        ModuleOrderEntry candidate = (ModuleOrderEntry)entry;
-        if (dependency.getInternalName().equals(candidate.getModuleName()) &&
-            dependency.getScope().equals(candidate.getScope())) {
-          return candidate;
-        }
-      }
-    }
-    return null;
-  }
-
-  @Nullable
-  @Override
-  public OrderEntry findIdeModuleOrderEntry(LibraryDependencyData data, Project project) {
-    Module ownerIdeModule = findIdeModule(data.getOwnerModule(), project);
-    if (ownerIdeModule == null) return null;
-
-    ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(ownerIdeModule);
-
-    for (OrderEntry entry : moduleRootManager.getOrderEntries()) {
-      if (entry instanceof LibraryOrderEntry) {
-        if (((LibraryOrderEntry)entry).isModuleLevel() && data.getLevel() != LibraryLevel.MODULE) continue;
-      }
-
-      if (data.getInternalName().equals(entry.getPresentableName())) {
-        return entry;
-      }
-    }
-    return null;
-  }
-
-  @Override
-  public void updateModule(@NotNull final Module module, @NotNull Consumer<ModifiableRootModel> task) {
-    final ModifiableModelsProvider modifiableModelsProvider = ModifiableModelsProvider.SERVICE.getInstance();
-    final ModifiableRootModel modifiableRootModel =
-      ApplicationManager.getApplication().runReadAction(new Computable<ModifiableRootModel>() {
-        @Override
-        public ModifiableRootModel compute() {
-          return modifiableModelsProvider.getModuleModifiableModel(module);
-        }
-      });
-    try {
-      task.consume(modifiableRootModel);
-      if (modifiableRootModel.isChanged()) {
-        doWriteAction(new Runnable() {
-          @Override
-          public void run() {
-            modifiableModelsProvider.commitModuleModifiableModel(modifiableRootModel);
-          }
-        });
-      }
-      else {
-        modifiableRootModel.dispose();
-      }
-    }
-    catch (Throwable t) {
-      modifiableModelsProvider.disposeModuleModifiableModel(modifiableRootModel);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
-    }
-  }
-
-  @Override
-  public void updateLibraryTable(@NotNull final Project project, @NotNull Consumer<LibraryTable.ModifiableModel> task) {
-    final ModifiableModelsProvider modifiableModelsProvider = ModifiableModelsProvider.SERVICE.getInstance();
-    final LibraryTable.ModifiableModel modifiableModel =
-      ApplicationManager.getApplication().runReadAction(new Computable<LibraryTable.ModifiableModel>() {
-        @Override
-        public LibraryTable.ModifiableModel compute() {
-          return modifiableModelsProvider.getLibraryTableModifiableModel(project);
-        }
-      });
-    task.consume(modifiableModel);
-    if (modifiableModel.isChanged()) {
-      doWriteAction(new Runnable() {
-        @Override
-        public void run() {
-          modifiableModel.commit();
-        }
-      });
-    }
-  }
-
-  @Override
-  public void updateLibrary(@NotNull final Library library, @NotNull Consumer<Library.ModifiableModel> task) {
-    final Library.ModifiableModel modifiableModel = library.getModifiableModel();
-    try {
-      task.consume(modifiableModel);
-      if (modifiableModel.isChanged()) {
-      doWriteAction(new Runnable() {
-        @Override
-        public void run() {
-          modifiableModel.commit();
-        }
-      });
-      }
-      else {
-        Disposer.dispose(modifiableModel);
-      }
-    }
-    catch (Throwable t) {
-      Disposer.dispose(modifiableModel);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
-    }
-  }
-}
@@ -1,69 +0,0 @@
-package com.intellij.openapi.externalSystem.service.project;
-
-import com.intellij.openapi.externalSystem.model.project.LibraryData;
-import com.intellij.openapi.externalSystem.model.project.LibraryDependencyData;
-import com.intellij.openapi.externalSystem.model.project.ModuleData;
-import com.intellij.openapi.externalSystem.model.project.ModuleDependencyData;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.*;
-import com.intellij.openapi.roots.libraries.Library;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Thread-safe.
- *
- * @author Denis Zhdanov
- * @since 2/6/12 3:28 PM
- */
-public class ProjectStructureHelper {
-
-  @NotNull private final PlatformFacade myFacade;
-
-  public ProjectStructureHelper(@NotNull PlatformFacade facade) {
-    myFacade = facade;
-  }
-
-  @Nullable
-  public Module findIdeModule(@NotNull ModuleData module, @NotNull Project ideProject) {
-    return myFacade.findIdeModule(module, ideProject);
-  }
-
-  @Nullable
-  public Module findIdeModule(@NotNull String ideModuleName, @NotNull Project ideProject) {
-    return myFacade.findIdeModule(ideModuleName, ideProject);
-  }
-
-  @Nullable
-  public Library findIdeLibrary(@NotNull final LibraryData libraryData, @NotNull Project ideProject) {
-    return myFacade.findIdeLibrary(libraryData, ideProject);
-  }
-
-  public static boolean isOrphanProjectLibrary(@NotNull final Library library,
-                                               @NotNull final Iterable<Module> ideModules) {
-    RootPolicy<Boolean> visitor = new RootPolicy<Boolean>() {
-      @Override
-      public Boolean visitLibraryOrderEntry(LibraryOrderEntry ideDependency, Boolean value) {
-        return !ideDependency.isModuleLevel() && library == ideDependency.getLibrary();
-      }
-    };
-    for (Module module : ideModules) {
-      for (OrderEntry entry : ModuleRootManager.getInstance(module).getOrderEntries()) {
-        if (entry.accept(visitor, false)) return false;
-      }
-    }
-    return true;
-  }
-
-  @SuppressWarnings("MethodMayBeStatic")
-  @Nullable
-  public ModuleOrderEntry findIdeModuleDependency(@NotNull ModuleDependencyData dependency, @NotNull ModifiableRootModel model) {
-    return myFacade.findIdeModuleDependency(dependency, model);
-  }
-
-  @Nullable
-  public OrderEntry findIdeModuleOrderEntry(LibraryDependencyData data, Project project) {
-    return myFacade.findIdeModuleOrderEntry(data, project);
-  }
-}
@@ -18,8 +18,7 @@ package com.intellij.openapi.externalSystem.service.project.manage;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.project.AbstractDependencyData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
-import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.util.Order;
 import com.intellij.openapi.module.Module;
@@ -28,7 +27,6 @@ import com.intellij.openapi.roots.ExportableOrderEntry;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.util.Computable;
-import com.intellij.util.ExceptionUtil;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.ContainerUtilRt;
 import com.intellij.util.containers.MultiMap;
@@ -50,7 +48,7 @@ public abstract class AbstractDependencyDataService<E extends AbstractDependency
  public Computable<Collection<I>> computeOrphanData(@NotNull final Collection<DataNode<E>> toImport,
                                                     @NotNull final ProjectData projectData,
                                                     @NotNull final Project project,
-                                                     @NotNull final PlatformFacade platformFacade) {
+                                                     @NotNull final IdeModifiableModelsProvider modelsProvider) {
    return new Computable<Collection<I>>() {
      @Override
      public Collection<I> compute() {
@@ -61,10 +59,12 @@ public abstract class AbstractDependencyDataService<E extends AbstractDependency
        }

        List<I> orphanEntries = ContainerUtil.newSmartList();
-        for (Module module : platformFacade.getModules(project, projectData)) {
-          for (OrderEntry entry : platformFacade.getOrderEntries(module)) {
+        for (Module module : modelsProvider.getModules(projectData)) {
+          for (OrderEntry entry : modelsProvider.getOrderEntries(module)) {
+            //noinspection unchecked
            if (getOrderEntryType().isInstance(entry) &&
                !byModuleName.get(entry.getOwnerModule().getName()).contains(getOrderEntryName((I)entry))) {
+              //noinspection unchecked
              orphanEntries.add((I)entry);
            }
          }
@@ -87,23 +87,10 @@ public abstract class AbstractDependencyDataService<E extends AbstractDependency
                         @NotNull Collection<DataNode<E>> toIgnore,
                         @NotNull ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
-    List<ModifiableRootModel> models = ContainerUtilRt.newArrayList();
-    try {
-      Map<Module, Collection<ExportableOrderEntry>> byModule = groupByModule(toRemoveComputable.compute());
-      for (Map.Entry<Module, Collection<ExportableOrderEntry>> entry : byModule.entrySet()) {
-        Module module = entry.getKey();
-        Collection<ExportableOrderEntry> depsToRemove = entry.getValue();
-        ModifiableRootModel model = platformFacade.getModuleModifiableModel(module);
-        removeData(depsToRemove, model);
-        models.add(model);
-      }
-      ExternalSystemApiUtil.commitModels(synchronous, project, models);
-    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(models);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
+    Map<Module, Collection<ExportableOrderEntry>> byModule = groupByModule(toRemoveComputable.compute());
+    for (Map.Entry<Module, Collection<ExportableOrderEntry>> entry : byModule.entrySet()) {
+      removeData(entry.getValue(), entry.getKey(), modelsProvider);
    }
  }

@@ -121,22 +108,27 @@ public abstract class AbstractDependencyDataService<E extends AbstractDependency
  }

  protected void removeData(@NotNull Collection<? extends ExportableOrderEntry> toRemove,
-                            @NotNull ModifiableRootModel moduleRootModel) {
-    for (ExportableOrderEntry dependency : toRemove) {
+                            @NotNull Module module,
+                            @NotNull IdeModifiableModelsProvider modelsProvider) {
+    if (toRemove.isEmpty()) {
+      return;
+    }
+    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
+    for (final ExportableOrderEntry dependency : toRemove) {
      // The thing is that intellij created order entry objects every time new modifiable model is created,
      // that's why we can't use target dependency object as is but need to get a reference to the current
      // entry object from the model instead.
-      for (OrderEntry entry : moduleRootModel.getOrderEntries()) {
+      for (OrderEntry entry : modifiableRootModel.getOrderEntries()) {
        if (entry instanceof ExportableOrderEntry) {
          ExportableOrderEntry orderEntry = (ExportableOrderEntry)entry;
          if (orderEntry.getPresentableName().equals(dependency.getPresentableName()) &&
              orderEntry.getScope().equals(dependency.getScope())) {
-            moduleRootModel.removeOrderEntry(entry);
+            modifiableRootModel.removeOrderEntry(entry);
            break;
          }
        }
        else if (entry.getPresentableName().equals(dependency.getPresentableName())) {
-          moduleRootModel.removeOrderEntry(entry);
+          modifiableRootModel.removeOrderEntry(entry);
          break;
        }
      }
@@ -25,7 +25,7 @@ import com.intellij.openapi.externalSystem.model.project.ContentRootData.SourceR
 import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceType;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemSettings;
 import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
@@ -42,7 +42,6 @@ import com.intellij.openapi.vcs.changes.ChangeListManager;
 import com.intellij.openapi.vfs.LocalFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.ExceptionUtil;
 import com.intellij.util.containers.ContainerUtilRt;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
@@ -59,8 +58,6 @@ import java.util.List;
 import java.util.Map;

 /**
- * Thread-safe.
- *
 * @author Denis Zhdanov
 * @since 2/7/12 3:20 PM
 */
@@ -79,42 +76,32 @@ public class ContentRootDataService extends AbstractProjectDataService<ContentRo
  public void importData(@NotNull Collection<DataNode<ContentRootData>> toImport,
                         @Nullable ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty()) {
      return;
    }

-    List<ModifiableRootModel> models = ContainerUtilRt.newArrayList();
-    try {
-      MultiMap<DataNode<ModuleData>, DataNode<ContentRootData>> byModule = ExternalSystemApiUtil.groupBy(toImport, ProjectKeys.MODULE);
-      for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ContentRootData>>> entry : byModule.entrySet()) {
-        Module module = platformFacade.findIdeModule(entry.getKey().getData(), project);
-        if (module == null) {
-          LOG.warn(String.format(
-            "Can't import content roots. Reason: target module (%s) is not found at the ide. Content roots: %s",
-            entry.getKey(), entry.getValue()
-          ));
-          continue;
-        }
-        models.add(importData(entry.getValue(), module, platformFacade));
+    MultiMap<DataNode<ModuleData>, DataNode<ContentRootData>> byModule = ExternalSystemApiUtil.groupBy(toImport, ProjectKeys.MODULE);
+    for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ContentRootData>>> entry : byModule.entrySet()) {
+      Module module = modelsProvider.findIdeModule(entry.getKey().getData());
+      if (module == null) {
+        LOG.warn(String.format(
+          "Can't import content roots. Reason: target module (%s) is not found at the ide. Content roots: %s",
+          entry.getKey(), entry.getValue()
+        ));
+        continue;
      }
-      ExternalSystemApiUtil.commitModels(synchronous, project, models);
-    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(models);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
+      importData(modelsProvider, entry.getValue(), module);
    }
  }

-  @NotNull
-  private static ModifiableRootModel importData(@NotNull Collection<DataNode<ContentRootData>> data,
-                                                @NotNull Module module,
-                                                @NotNull PlatformFacade platformFacade) {
-    ModifiableRootModel model = platformFacade.getModuleModifiableModel(module);
-    ContentEntry[] contentEntries = model.getContentEntries();
-    Map<String, ContentEntry> contentEntriesMap = ContainerUtilRt.newHashMap();
-    for(ContentEntry contentEntry : contentEntries) {
+  private static void importData(@NotNull IdeModifiableModelsProvider modelsProvider,
+                                 @NotNull final Collection<DataNode<ContentRootData>> data,
+                                 @NotNull final Module module) {
+    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
+    final ContentEntry[] contentEntries = modifiableRootModel.getContentEntries();
+    final Map<String, ContentEntry> contentEntriesMap = ContainerUtilRt.newHashMap();
+    for (ContentEntry contentEntry : contentEntries) {
      contentEntriesMap.put(contentEntry.getUrl(), contentEntry);
    }

@@ -131,40 +118,45 @@ public class ContentRootDataService extends AbstractProjectDataService<ContentRo
      }
    }

-    for (DataNode<ContentRootData> node : data) {
-      ContentRootData contentRoot = node.getData();
+    for (final DataNode<ContentRootData> node : data) {
+      final ContentRootData contentRoot = node.getData();

-      ContentEntry contentEntry = findOrCreateContentRoot(model, contentRoot.getRootPath());
+      final ContentEntry contentEntry = findOrCreateContentRoot(modifiableRootModel, contentRoot.getRootPath());
      contentEntry.clearExcludeFolders();
      contentEntry.clearSourceFolders();
      LOG.debug(String.format("Importing content root '%s' for module '%s'", contentRoot.getRootPath(), module.getName()));
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.SOURCE)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaSourceRootType.SOURCE, false, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaSourceRootType.SOURCE, false, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.TEST)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaSourceRootType.TEST_SOURCE, false, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaSourceRootType.TEST_SOURCE, false, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.RESOURCE)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaResourceRootType.RESOURCE, false, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaResourceRootType.RESOURCE, false, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.TEST_RESOURCE)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaResourceRootType.TEST_RESOURCE, false, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaResourceRootType.TEST_RESOURCE, false, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.SOURCE_GENERATED)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaSourceRootType.SOURCE, true, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaSourceRootType.SOURCE, true, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.TEST_GENERATED)) {
-        createSourceRootIfAbsent(contentEntry, path, module.getName(), JavaSourceRootType.TEST_SOURCE, true, createEmptyContentRootDirectories);
+        createSourceRootIfAbsent(
+          contentEntry, path, module.getName(), JavaSourceRootType.TEST_SOURCE, true, createEmptyContentRootDirectories);
      }
      for (SourceRoot path : contentRoot.getPaths(ExternalSystemSourceType.EXCLUDED)) {
        createExcludedRootIfAbsent(contentEntry, path, module.getName(), module.getProject());
      }
      contentEntriesMap.remove(contentEntry.getUrl());
    }
-    for(ContentEntry contentEntry : contentEntriesMap.values()) {
-      model.removeContentEntry(contentEntry);
+    for (ContentEntry contentEntry : contentEntriesMap.values()) {
+      modifiableRootModel.removeContentEntry(contentEntry);
    }
-    return model;
  }

  @NotNull
@@ -185,7 +177,7 @@ public class ContentRootDataService extends AbstractProjectDataService<ContentRo

  private static void createSourceRootIfAbsent(
    @NotNull ContentEntry entry, @NotNull SourceRoot root, @NotNull String moduleName,
-    @NotNull JpsModuleSourceRootType sourceRootType, boolean generated, boolean createEmptyContentRootDirectories) {
+    @NotNull JpsModuleSourceRootType<?> sourceRootType, boolean generated, boolean createEmptyContentRootDirectories) {
    List<SourceFolder> folders = entry.getSourceFolders(sourceRootType);
    for (SourceFolder folder : folders) {
      VirtualFile file = folder.getFile();
@@ -9,13 +9,17 @@ import com.intellij.openapi.externalSystem.model.project.LibraryData;
 import com.intellij.openapi.externalSystem.model.project.LibraryPathType;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.service.project.ExternalLibraryPathTypeMapper;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.util.ExternalSystemUtil;
 import com.intellij.openapi.externalSystem.util.Order;
+import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.LibraryOrderEntry;
+import com.intellij.openapi.roots.OrderEntry;
 import com.intellij.openapi.roots.OrderRootType;
+import com.intellij.openapi.roots.RootPolicy;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTable;
 import com.intellij.openapi.util.Computable;
@@ -23,7 +27,6 @@ import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.ArrayUtil;
-import com.intellij.util.Consumer;
 import com.intellij.util.NotNullFunction;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.ContainerUtilRt;
@@ -31,10 +34,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.io.File;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;

 /**
 * @author Denis Zhdanov
@@ -68,25 +68,22 @@ public class LibraryDataService extends AbstractProjectDataService<LibraryData,
  public void importData(@NotNull final Collection<DataNode<LibraryData>> toImport,
                         @Nullable final ProjectData projectData,
                         @NotNull final Project project,
-                         @NotNull final PlatformFacade platformFacade,
-                         final boolean synchronous) {
+                         @NotNull final IdeModifiableModelsProvider modelsProvider) {
    for (DataNode<LibraryData> dataNode : toImport) {
-      importLibrary(dataNode.getData(), project, platformFacade, synchronous);
+      importLibrary(dataNode.getData(), modelsProvider);
    }
  }

-  private void importLibrary(@NotNull final LibraryData toImport,
-                             @NotNull final Project project,
-                             @NotNull final PlatformFacade platformFacade,
-                             boolean synchronous) {
+  private void importLibrary(@NotNull final LibraryData toImport, @NotNull final IdeModifiableModelsProvider modelsProvider) {
    Map<OrderRootType, Collection<File>> libraryFiles = prepareLibraryFiles(toImport);

-    Library library = platformFacade.findIdeLibrary(toImport, project);
+    final String libraryName = toImport.getInternalName();
+    Library library = modelsProvider.getLibraryByName(libraryName);
    if (library != null) {
-      syncPaths(toImport, library, platformFacade);
+      syncPaths(toImport, library, modelsProvider);
      return;
    }
-    importLibrary(toImport.getInternalName(), libraryFiles, project, platformFacade);
+    importLibrary(libraryName, libraryFiles, modelsProvider);
  }

  @NotNull
@@ -104,22 +101,10 @@ public class LibraryDataService extends AbstractProjectDataService<LibraryData,

  private void importLibrary(@NotNull final String libraryName,
                             @NotNull final Map<OrderRootType, Collection<File>> libraryFiles,
-                             @NotNull final Project project,
-                             @NotNull final PlatformFacade platformFacade)
-  {
-    final Library[] intellijLibrary = new Library[1];
-    platformFacade.updateLibraryTable(project, new Consumer<LibraryTable.ModifiableModel>() {
-      @Override
-      public void consume(LibraryTable.ModifiableModel model) {
-        intellijLibrary[0] = model.createLibrary(libraryName);
-      }
-    });
-    platformFacade.updateLibrary(intellijLibrary[0], new Consumer<Library.ModifiableModel>() {
-      @Override
-      public void consume(Library.ModifiableModel libraryModel) {
-        registerPaths(libraryFiles, libraryModel, libraryName);
-      }
-    });
+                             @NotNull final IdeModifiableModelsProvider modelsProvider) {
+    final Library library = modelsProvider.createLibrary(libraryName);
+    final Library.ModifiableModel libraryModel = modelsProvider.getModifiableLibraryModel(library);
+    registerPaths(libraryFiles, libraryModel, libraryName);
  }

  @SuppressWarnings("MethodMayBeStatic")
@@ -170,36 +155,54 @@ public class LibraryDataService extends AbstractProjectDataService<LibraryData,
    }
  }

+  @NotNull
+  @Override
+  public Computable<Collection<Library>> computeOrphanData(@NotNull Collection<DataNode<LibraryData>> toImport,
+                                                           @NotNull final ProjectData projectData,
+                                                           @NotNull Project project,
+                                                           @NotNull final IdeModifiableModelsProvider modelsProvider) {
+    return new Computable<Collection<Library>>() {
+      @Override
+      public Collection<Library> compute() {
+        final List<Library> orphanIdeLibraries = ContainerUtil.newSmartList();
+        final LibraryTable.ModifiableModel librariesModel = modelsProvider.getModifiableProjectLibrariesModel();
+        for (Library library : librariesModel.getLibraries()) {
+          if (!ExternalSystemApiUtil.isExternalSystemLibrary(library, projectData.getOwner())) continue;
+          if (isOrphanProjectLibrary(library, modelsProvider)) {
+            orphanIdeLibraries.add(library);
+          }
+        }
+        return orphanIdeLibraries;
+      }
+    };
+  }
+
  @Override
  public void removeData(@NotNull final Computable<Collection<Library>> toRemoveComputable,
                         @NotNull Collection<DataNode<LibraryData>> toIgnore,
                         @NotNull ProjectData projectData,
                         @NotNull final Project project,
-                         @NotNull final PlatformFacade platformFacade,
-                         boolean synchronous) {
+                         @NotNull final IdeModifiableModelsProvider modelsProvider) {
    final Collection<Library> toRemove = toRemoveComputable.compute();
    if (toRemove.isEmpty()) {
      return;
    }
-    platformFacade.updateLibraryTable(project, new Consumer<LibraryTable.ModifiableModel>() {
-      @Override
-      public void consume(LibraryTable.ModifiableModel model) {
-        for (Library library : toRemove) {
-          String libraryName = library.getName();
-          if (libraryName != null) {
-            Library libraryToRemove = model.getLibraryByName(libraryName);
-            if (libraryToRemove != null) {
-              model.removeLibrary(libraryToRemove);
-            }
-          }
+
+    final LibraryTable.ModifiableModel librariesModel = modelsProvider.getModifiableProjectLibrariesModel();
+    for (Library library : toRemove) {
+      String libraryName = library.getName();
+      if (libraryName != null) {
+        Library libraryToRemove = librariesModel.getLibraryByName(libraryName);
+        if (libraryToRemove != null) {
+          librariesModel.removeLibrary(libraryToRemove);
        }
      }
-    });
+    }
  }

  private void syncPaths(@NotNull final LibraryData externalLibrary,
                         @NotNull final Library ideLibrary,
-                         @NotNull final PlatformFacade platformFacade) {
+                         @NotNull final IdeModifiableModelsProvider modelsProvider) {
    if (externalLibrary.isUnresolved()) {
      return;
    }
@@ -224,21 +227,33 @@ public class LibraryDataService extends AbstractProjectDataService<LibraryData,
      return;
    }

-    platformFacade.updateLibrary(ideLibrary, new Consumer<Library.ModifiableModel>() {
-      @Override
-      public void consume(Library.ModifiableModel model) {
-        for (Map.Entry<OrderRootType, Set<String>> entry : toRemove.entrySet()) {
-          for (String path : entry.getValue()) {
-            model.removeRoot(path, entry.getKey());
-          }
-        }
-
-        for (Map.Entry<OrderRootType, Set<String>> entry : toAdd.entrySet()) {
-          Map<OrderRootType, Collection<File>> roots = ContainerUtilRt.newHashMap();
-          roots.put(entry.getKey(), ContainerUtil.map(entry.getValue(), PATH_TO_FILE));
-          registerPaths(roots, model, externalLibrary.getInternalName());
-        }
+    final Library.ModifiableModel libraryModel = modelsProvider.getModifiableLibraryModel(ideLibrary);
+    for (Map.Entry<OrderRootType, Set<String>> entry : toRemove.entrySet()) {
+      for (String path : entry.getValue()) {
+        libraryModel.removeRoot(path, entry.getKey());
      }
-    });
+    }
+
+    for (Map.Entry<OrderRootType, Set<String>> entry : toAdd.entrySet()) {
+      Map<OrderRootType, Collection<File>> roots = ContainerUtilRt.newHashMap();
+      roots.put(entry.getKey(), ContainerUtil.map(entry.getValue(), PATH_TO_FILE));
+      registerPaths(roots, libraryModel, externalLibrary.getInternalName());
+    }
+  }
+
+  private static boolean isOrphanProjectLibrary(@NotNull final Library library,
+                                                @NotNull final IdeModifiableModelsProvider modelsProvider) {
+    RootPolicy<Boolean> visitor = new RootPolicy<Boolean>() {
+      @Override
+      public Boolean visitLibraryOrderEntry(LibraryOrderEntry ideDependency, Boolean value) {
+        return !ideDependency.isModuleLevel() && library == ideDependency.getLibrary();
+      }
+    };
+    for (Module module : modelsProvider.getModules()) {
+      for (OrderEntry entry : modelsProvider.getOrderEntries(module)) {
+        if (entry.accept(visitor, false)) return false;
+      }
+    }
+    return true;
  }
 }
@@ -20,7 +20,7 @@ import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.Key;
 import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.project.*;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.util.Order;
@@ -34,8 +34,6 @@ import com.intellij.openapi.roots.impl.ModuleLibraryOrderEntryImpl;
 import com.intellij.openapi.roots.libraries.Library;
 import com.intellij.openapi.roots.libraries.LibraryTable;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.ExceptionUtil;
-import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.ContainerUtilRt;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
@@ -43,7 +41,6 @@ import org.jetbrains.annotations.Nullable;

 import java.io.File;
 import java.util.Collection;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;

@@ -74,34 +71,22 @@ public class LibraryDependencyDataService extends AbstractDependencyDataService<
  public void importData(@NotNull Collection<DataNode<LibraryDependencyData>> toImport,
                         @Nullable ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty()) {
      return;
    }

-    MyImporter importer = new MyImporter(platformFacade);
-    try {
-      MultiMap<DataNode<ModuleData>, DataNode<LibraryDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
-      for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<LibraryDependencyData>>> entry : byModule.entrySet()) {
-        Module module = platformFacade.findIdeModule(entry.getKey().getData(), project);
-        Collection<DataNode<LibraryDependencyData>> libraryDependency = entry.getValue();
-        if (module == null) {
-          LOG.warn(String.format(
-            "Can't import library dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
-            libraryDependency, entry.getKey()
-          ));
-          continue;
-        }
-        importer.importData(module, libraryDependency);
+    MultiMap<DataNode<ModuleData>, DataNode<LibraryDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
+    for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<LibraryDependencyData>>> entry : byModule.entrySet()) {
+      Module module = modelsProvider.findIdeModule(entry.getKey().getData());
+      if (module == null) {
+        LOG.warn(String.format(
+          "Can't import library dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
+          entry.getValue(), entry.getKey()
+        ));
+        continue;
      }
-      // change libraries first
-      ExternalSystemApiUtil.commitChangedModels(synchronous, project, importer.getLibraryModels());
-      ExternalSystemApiUtil.commitModels(synchronous, project, importer.getModels());
-    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(importer.getModels());
-      ExceptionUtil.rethrowAllAsUnchecked(t);
+      importData(entry.getValue(), module, modelsProvider);
    }
  }

@@ -116,157 +101,146 @@ public class LibraryDependencyDataService extends AbstractDependencyDataService<
    return orderEntry.getLibraryName();
  }

-  private class MyImporter {
-    private final PlatformFacade myPlatformFacade;
-    private final List<ModifiableRootModel> myModels = ContainerUtilRt.newArrayList();
-    private final List<Library.ModifiableModel> myLibraryModels = ContainerUtilRt.newArrayList();
+  private void importData(@NotNull final Collection<DataNode<LibraryDependencyData>> nodesToImport,
+                          @NotNull final Module module,
+                          @NotNull final IdeModifiableModelsProvider modelsProvider) {
+    // The general idea is to import all external project library dependencies and module libraries which don't present at the
+    // ide side yet and remove all project library dependencies and module libraries which present at the ide but not at
+    // the given collection.
+    // The trick is that we should perform module settings modification inside try/finally block against target root model.
+    // That means that we need to prepare all necessary data, obtain a model and modify it as necessary.
+    final Map<Set<String>/* library paths */, LibraryDependencyData> moduleLibrariesToImport = ContainerUtilRt.newHashMap();
+    final Map<String/* library name + scope */, LibraryDependencyData> projectLibrariesToImport = ContainerUtilRt.newHashMap();
+    final Set<LibraryDependencyData> toImport = ContainerUtilRt.newLinkedHashSet();

-    private MyImporter(PlatformFacade platformFacade) {
-      myPlatformFacade = platformFacade;
-    }
-
-    public List<ModifiableRootModel> getModels() {
-      return ContainerUtil.newUnmodifiableList(myModels);
-    }
-
-    public List<Library.ModifiableModel> getLibraryModels() {
-      return ContainerUtil.newUnmodifiableList(myLibraryModels);
-    }
-
-    public void importData(@NotNull Module module, @NotNull Collection<DataNode<LibraryDependencyData>> nodesToImport) {
-      // The general idea is to import all external project library dependencies and module libraries which don't present at the
-      // ide side yet and remove all project library dependencies and module libraries which present at the ide but not at
-      // the given collection.
-      // The trick is that we should perform module settings modification inside try/finally block against target root model.
-      // That means that we need to prepare all necessary data, obtain a model and modify it as necessary.
-      Map<Set<String>/* library paths */, LibraryDependencyData> moduleLibrariesToImport = ContainerUtilRt.newHashMap();
-      Map<String/* library name + scope */, LibraryDependencyData> projectLibrariesToImport = ContainerUtilRt.newHashMap();
-      Set<LibraryDependencyData> toImport = ContainerUtilRt.newLinkedHashSet();
-
-      boolean hasUnresolved = false;
-      for (DataNode<LibraryDependencyData> dependencyNode : nodesToImport) {
-        LibraryDependencyData dependencyData = dependencyNode.getData();
-        LibraryData libraryData = dependencyData.getTarget();
-        hasUnresolved |= libraryData.isUnresolved();
-        switch (dependencyData.getLevel()) {
-          case MODULE:
-            if (!libraryData.isUnresolved()) {
-              Set<String> paths = ContainerUtilRt.newHashSet();
-              for (String path : libraryData.getPaths(LibraryPathType.BINARY)) {
-                paths.add(ExternalSystemApiUtil.toCanonicalPath(path) + dependencyData.getScope().name());
-              }
-              moduleLibrariesToImport.put(paths, dependencyData);
-              toImport.add(dependencyData);
+    boolean hasUnresolved = false;
+    for (DataNode<LibraryDependencyData> dependencyNode : nodesToImport) {
+      LibraryDependencyData dependencyData = dependencyNode.getData();
+      LibraryData libraryData = dependencyData.getTarget();
+      hasUnresolved |= libraryData.isUnresolved();
+      switch (dependencyData.getLevel()) {
+        case MODULE:
+          if (!libraryData.isUnresolved()) {
+            Set<String> paths = ContainerUtilRt.newHashSet();
+            for (String path : libraryData.getPaths(LibraryPathType.BINARY)) {
+              paths.add(ExternalSystemApiUtil.toCanonicalPath(path) + dependencyData.getScope().name());
            }
-            break;
-          case PROJECT:
-            projectLibrariesToImport.put(libraryData.getInternalName() + dependencyData.getScope().name(), dependencyData);
+            moduleLibrariesToImport.put(paths, dependencyData);
            toImport.add(dependencyData);
-        }
-      }
-
-      ModifiableRootModel moduleRootModel = myPlatformFacade.getModuleModifiableModel(module);
-      LibraryTable moduleLibraryTable = moduleRootModel.getModuleLibraryTable();
-      LibraryTable libraryTable = myPlatformFacade.getProjectLibraryTable(module.getProject());
-      syncExistingAndRemoveObsolete(moduleLibrariesToImport, projectLibrariesToImport, toImport, moduleRootModel, hasUnresolved);
-
-      // Import missing library dependencies.
-      if (!toImport.isEmpty()) {
-        importMissing(toImport, moduleRootModel, moduleLibraryTable, libraryTable, module);
-      }
-      myModels.add(moduleRootModel);
-    }
-
-    private void importMissing(@NotNull Set<LibraryDependencyData> toImport,
-                               @NotNull ModifiableRootModel moduleRootModel,
-                               @NotNull LibraryTable moduleLibraryTable,
-                               @NotNull LibraryTable libraryTable,
-                               @NotNull Module module) {
-      for (LibraryDependencyData dependencyData : toImport) {
-        LibraryData libraryData = dependencyData.getTarget();
-        String libraryName = libraryData.getInternalName();
-        switch (dependencyData.getLevel()) {
-          case MODULE:
-            Library moduleLib = moduleLibraryTable.createLibrary(libraryName);
-            syncExistingLibraryDependency(dependencyData, moduleLib, moduleRootModel, module);
-            break;
-          case PROJECT:
-            Library projectLib = libraryTable.getLibraryByName(libraryName);
-            if (projectLib == null) {
-              syncExistingLibraryDependency(dependencyData, moduleLibraryTable.createLibrary(libraryName), moduleRootModel, module);
-              break;
-            }
-            LibraryOrderEntry orderEntry = moduleRootModel.addLibraryEntry(projectLib);
-            setLibraryScope(orderEntry, projectLib, module, dependencyData);
-        }
+          }
+          break;
+        case PROJECT:
+          projectLibrariesToImport.put(libraryData.getInternalName() + dependencyData.getScope().name(), dependencyData);
+          toImport.add(dependencyData);
      }
    }

-    private void setLibraryScope(@NotNull LibraryOrderEntry orderEntry,
-                                        @NotNull Library lib,
-                                        @NotNull Module module,
-                                        @NotNull LibraryDependencyData dependencyData) {
-      LOG.debug(String.format("Adding library dependency '%s' to module '%s'", lib.getName(), module.getName()));
-      orderEntry.setExported(dependencyData.isExported());
-      orderEntry.setScope(dependencyData.getScope());
-      LOG.debug(String.format("Configuring library dependency '%s' of module '%s' to be%s exported and have scope %s", lib.getName(), module.getName(), dependencyData.isExported() ? " not" : "", dependencyData.getScope()));
-    }
+    final boolean finalHasUnresolved = hasUnresolved;

-    private void syncExistingAndRemoveObsolete(@NotNull Map<Set<String>, LibraryDependencyData> moduleLibrariesToImport,
-                                               @NotNull Map<String, LibraryDependencyData> projectLibrariesToImport,
-                                               @NotNull Set<LibraryDependencyData> toImport,
-                                               @NotNull ModifiableRootModel moduleRootModel,
-                                               boolean hasUnresolvedLibraries) {
-      Set<String> moduleLibraryKey = ContainerUtilRt.newHashSet();
-      for (OrderEntry entry : moduleRootModel.getOrderEntries()) {
-        if (entry instanceof ModuleLibraryOrderEntryImpl) {
-          ModuleLibraryOrderEntryImpl moduleLibraryOrderEntry = (ModuleLibraryOrderEntryImpl)entry;
-          Library library = moduleLibraryOrderEntry.getLibrary();
-          if (library == null) {
-            LOG.warn("Skipping module-level library entry because it doesn't have backing Library object. Entry: " + entry);
-            continue;
-          }
-          moduleLibraryKey.clear();
-          for (VirtualFile file : library.getFiles(OrderRootType.CLASSES)) {
-            moduleLibraryKey.add(ExternalSystemApiUtil.getLocalFileSystemPath(file) + moduleLibraryOrderEntry.getScope().name());
-          }
-          LibraryDependencyData existing = moduleLibrariesToImport.remove(moduleLibraryKey);
-          if (existing == null) {
-            moduleRootModel.removeOrderEntry(entry);
-          }
-          else {
-            syncExistingLibraryDependency(existing, library, moduleRootModel, moduleLibraryOrderEntry.getOwnerModule());
-            toImport.remove(existing);
-          }
-        }
-        else if (entry instanceof LibraryOrderEntry) {
-          LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry)entry;
-          String libraryName = libraryOrderEntry.getLibraryName();
-          LibraryDependencyData existing = projectLibrariesToImport.remove(libraryName + libraryOrderEntry.getScope().name());
-          if (existing != null) {
-            toImport.remove(existing);
-          }
-          else if (!hasUnresolvedLibraries) {
-            // There is a possible case that a project has been successfully imported from external model and after
-            // that network/repo goes down. We don't want to drop existing binary mappings then.
-            moduleRootModel.removeOrderEntry(entry);
-          }
-        }
-      }
-    }
-
-    private void syncExistingLibraryDependency(@NotNull LibraryDependencyData libraryDependencyData,
-                                               @NotNull Library library,
-                                               @NotNull ModifiableRootModel moduleRootModel,
-                                               @NotNull Module module) {
-      Library.ModifiableModel libModel = library.getModifiableModel();
-      String libraryName = libraryDependencyData.getInternalName();
-      Map<OrderRootType, Collection<File>> files = myLibraryManager.prepareLibraryFiles(libraryDependencyData.getTarget());
-      myLibraryManager.registerPaths(files, libModel, libraryName);
-      LibraryOrderEntry orderEntry = moduleRootModel.findLibraryOrderEntry(library);
-      assert orderEntry != null;
-      setLibraryScope(orderEntry, library, module, libraryDependencyData);
-      myLibraryModels.add(libModel);
+    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
+    LibraryTable moduleLibraryTable = modifiableRootModel.getModuleLibraryTable();
+    syncExistingAndRemoveObsolete(
+      modelsProvider, moduleLibrariesToImport, projectLibrariesToImport, toImport, modifiableRootModel, finalHasUnresolved);
+    // Import missing library dependencies.
+    if (!toImport.isEmpty()) {
+      importMissing(modelsProvider, toImport, modifiableRootModel, moduleLibraryTable, module);
    }
  }
+
+  private void importMissing(@NotNull IdeModifiableModelsProvider modelsProvider,
+                             @NotNull Set<LibraryDependencyData> toImport,
+                             @NotNull ModifiableRootModel moduleRootModel,
+                             @NotNull LibraryTable moduleLibraryTable,
+                             @NotNull Module module) {
+    for (final LibraryDependencyData dependencyData : toImport) {
+      final LibraryData libraryData = dependencyData.getTarget();
+      final String libraryName = libraryData.getInternalName();
+      switch (dependencyData.getLevel()) {
+        case MODULE:
+          final Library moduleLib = moduleLibraryTable.createLibrary(libraryName);
+          syncExistingLibraryDependency(modelsProvider, dependencyData, moduleLib, moduleRootModel, module);
+          break;
+        case PROJECT:
+          final Library projectLib = modelsProvider.getLibraryByName(libraryName);
+          if (projectLib == null) {
+            syncExistingLibraryDependency(modelsProvider, dependencyData, moduleLibraryTable.createLibrary(libraryName), moduleRootModel,
+                                          module);
+            break;
+          }
+          LibraryOrderEntry orderEntry = moduleRootModel.addLibraryEntry(projectLib);
+          setLibraryScope(orderEntry, projectLib, module, dependencyData);
+      }
+    }
+  }
+
+  private static void setLibraryScope(@NotNull LibraryOrderEntry orderEntry,
+                                      @NotNull Library lib,
+                                      @NotNull Module module,
+                                      @NotNull LibraryDependencyData dependencyData) {
+    LOG.debug(String.format("Adding library dependency '%s' to module '%s'", lib.getName(), module.getName()));
+    orderEntry.setExported(dependencyData.isExported());
+    orderEntry.setScope(dependencyData.getScope());
+    LOG.debug(String.format(
+      "Configuring library dependency '%s' of module '%s' to be%s exported and have scope %s",
+      lib.getName(), module.getName(), dependencyData.isExported() ? " not" : "", dependencyData.getScope()
+    ));
+  }
+
+  private void syncExistingAndRemoveObsolete(@NotNull IdeModifiableModelsProvider modelsProvider,
+                                             @NotNull Map<Set<String>, LibraryDependencyData> moduleLibrariesToImport,
+                                             @NotNull Map<String, LibraryDependencyData> projectLibrariesToImport,
+                                             @NotNull Set<LibraryDependencyData> toImport,
+                                             @NotNull ModifiableRootModel moduleRootModel,
+                                             boolean hasUnresolvedLibraries) {
+    Set<String> moduleLibraryKey = ContainerUtilRt.newHashSet();
+    for (OrderEntry entry : moduleRootModel.getOrderEntries()) {
+      if (entry instanceof ModuleLibraryOrderEntryImpl) {
+        ModuleLibraryOrderEntryImpl moduleLibraryOrderEntry = (ModuleLibraryOrderEntryImpl)entry;
+        Library library = moduleLibraryOrderEntry.getLibrary();
+        if (library == null) {
+          LOG.warn("Skipping module-level library entry because it doesn't have backing Library object. Entry: " + entry);
+          continue;
+        }
+        moduleLibraryKey.clear();
+        for (VirtualFile file : library.getFiles(OrderRootType.CLASSES)) {
+          moduleLibraryKey.add(ExternalSystemApiUtil.getLocalFileSystemPath(file) + moduleLibraryOrderEntry.getScope().name());
+        }
+        LibraryDependencyData existing = moduleLibrariesToImport.remove(moduleLibraryKey);
+        if (existing == null) {
+          moduleRootModel.removeOrderEntry(entry);
+        }
+        else {
+          syncExistingLibraryDependency(modelsProvider, existing, library, moduleRootModel, moduleLibraryOrderEntry.getOwnerModule());
+          toImport.remove(existing);
+        }
+      }
+      else if (entry instanceof LibraryOrderEntry) {
+        LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry)entry;
+        String libraryName = libraryOrderEntry.getLibraryName();
+        LibraryDependencyData existing = projectLibrariesToImport.remove(libraryName + libraryOrderEntry.getScope().name());
+        if (existing != null) {
+          toImport.remove(existing);
+        }
+        else if (!hasUnresolvedLibraries) {
+          // There is a possible case that a project has been successfully imported from external model and after
+          // that network/repo goes down. We don't want to drop existing binary mappings then.
+          moduleRootModel.removeOrderEntry(entry);
+        }
+      }
+    }
+  }
+
+  private void syncExistingLibraryDependency(@NotNull IdeModifiableModelsProvider modelsProvider,
+                                             @NotNull final LibraryDependencyData libraryDependencyData,
+                                             @NotNull final Library library,
+                                             @NotNull final ModifiableRootModel moduleRootModel,
+                                             @NotNull final Module module) {
+    final Library.ModifiableModel libraryModel = modelsProvider.getModifiableLibraryModel(library);
+    final String libraryName = libraryDependencyData.getInternalName();
+    Map<OrderRootType, Collection<File>> files = myLibraryManager.prepareLibraryFiles(libraryDependencyData.getTarget());
+    myLibraryManager.registerPaths(files, libraryModel, libraryName);
+    LibraryOrderEntry orderEntry = moduleRootModel.findLibraryOrderEntry(library);
+    assert orderEntry != null;
+    setLibraryScope(orderEntry, library, module, libraryDependencyData);
+  }
 }
@@ -15,6 +15,7 @@
 */
 package com.intellij.openapi.externalSystem.service.project.manage;

+import com.intellij.ide.util.projectWizard.ModuleBuilder;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.model.DataNode;
@@ -24,10 +25,10 @@ import com.intellij.openapi.externalSystem.model.ProjectSystemId;
 import com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceType;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.*;
+import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.ui.DialogWrapper;
@@ -38,7 +39,6 @@ import com.intellij.ui.CheckBoxList;
 import com.intellij.ui.IdeBorderFactory;
 import com.intellij.ui.components.JBScrollPane;
 import com.intellij.util.Consumer;
-import com.intellij.util.ExceptionUtil;
 import com.intellij.util.Function;
 import com.intellij.util.SmartList;
 import com.intellij.util.containers.ContainerUtil;
@@ -49,7 +49,6 @@ import org.jetbrains.annotations.Nullable;

 import javax.swing.*;
 import java.awt.*;
-import java.io.File;
 import java.util.Collection;
 import java.util.List;

@@ -76,74 +75,63 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
  public void importData(@NotNull Collection<DataNode<ModuleData>> toImport,
                         @Nullable ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty()) {
      return;
    }
-    Collection<DataNode<ModuleData>> toCreate = filterExistingModules(toImport, project, platformFacade);
+
+    final Collection<DataNode<ModuleData>> toCreate = filterExistingModules(toImport, modelsProvider);
    if (!toCreate.isEmpty()) {
-      ExternalSystemApiUtil.commitModels(synchronous, project, createModules(project, platformFacade, toCreate));
+      createModules(toCreate, modelsProvider);
+    }
+    for (DataNode<ModuleData> node : toImport) {
+      Module module = modelsProvider.findIdeModule(node.getData());
+      if (module != null) {
+        syncPaths(module, modelsProvider, node.getData());
+      }
    }
-    ExternalSystemApiUtil.commitModels(synchronous, project, syncModulesPaths(project, platformFacade, toImport));
  }

-  @NotNull
-  private static List<ModifiableRootModel> createModules(@NotNull Project project,
-                                                         @NotNull PlatformFacade platformFacade,
-                                                         Collection<DataNode<ModuleData>> toCreate) {
-    List<ModifiableRootModel> models = ContainerUtilRt.newArrayList();
-    try {
-      for (DataNode<ModuleData> moduleData : toCreate) {
-        models.add(createModule(project, platformFacade, moduleData));
+  private static void createModules(@NotNull Collection<DataNode<ModuleData>> toCreate,
+                                    @NotNull IdeModifiableModelsProvider modelsProvider) {
+    for (final DataNode<ModuleData> module : toCreate) {
+      ModuleData data = module.getData();
+      final Module created = modelsProvider.newModule(data.getModuleFilePath(), data.getModuleTypeId());
+
+      // Ensure that the dependencies are clear (used to be not clear when manually removing the module and importing it via gradle)
+      final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(created);
+
+      modifiableRootModel.inheritSdk();
+      setModuleOptions(created, module);
+
+      RootPolicy<Object> visitor = new RootPolicy<Object>() {
+        @Override
+        public Object visitLibraryOrderEntry(LibraryOrderEntry libraryOrderEntry, Object value) {
+          modifiableRootModel.removeOrderEntry(libraryOrderEntry);
+          return value;
+        }
+
+        @Override
+        public Object visitModuleOrderEntry(ModuleOrderEntry moduleOrderEntry, Object value) {
+          modifiableRootModel.removeOrderEntry(moduleOrderEntry);
+          return value;
+        }
+      };
+
+      for (OrderEntry orderEntry : modifiableRootModel.getOrderEntries()) {
+        orderEntry.accept(visitor, null);
      }
    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(models);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
-    }
-    return models;
-  }
-
-  private static ModifiableRootModel createModule(@NotNull Project project,
-                                                  @NotNull PlatformFacade platformFacade,
-                                                  @NotNull DataNode<ModuleData> module) {
-    ModuleData data = module.getData();
-    Module created = platformFacade.newModule(project, data.getModuleFilePath(), data.getModuleTypeId());
-
-    // Ensure that the dependencies are clear (used to be not clear when manually removing the module and importing it via gradle)
-    final ModifiableRootModel moduleRootModel = platformFacade.getModuleModifiableModel(created);
-    moduleRootModel.inheritSdk();
-    setModuleOptions(created, module);
-
-    RootPolicy<Object> visitor = new RootPolicy<Object>() {
-      @Override
-      public Object visitLibraryOrderEntry(LibraryOrderEntry libraryOrderEntry, Object value) {
-        moduleRootModel.removeOrderEntry(libraryOrderEntry);
-        return value;
-      }
-
-      @Override
-      public Object visitModuleOrderEntry(ModuleOrderEntry moduleOrderEntry, Object value) {
-        moduleRootModel.removeOrderEntry(moduleOrderEntry);
-        return value;
-      }
-    };
-    for (OrderEntry orderEntry : moduleRootModel.getOrderEntries()) {
-      orderEntry.accept(visitor, null);
-    }
-    return moduleRootModel;
  }

  @NotNull
  private static Collection<DataNode<ModuleData>> filterExistingModules(@NotNull Collection<DataNode<ModuleData>> modules,
-                                                                        @NotNull Project project,
-                                                                        @NotNull PlatformFacade platformFacade)
+                                                                        @NotNull IdeModifiableModelsProvider modelsProvider)
  {
    Collection<DataNode<ModuleData>> result = ContainerUtilRt.newArrayList();
    for (DataNode<ModuleData> node : modules) {
      ModuleData moduleData = node.getData();
-      Module module = platformFacade.findIdeModule(moduleData, project);
+      Module module = modelsProvider.findIdeModule(moduleData);
      if (module == null) {
        result.add(node);
      }
@@ -154,34 +142,16 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
    return result;
  }

-  @NotNull
-  private static List<ModifiableRootModel> syncModulesPaths(@NotNull Project project,
-                                                            @NotNull PlatformFacade platformFacade,
-                                                            Collection<DataNode<ModuleData>> toCreate) {
-    List<ModifiableRootModel> models = ContainerUtilRt.newArrayList();
-    try {
-      for (DataNode<ModuleData> moduleData : toCreate) {
-        Module module = platformFacade.findIdeModule(moduleData.getData(), project);
-        if (module != null) {
-          models.add(syncPaths(module, platformFacade, moduleData.getData()));
-        }
-      }
-    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(models);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
-    }
-    return models;
-  }
-
-  @NotNull
-  private static ModifiableRootModel syncPaths(@NotNull Module module, @NotNull PlatformFacade platformFacade, @NotNull ModuleData data) {
-    ModifiableRootModel modifiableModel = platformFacade.getModuleModifiableModel(module);
-    CompilerModuleExtension extension = modifiableModel.getModuleExtension(CompilerModuleExtension.class);
+  private static void syncPaths(@NotNull final Module module, @NotNull IdeModifiableModelsProvider modelsProvider, @NotNull final ModuleData data) {
+    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
+    CompilerModuleExtension extension = modifiableRootModel.getModuleExtension(CompilerModuleExtension.class);
    if (extension == null) {
-      LOG.warn(String.format("Can't sync paths for module '%s'. Reason: no compiler extension is found for it", module.getName()));
-      return modifiableModel;
+      modifiableRootModel.dispose();
+      final String errorMsg =
+        String.format("Can't sync paths for module '%s'. Reason: no compiler extension is found for it", module.getName());
+      throw new RuntimeException(errorMsg);
    }
+
    String compileOutputPath = data.getCompileOutputPath(ExternalSystemSourceType.SOURCE);
    if (compileOutputPath != null) {
      extension.setCompilerOutputPath(VfsUtilCore.pathToUrl(compileOutputPath));
@@ -193,7 +163,6 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
    }

    extension.inheritCompilerOutputPath(data.isInheritProjectCompileOutputPath());
-    return modifiableModel;
  }

  @NotNull
@@ -201,13 +170,13 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
  public Computable<Collection<Module>> computeOrphanData(@NotNull final Collection<DataNode<ModuleData>> toImport,
                                                          @NotNull final ProjectData projectData,
                                                          @NotNull final Project project,
-                                                          @NotNull final PlatformFacade platformFacade) {
+                                                          @NotNull final IdeModifiableModelsProvider modelsProvider) {
    return new Computable<Collection<Module>>() {
      @Override
      public Collection<Module> compute() {
        List<Module> orphanIdeModules = ContainerUtil.newSmartList();

-        for (Module module : platformFacade.getModules(project)) {
+        for (Module module : modelsProvider.getModules()) {
          if (!ExternalSystemApiUtil.isExternalSystemAwareModule(projectData.getOwner(), module)) continue;
          final String rootProjectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
          if (projectData.getLinkedExternalProjectPath().equals(rootProjectPath)) {
@@ -238,12 +207,11 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
                         @NotNull final Collection<DataNode<ModuleData>> toIgnore,
                         @NotNull final ProjectData projectData,
                         @NotNull final Project project,
-                         @NotNull final PlatformFacade platformFacade,
-                         final boolean synchronous) {
+                         @NotNull final IdeModifiableModelsProvider modelsProvider) {
    final Collection<Module> toRemove = toRemoveComputable.compute();
    final List<Module> modules = new SmartList<Module>(toRemove);
    for (DataNode<ModuleData> moduleDataNode : toIgnore) {
-      final Module module = platformFacade.findIdeModule(moduleDataNode.getData(), project);
+      final Module module = modelsProvider.findIdeModule(moduleDataNode.getData());
      ContainerUtil.addIfNotNull(modules, module);
    }

@@ -261,25 +229,13 @@ public class ModuleDataService extends AbstractProjectDataService<ModuleData, Mo
    ruleOrphanModules(modules, project, projectData.getOwner(), new Consumer<List<Module>>() {
      @Override
      public void consume(final List<Module> modules) {
-        ExternalSystemApiUtil.executeProjectChangeAction(synchronous, new DisposeAwareProjectChange(project) {
-          @Override
-          public void execute() {
-            for (Module module : modules) {
-              if (module.isDisposed()) continue;
-
-              ModuleManager moduleManager = ModuleManager.getInstance(module.getProject());
-              String path = module.getModuleFilePath();
-              moduleManager.disposeModule(module);
-              File file = new File(path);
-              if (file.isFile()) {
-                boolean success = file.delete();
-                if (!success) {
-                  LOG.warn("Can't remove module file at '" + path + "'");
-                }
-              }
-            }
-          }
-        });
+        final ModifiableModuleModel moduleModel = modelsProvider.getModifiableModuleModel();
+        for (Module module : modules) {
+          if (module.isDisposed()) continue;
+          String path = module.getModuleFilePath();
+          moduleModel.disposeModule(module);
+          ModuleBuilder.deleteModuleFile(path);
+        }
      }
    });
  }
@@ -22,7 +22,7 @@ import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ModuleDependencyData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.util.Order;
@@ -30,14 +30,12 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.util.Pair;
-import com.intellij.util.ExceptionUtil;
 import com.intellij.util.containers.ContainerUtilRt;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.Collection;
-import java.util.List;
 import java.util.Map;

 import static com.intellij.openapi.externalSystem.model.ProjectKeys.MODULE;
@@ -61,27 +59,18 @@ public class ModuleDependencyDataService extends AbstractDependencyDataService<M
  public void importData(@NotNull Collection<DataNode<ModuleDependencyData>> toImport,
                         @Nullable ProjectData projectData,
                         @NotNull Project project,
-                         @NotNull PlatformFacade platformFacade,
-                         boolean synchronous) {
-    List<ModifiableRootModel> models = ContainerUtilRt.newArrayList();
-    try {
-      MultiMap<DataNode<ModuleData>, DataNode<ModuleDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
-      for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ModuleDependencyData>>> entry : byModule.entrySet()) {
-        Module ideModule = platformFacade.findIdeModule(entry.getKey().getData(), project);
-        if (ideModule == null) {
-          LOG.warn(String.format(
-            "Can't import module dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
-            entry.getValue(), entry.getKey()
-          ));
-          continue;
-        }
-        models.add(importData(entry.getValue(), ideModule, platformFacade));
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
+    MultiMap<DataNode<ModuleData>, DataNode<ModuleDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
+    for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ModuleDependencyData>>> entry : byModule.entrySet()) {
+      Module ideModule = modelsProvider.findIdeModule(entry.getKey().getData());
+      if (ideModule == null) {
+        LOG.warn(String.format(
+          "Can't import module dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
+          entry.getValue(), entry.getKey()
+        ));
+        continue;
      }
-      ExternalSystemApiUtil.commitModels(synchronous, project, models);
-    }
-    catch (Throwable t) {
-      ExternalSystemApiUtil.disposeModels(models);
-      ExceptionUtil.rethrowAllAsUnchecked(t);
+      importData(entry.getValue(), ideModule, modelsProvider);
    }
  }

@@ -96,27 +85,24 @@ public class ModuleDependencyDataService extends AbstractDependencyDataService<M
    return orderEntry.getModuleName();
  }

-  @NotNull
-  private ModifiableRootModel importData(@NotNull Collection<DataNode<ModuleDependencyData>> toImport,
-                                         @NotNull Module module,
-                                         @NotNull PlatformFacade platformFacade)
-  {
-    ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
-    Map<Pair<String /* dependency module internal name */, /* dependency module scope */DependencyScope>, ModuleOrderEntry> toRemove =
+  private void importData(@NotNull final Collection<DataNode<ModuleDependencyData>> toImport,
+                          @NotNull final Module module,
+                          @NotNull final IdeModifiableModelsProvider modelsProvider) {
+    final Map<Pair<String /* dependency module internal name */, /* dependency module scope */DependencyScope>, ModuleOrderEntry> toRemove =
      ContainerUtilRt.newHashMap();
-    for (OrderEntry entry : moduleRootManager.getOrderEntries()) {
+    for (OrderEntry entry : modelsProvider.getOrderEntries(module)) {
      if (entry instanceof ModuleOrderEntry) {
        ModuleOrderEntry e = (ModuleOrderEntry)entry;
        toRemove.put(Pair.create(e.getModuleName(), e.getScope()), e);
      }
    }

-    ModifiableRootModel moduleRootModel = platformFacade.getModuleModifiableModel(module);
+    final ModifiableRootModel modifiableRootModel = modelsProvider.getModifiableRootModel(module);
    for (DataNode<ModuleDependencyData> dependencyNode : toImport) {
-      ModuleDependencyData dependencyData = dependencyNode.getData();
+      final ModuleDependencyData dependencyData = dependencyNode.getData();
      toRemove.remove(Pair.create(dependencyData.getInternalName(), dependencyData.getScope()));
-      String moduleName = dependencyData.getInternalName();
-      Module ideDependencyModule = platformFacade.findIdeModule(moduleName, module.getProject());
+      final String moduleName = dependencyData.getInternalName();
+      Module ideDependencyModule = modelsProvider.findIdeModule(moduleName);

      ModuleOrderEntry orderEntry;
      if (module.equals(ideDependencyModule)) {
@@ -125,14 +111,16 @@ public class ModuleDependencyDataService extends AbstractDependencyDataService<M
      }
      else {
        if (ideDependencyModule == null) {
-          LOG.warn(String.format("Can't import module dependency for '%s' module. Reason: target module (%s) is not found at the ide",
-                                 module.getName(), dependencyData));
+          LOG.warn(String.format(
+            "Can't import module dependency for '%s' module. Reason: target module (%s) is not found at the ide",
+            module.getName(), dependencyData
+          ));
        }
-        orderEntry = platformFacade.findIdeModuleDependency(dependencyData, moduleRootModel);
+        orderEntry = modelsProvider.findIdeModuleDependency(dependencyData, module);
        if (orderEntry == null) {
          orderEntry = ideDependencyModule == null
-                       ? moduleRootModel.addInvalidModuleEntry(moduleName)
-                       : moduleRootModel.addModuleOrderEntry(ideDependencyModule);
+                       ? modifiableRootModel.addInvalidModuleEntry(moduleName)
+                       : modifiableRootModel.addModuleOrderEntry(ideDependencyModule);
        }
      }

@@ -141,9 +129,7 @@ public class ModuleDependencyDataService extends AbstractDependencyDataService<M
    }

    if (!toRemove.isEmpty()) {
-      removeData(toRemove.values(), moduleRootModel);
+      removeData(toRemove.values(), module, modelsProvider);
    }
-
-    return moduleRootModel;
  }
 }
@@ -16,12 +16,13 @@
 package com.intellij.openapi.externalSystem.service.project.manage;

 import com.intellij.openapi.components.ServiceManager;
-import com.intellij.openapi.components.impl.stores.BatchUpdateListener;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.model.*;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
+import com.intellij.openapi.externalSystem.util.DisposeAwareProjectChange;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemBundle;
 import com.intellij.openapi.externalSystem.util.ExternalSystemUtil;
@@ -33,6 +34,7 @@ import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.NotNullLazyValue;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.Consumer;
+import com.intellij.util.ExceptionUtil;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.ContainerUtilRt;
@@ -57,13 +59,12 @@ public class ProjectDataManager {
    com.intellij.openapi.util.Key.create("externalSystem.data.ready");

  @NotNull private final NotNullLazyValue<Map<Key<?>, List<ProjectDataService<?, ?>>>> myServices;
-  private final PlatformFacade myPlatformFacade;

  public static ProjectDataManager getInstance() {
    return ServiceManager.getService(ProjectDataManager.class);
  }

-  public ProjectDataManager(@NotNull PlatformFacade platformFacade) {
+  public ProjectDataManager() {
    myServices = new NotNullLazyValue<Map<Key<?>, List<ProjectDataService<?, ?>>>>() {
      @NotNull
      @Override
@@ -83,7 +84,6 @@ public class ProjectDataManager {
        return result;
      }
    };
-    myPlatformFacade = platformFacade;
  }

  @Nullable
@@ -95,8 +95,8 @@ public class ProjectDataManager {

  @SuppressWarnings("unchecked")
  public void importData(@NotNull Collection<DataNode<?>> nodes,
-                         @NotNull final Project project,
-                         @NotNull PlatformFacade platformFacade,
+                         @NotNull Project project,
+                         @NotNull IdeModifiableModelsProvider modelsProvider,
                         boolean synchronous) {
    if (project.isDisposed()) return;

@@ -129,8 +129,6 @@ public class ProjectDataManager {
      ExternalSystemUtil.scheduleExternalViewStructureUpdate(project, projectSystemId);
    }

-    final BatchUpdateListener publisher = project.getMessageBus().syncPublisher(BatchUpdateListener.TOPIC);
-    publisher.onBatchUpdateStarted();
    try {
      final Set<Map.Entry<Key<?>, Collection<DataNode<?>>>> entries = grouped.entrySet();
      final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
@@ -139,27 +137,30 @@ public class ProjectDataManager {
      }
      final int size = entries.size();
      int count = 0;
+      List<Runnable> postImportTasks = ContainerUtil.newSmartList();
      for (Map.Entry<Key<?>, Collection<DataNode<?>>> entry : entries) {
        if (indicator != null) {
          String message = ExternalSystemBundle.message(
            "progress.update.text", projectSystemId != null ? projectSystemId.getReadableName() : "",
-            "Importing " + getReadableText(entry.getKey()));
+            "Refresh " + getReadableText(entry.getKey()));
          indicator.setText(message);
          indicator.setFraction((double)count++ / size);
        }
-        doImportData(entry.getKey(), entry.getValue(), projectData, project, platformFacade, synchronous);
+        doImportData(entry.getKey(), entry.getValue(), projectData, project, modelsProvider, postImportTasks);
      }
+
+      for (Runnable postImportTask : ContainerUtil.reverse(postImportTasks)) {
+        postImportTask.run();
+      }
+
+      commit(modelsProvider, project, synchronous, "Imported data");
      if (indicator != null) {
        indicator.setIndeterminate(true);
      }
    }
-    finally {
-      ExternalSystemApiUtil.executeOnEdt(synchronous, new Runnable() {
-        @Override
-        public void run() {
-          publisher.onBatchUpdateFinished();
-        }
-      });
+    catch (Throwable t) {
+      dispose(modelsProvider, project, synchronous);
+      ExceptionUtil.rethrowAllAsUnchecked(t);
    }
  }

@@ -187,33 +188,33 @@ public class ProjectDataManager {
    for (DataNode<T> node : nodes) {
      dummy.add(node);
    }
-    importData(dummy, project, myPlatformFacade, synchronous);
+    importData(dummy, project, new IdeModifiableModelsProviderImpl(project), synchronous);
  }

  public <T> void importData(@NotNull DataNode<T> node,
                             @NotNull Project project,
-                             @NotNull PlatformFacade platformFacade,
+                             @NotNull IdeModifiableModelsProvider modelsProvider,
                             boolean synchronous) {
    Collection<DataNode<?>> dummy = ContainerUtil.newSmartList();
    dummy.add(node);
-    importData(dummy, project, platformFacade, synchronous);
+    importData(dummy, project, modelsProvider, synchronous);
  }

  public <T> void importData(@NotNull DataNode<T> node,
                             @NotNull Project project,
                             boolean synchronous) {
-    importData(node, project, myPlatformFacade, synchronous);
+    importData(node, project, new IdeModifiableModelsProviderImpl(project), synchronous);
  }

  @SuppressWarnings("unchecked")
  private <T> void doImportData(@NotNull Key<T> key,
                                @NotNull Collection<DataNode<?>> nodes,
-                                @Nullable ProjectData projectData,
-                                @NotNull Project project,
-                                @NotNull PlatformFacade platformFacade,
-                                boolean synchronous) {
+                                @Nullable final ProjectData projectData,
+                                @NotNull final Project project,
+                                @NotNull final IdeModifiableModelsProvider modelsProvider,
+                                @NotNull List<Runnable> postImportTasks) {
    if (project.isDisposed()) return;
-    if(project instanceof ProjectImpl) {
+    if (project instanceof ProjectImpl) {
      assert ((ProjectImpl)project).isComponentsCreated();
    }

@@ -233,7 +234,7 @@ public class ProjectDataManager {

    ensureTheDataIsReadyToUse((Collection)toImport);

-    List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
+    final List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
    if (services == null) {
      LOG.warn(String.format(
        "Can't import data nodes '%s'. Reason: no service is registered for key %s. Available services for %s",
@@ -243,32 +244,28 @@ public class ProjectDataManager {
    else {
      for (ProjectDataService<?, ?> service : services) {
        final long importStartTime = System.currentTimeMillis();
-        if (service instanceof ProjectDataServiceEx) {
-          ((ProjectDataServiceEx<T, ?>)service).importData(toImport, projectData, project, platformFacade, synchronous);
-        }
-        else {
-          ((ProjectDataService<T, ?>)service).importData(toImport, project, synchronous);
-        }
-        final long importTimeInSeconds = (System.currentTimeMillis() - importStartTime) / 1000;
-        LOG.debug(String.format("Service %s imported data in %d seconds", service.getClass().getSimpleName(), importTimeInSeconds));
+        ((ProjectDataService)service).importData(toImport, projectData, project, modelsProvider);
+        final long importTimeInMs = (System.currentTimeMillis() - importStartTime);
+        LOG.debug(String.format("Service %s imported data in %d ms", service.getClass().getSimpleName(), importTimeInMs));
      }
    }

    ensureTheDataIsReadyToUse((Collection)toIgnore);

    if (services != null && projectData != null) {
-      for (ProjectDataService<?, ?> service : services) {
-        if (service instanceof ProjectDataServiceEx) {
-          final long removeStartTime = System.currentTimeMillis();
-          final ProjectDataServiceEx dataServiceEx = (ProjectDataServiceEx)service;
-          final Computable<Collection<?>> orphanIdeDataComputable =
-            dataServiceEx.computeOrphanData(toImport, projectData, project, platformFacade);
-          dataServiceEx.removeData(orphanIdeDataComputable, toIgnore, projectData, project, platformFacade, synchronous);
-          final long removeTimeInSeconds = (System.currentTimeMillis() - removeStartTime) / 1000;
-          LOG.debug(String.format("Service %s computed and removed data in %d seconds",
-                                  service.getClass().getSimpleName(), removeTimeInSeconds));
+      postImportTasks.add(new Runnable() {
+        @Override
+        public void run() {
+          for (ProjectDataService<?, ?> service : services) {
+            final long removeStartTime = System.currentTimeMillis();
+            final Computable<Collection<?>> orphanIdeDataComputable =
+              ((ProjectDataService)service).computeOrphanData(toImport, projectData, project, modelsProvider);
+            ((ProjectDataService)service).removeData(orphanIdeDataComputable, toIgnore, projectData, project, modelsProvider);
+            final long removeTimeInMs = (System.currentTimeMillis() - removeStartTime);
+            LOG.debug(String.format("Service %s computed and removed data in %d ms", service.getClass().getSimpleName(), removeTimeInMs));
+          }
        }
-      }
+      });
    }
  }

@@ -285,35 +282,28 @@ public class ProjectDataManager {
    });
  }

-  @SuppressWarnings("unchecked")
-  @Deprecated
-  public <E, I> void removeData(@NotNull Key<E> key, @NotNull Collection<I> toRemove, @NotNull Project project, boolean synchronous) {
-    List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
-    for (ProjectDataService service : services) {
-      service.removeData(toRemove, project, synchronous);
-    }
-  }
-
  @SuppressWarnings("unchecked")
  public <E, I> void removeData(@NotNull Key<E> key,
                                @NotNull Collection<I> toRemove,
                                @NotNull final Collection<DataNode<E>> toIgnore,
                                @NotNull final ProjectData projectData,
                                @NotNull Project project,
-                                @NotNull PlatformFacade platformFacade,
+                                @NotNull final IdeModifiableModelsProvider modelsProvider,
                                boolean synchronous) {
-    List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
-    for (ProjectDataService service : services) {
-      final long removeStartTime = System.currentTimeMillis();
-      if (service instanceof ProjectDataServiceEx) {
-        ((ProjectDataServiceEx)service).removeData(new Computable.PredefinedValueComputable<Collection>(toRemove),
-                                                   toIgnore, projectData, project, platformFacade, synchronous);
+    try {
+      List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
+      for (ProjectDataService service : services) {
+        final long removeStartTime = System.currentTimeMillis();
+        service.removeData(new Computable.PredefinedValueComputable<Collection>(toRemove), toIgnore, projectData, project, modelsProvider);
+        final long removeTimeInMs = System.currentTimeMillis() - removeStartTime;
+        LOG.debug(String.format("Service %s removed data in %d ms", service.getClass().getSimpleName(), removeTimeInMs));
      }
-      else {
-        service.removeData(toRemove, project, synchronous);
-      }
-      final long removeTimeInSeconds = (System.currentTimeMillis() - removeStartTime) / 1000;
-      LOG.debug(String.format("Service %s removed data in %d seconds", service.getClass().getSimpleName(), removeTimeInSeconds));
+
+      commit(modelsProvider, project, synchronous, "Removed data");
+    }
+    catch (Throwable t) {
+      dispose(modelsProvider, project, synchronous);
+      ExceptionUtil.rethrowAllAsUnchecked(t);
    }
  }

@@ -323,7 +313,7 @@ public class ProjectDataManager {
                                @NotNull final ProjectData projectData,
                                @NotNull Project project,
                                boolean synchronous) {
-    removeData(key, toRemove, toIgnore, projectData, project, myPlatformFacade, synchronous);
+    removeData(key, toRemove, toIgnore, projectData, project, new IdeModifiableModelsProviderImpl(project), synchronous);
  }

  public void updateExternalProjectData(@NotNull Project project, @NotNull ExternalProjectInfo externalProjectInfo) {
@@ -373,4 +363,30 @@ public class ProjectDataManager {
      }
    }
  }
+
+  private static void commit(@NotNull final IdeModifiableModelsProvider modelsProvider,
+                             @NotNull Project project,
+                             boolean synchronous,
+                             @NotNull final String commitDesc) {
+    ExternalSystemApiUtil.executeProjectChangeAction(synchronous, new DisposeAwareProjectChange(project) {
+      @Override
+      public void execute() {
+        final long startTime = System.currentTimeMillis();
+        modelsProvider.commit();
+        final long timeInMs = System.currentTimeMillis() - startTime;
+        LOG.debug(String.format("%s committed in %d ms", commitDesc, timeInMs));
+      }
+    });
+  }
+
+  private static void dispose(@NotNull final IdeModifiableModelsProvider modelsProvider,
+                              @NotNull Project project,
+                              boolean synchronous) {
+    ExternalSystemApiUtil.executeProjectChangeAction(synchronous, new DisposeAwareProjectChange(project) {
+      @Override
+      public void execute() {
+        modelsProvider.dispose();
+      }
+    });
+  }
 }
@@ -20,6 +20,7 @@ import com.intellij.openapi.externalSystem.model.Key;
 import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.ProjectSystemId;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.util.DisposeAwareProjectChange;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
@@ -27,6 +28,7 @@ import com.intellij.openapi.externalSystem.util.Order;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ex.ProjectEx;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;

 import java.util.Collection;

@@ -35,7 +37,7 @@ import java.util.Collection;
 * @since 2/21/13 2:40 PM
 */
@Order(ExternalSystemConstants.BUILTIN_PROJECT_DATA_SERVICE_ORDER)
-public class ProjectDataServiceImpl implements ProjectDataService<ProjectData, Project> {
+public class ProjectDataServiceImpl extends AbstractProjectDataService<ProjectData, Project> {
  
  @NotNull
  @Override
@@ -44,7 +46,10 @@ public class ProjectDataServiceImpl implements ProjectDataService<ProjectData, P
  }

  @Override
-  public void importData(@NotNull Collection<DataNode<ProjectData>> toImport, @NotNull Project project, boolean synchronous) {
+  public void importData(@NotNull Collection<DataNode<ProjectData>> toImport,
+                         @Nullable ProjectData projectData,
+                         @NotNull final Project project,
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    // root project can be marked as ignored
    if(toImport.isEmpty()) return;

@@ -52,31 +57,25 @@ public class ProjectDataServiceImpl implements ProjectDataService<ProjectData, P
      throw new IllegalArgumentException(String.format("Expected to get a single project but got %d: %s", toImport.size(), toImport));
    }
    DataNode<ProjectData> node = toImport.iterator().next();
-    ProjectData projectData = node.getData();
+    assert projectData == node.getData();

    if (!ExternalSystemApiUtil.isOneToOneMapping(project, node)) {
      return;
    }
    
    if (!project.getName().equals(projectData.getInternalName())) {
-      renameProject(projectData.getInternalName(), projectData.getOwner(), project, synchronous);
+      renameProject(projectData.getInternalName(), projectData.getOwner(), project);
    }
  }

-  @Override
-  public void removeData(@NotNull Collection<? extends Project> toRemove, @NotNull Project project, boolean synchronous) {
-  }
-
-  @SuppressWarnings("MethodMayBeStatic")
-  public void renameProject(@NotNull final String newName,
-                            @NotNull final ProjectSystemId externalSystemId,
-                            @NotNull final Project project,
-                            boolean synchronous)
+  private static void renameProject(@NotNull final String newName,
+                                    @NotNull final ProjectSystemId externalSystemId,
+                                    @NotNull final Project project)
  {
    if (!(project instanceof ProjectEx) || newName.equals(project.getName())) {
      return;
    }
-    ExternalSystemApiUtil.executeProjectChangeAction(synchronous, new DisposeAwareProjectChange(project) {
+    ExternalSystemApiUtil.executeProjectChangeAction(true, new DisposeAwareProjectChange(project) {
      @Override
      public void execute() {
        String oldName = project.getName();
@@ -4,7 +4,6 @@ import com.intellij.ide.util.projectWizard.WizardContext;
 import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.components.PersistentStateComponent;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.ExternalSystemDataKeys;
@@ -13,8 +12,9 @@ import com.intellij.openapi.externalSystem.model.internal.InternalExternalProjec
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.service.execution.ProgressExecutionMode;
 import com.intellij.openapi.externalSystem.service.project.ExternalProjectRefreshCallback;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacadeImpl;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
+import com.intellij.openapi.externalSystem.service.project.IdeUIModifiableModelsProvider;
 import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManager;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
 import com.intellij.openapi.externalSystem.service.settings.AbstractImportFromExternalSystemControl;
@@ -30,6 +30,7 @@ import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.project.ProjectManager;
+import com.intellij.openapi.roots.ui.configuration.ModulesConfigurator;
 import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.io.FileUtil;
@@ -125,22 +126,17 @@ public abstract class AbstractExternalProjectImportBuilder<C extends AbstractImp
    boolean isFromUI = model != null;

    final List<Module> modules = ContainerUtil.newSmartList();
-    final PlatformFacade platformFacade = isFromUI ? new PlatformFacadeImpl() {
+    final IdeModifiableModelsProvider modelsProvider = isFromUI ? new IdeUIModifiableModelsProvider(
+      project, model, (ModulesConfigurator)modulesProvider, artifactModel) {
      @NotNull
      @Override
-      public Collection<Module> getModules(@NotNull Project project) {
-        return ContainerUtil.list(modulesProvider.getModules());
-      }
-
-      @Override
-      public Module newModule(Project project, @NotNull @NonNls String filePath, String moduleTypeId) {
-        final Module module = model.newModule(filePath, moduleTypeId);
-        // set module type id explicitly otherwise it can not be set if there is an existing module (with the same filePath) and w/o 'type' attribute
-        module.setOption(Module.ELEMENT_TYPE, moduleTypeId);
+      public Module newModule(@NotNull @NonNls String filePath,
+                              String moduleTypeId) {
+        final Module module = super.newModule(filePath, moduleTypeId);
        modules.add(module);
        return module;
      }
-    } : ServiceManager.getService(PlatformFacade.class);
+    } : new IdeModifiableModelsProviderImpl(project);
    AbstractExternalSystemSettings systemSettings = ExternalSystemApiUtil.getSettings(project, myExternalSystemId);
    final ExternalProjectSettings projectSettings = getCurrentExternalProjectSettings();

@@ -164,7 +160,7 @@ public abstract class AbstractExternalProjectImportBuilder<C extends AbstractImp
        dialog.dispose();
      }

-      myProjectDataManager.importData(externalProjectNode, project, platformFacade, true);
+      myProjectDataManager.importData(externalProjectNode, project, modelsProvider, true);
      myExternalProjectNode = null;

      // resolve dependencies
@@ -16,12 +16,10 @@
 package com.intellij.openapi.externalSystem.service.task;

 import com.intellij.openapi.externalSystem.model.DataNode;
-import com.intellij.openapi.externalSystem.model.ExternalSystemDataKeys;
 import com.intellij.openapi.externalSystem.model.project.ExternalEntityData;
-import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataService;
-import com.intellij.openapi.externalSystem.service.task.ui.ExternalSystemTasksTreeModel;
-import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
-import com.intellij.openapi.externalSystem.util.ExternalSystemUtil;
+import com.intellij.openapi.externalSystem.model.project.ProjectData;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -32,25 +30,18 @@ import java.util.Collection;
 * @author Denis Zhdanov
 * @since 5/15/13 1:32 PM
 */
-public abstract class AbstractToolWindowService<T extends ExternalEntityData> implements ProjectDataService<T, Void> {
-  
+public abstract class AbstractToolWindowService<T extends ExternalEntityData> extends AbstractProjectDataService<T, Void> {
+
  @Override
-  public void importData(@NotNull final Collection<DataNode<T>> toImport, @NotNull final Project project, boolean synchronous) {
+  public void importData(@NotNull final Collection<DataNode<T>> toImport,
+                         @Nullable ProjectData projectData,
+                         @NotNull final Project project,
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty()) {
      return;
    }
-    ExternalSystemApiUtil.executeOnEdt(false, new Runnable() {
-      @Override
-      public void run() {
-        processData(toImport, project);
-      }
-    });
+    processData(toImport, project);
  }

-  protected abstract void processData(@NotNull Collection<DataNode<T>> nodes,
-                                      @NotNull Project project);
-
-  @Override
-  public void removeData(@NotNull Collection<? extends Void> toRemove, @NotNull Project project, boolean synchronous) {
-  }
+  protected abstract void processData(@NotNull Collection<DataNode<T>> nodes, @NotNull Project project);
 }
@@ -18,6 +18,7 @@ package com.intellij.openapi.externalSystem.service.ui;
 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.actionSystem.ActionToolbarPosition;
 import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.externalSystem.ExternalSystemUiAware;
 import com.intellij.openapi.externalSystem.importing.ExternalProjectStructureCustomizer;
@@ -31,9 +32,12 @@ import com.intellij.openapi.externalSystem.model.project.ModuleDependencyData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
+import com.intellij.openapi.externalSystem.util.ExternalSystemBundle;
 import com.intellij.openapi.externalSystem.util.ExternalSystemUiUtil;
-import com.intellij.openapi.project.DumbModePermission;
-import com.intellij.openapi.project.DumbService;
+import com.intellij.openapi.externalSystem.util.ExternalSystemUtil;
+import com.intellij.openapi.progress.PerformInBackgroundOption;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
@@ -223,9 +227,19 @@ public class ExternalProjectDataSelectorDialog extends DialogWrapper {
        });
        projectStructure.setIgnored(notIgnoredNode == null);

-        DumbService.allowStartingDumbModeInside(DumbModePermission.MAY_START_BACKGROUND, new Runnable() {
+        // execute when current dialog is closed
+        ExternalSystemUtil.invokeLater(myProject, ModalityState.NON_MODAL, new Runnable() {
+          @Override
          public void run() {
-            ServiceManager.getService(ProjectDataManager.class).importData(projectStructure, myProject, true);
+            final ProjectData projectData = projectStructure.getData();
+            String title = ExternalSystemBundle.message(
+              "progress.refresh.text", projectData.getExternalName(), projectData.getOwner().getReadableName());
+            new Task.Backgroundable(myProject, title, true, PerformInBackgroundOption.DEAF) {
+              @Override
+              public void run(@NotNull ProgressIndicator indicator) {
+                ServiceManager.getService(ProjectDataManager.class).importData(projectStructure, myProject, false);
+              }
+            }.queue();
          }
        });
      }
@@ -51,8 +51,6 @@ import com.intellij.openapi.externalSystem.service.internal.ExternalSystemResolv
 import com.intellij.openapi.externalSystem.service.notification.ExternalSystemNotificationManager;
 import com.intellij.openapi.externalSystem.service.notification.NotificationSource;
 import com.intellij.openapi.externalSystem.service.project.ExternalProjectRefreshCallback;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
-import com.intellij.openapi.externalSystem.service.project.ProjectStructureHelper;
 import com.intellij.openapi.externalSystem.service.project.manage.ExternalProjectsManager;
 import com.intellij.openapi.externalSystem.service.project.manage.ExternalSystemTaskActivator;
 import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataManager;
@@ -67,8 +65,6 @@ import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.progress.util.AbstractProgressIndicatorExBase;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Pair;
@@ -97,7 +93,6 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 import java.io.IOException;
 import java.util.Collection;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;

@@ -301,149 +296,6 @@ public class ExternalSystemUtil {
    return timeStamp;
  }

-  //public static void processOrphanModules(@NotNull final Project project,
-  //                                        @NotNull final ProjectSystemId projectSystemId,
-  //                                        @NotNull final String externalProjectPath) {
-  //  final ExternalProjectInfo externalProjectInfo = getExternalProjectInfo(project, projectSystemId, externalProjectPath);
-  //  if (externalProjectInfo != null) {
-  //    Collection<DataNode<ModuleData>> moduleNodes = ExternalSystemApiUtil.findAllRecursively(
-  //      externalProjectInfo.getExternalProjectStructure(), ProjectKeys.MODULE);
-  //
-  //    processOrphanModules(project, moduleNodes);
-  //  }
-  //}
-  //
-  //public static void processOrphanModules(@NotNull Project project, @NotNull Collection<DataNode<ModuleData>> toImport) {
-  //  if (project.isDisposed()) return;
-  //  if (ExternalSystemDebugEnvironment.DEBUG_ORPHAN_MODULES_PROCESSING) {
-  //    //LOG.info(String.format(
-  //    //  "Checking for orphan modules. External paths returned by external system: '%s'", myExternalModulePaths
-  //    //));
-  //  }
-  //  PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class);
-  //  MultiMap<ProjectSystemId, Module> orphanIdeModules = MultiMap.create();
-  //
-  //  final MultiMap<DataNode<ProjectData>, DataNode<ModuleData>> grouped = ExternalSystemApiUtil.groupBy(toImport, ProjectKeys.PROJECT);
-  //
-  //  for (DataNode<ProjectData> node : grouped.keySet()) {
-  //    for (Module module : platformFacade.getModules(project)) {
-  //      final ProjectData projectData = node.getData();
-  //      if (!ExternalSystemApiUtil.isExternalSystemAwareModule(projectData.getOwner(), module)) continue;
-  //
-  //      final String rootProjectPath = ExternalSystemApiUtil.getExternalRootProjectPath(module);
-  //      if (projectData.getLinkedExternalProjectPath().equals(rootProjectPath)) {
-  //        final String projectPath = ExternalSystemApiUtil.getExternalProjectPath(module);
-  //        final String projectId = ExternalSystemApiUtil.getExternalProjectId(module);
-  //        final DataNode<ModuleData> found = ContainerUtil.find(grouped.get(node), new Condition<DataNode<ModuleData>>() {
-  //          @Override
-  //          public boolean value(DataNode<ModuleData> node) {
-  //            final ModuleData moduleData = node.getData();
-  //            return moduleData.getId().equals(projectId) &&
-  //                   moduleData.getLinkedExternalProjectPath().equals(projectPath);
-  //          }
-  //        });
-  //
-  //        if (found == null || found.isIgnored()) {
-  //          orphanIdeModules.putValue(projectData.getOwner(), module);
-  //        }
-  //      }
-  //    }
-  //  }
-  //
-  //  if (!orphanIdeModules.isEmpty()) {
-  //    for (Map.Entry<ProjectSystemId, Collection<Module>> entry : orphanIdeModules.entrySet()) {
-  //      ruleOrphanModules(new SmartList<Module>(entry.getValue()), project, entry.getKey());
-  //    }
-  //  }
-  //}
-  //
-  //public static void ruleOrphanModules(@NotNull final List<Module> orphanModules,
-  //                                     @NotNull final Project project,
-  //                                     @NotNull final ProjectSystemId externalSystemId) {
-  //  //noinspection unchecked
-  //  ruleOrphanModules(orphanModules, project, externalSystemId, Consumer.EMPTY_CONSUMER);
-  //}
-
-  ///**
-  // * There is a possible case that an external module has been un-linked from ide project. There are two ways to process
-  // * ide modules which correspond to that external project:
-  // * <pre>
-  // * <ol>
-  // *   <li>Remove them from ide project as well;</li>
-  // *   <li>Keep them at ide project as well;</li>
-  // * </ol>
-  // * </pre>
-  // * This method handles that situation, i.e. it asks a user what should be done and acts accordingly.
-  // *
-  // * @param orphanModules     modules which correspond to the un-linked external project
-  // * @param project           current ide project
-  // * @param externalSystemId  id of the external system which project has been un-linked from ide project
-  // */
-  //public static void ruleOrphanModules(@NotNull final List<Module> orphanModules,
-  //                                     @NotNull final Project project,
-  //                                     @NotNull final ProjectSystemId externalSystemId,
-  //                                     @NotNull final Consumer<Boolean> result)
-  //{
-  //  UIUtil.invokeLaterIfNeeded(new Runnable() {
-  //    @Override
-  //    public void run() {
-  //
-  //      final JPanel content = new JPanel(new GridBagLayout());
-  //      content.add(new JLabel(ExternalSystemBundle.message("orphan.modules.text", externalSystemId.getReadableName())),
-  //                  ExternalSystemUiUtil.getFillLineConstraints(0));
-  //
-  //      final CheckBoxList<Module> orphanModulesList = new CheckBoxList<Module>();
-  //      orphanModulesList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
-  //      orphanModulesList.setItems(orphanModules, new Function<Module, String>() {
-  //        @Override
-  //        public String fun(Module module) {
-  //          return module.getName();
-  //        }
-  //      });
-  //      for (Module module : orphanModules) {
-  //        orphanModulesList.setItemSelected(module, true);
-  //      }
-  //      orphanModulesList.setBorder(IdeBorderFactory.createEmptyBorder(8));
-  //      content.add(orphanModulesList, ExternalSystemUiUtil.getFillLineConstraints(0));
-  //      content.setBorder(IdeBorderFactory.createEmptyBorder(0, 0, 8, 0));
-  //
-  //      DialogWrapper dialog = new DialogWrapper(project) {
-  //
-  //        {
-  //          setTitle(ExternalSystemBundle.message("import.title", externalSystemId.getReadableName()));
-  //          init();
-  //        }
-  //
-  //        @Nullable
-  //        @Override
-  //        protected JComponent createCenterPanel() {
-  //          return new JBScrollPane(content);
-  //        }
-  //      };
-  //      boolean ok = dialog.showAndGet();
-  //      result.consume(ok);
-  //      if (!ok) {
-  //        return;
-  //      }
-  //
-  //      List<Module> toRemove = ContainerUtilRt.newArrayList();
-  //      for (int i = 0; i < orphanModules.size(); i++) {
-  //        Module module = orphanModules.get(i);
-  //        if (orphanModulesList.isItemSelected(i)) {
-  //          toRemove.add(module);
-  //        }
-  //        else {
-  //          ModuleDataService.unlinkModuleFromExternalSystem(module);
-  //        }
-  //      }
-  //
-  //      if (!toRemove.isEmpty()) {
-  //        ServiceManager.getService(ProjectDataManager.class).removeData(ProjectKeys.MODULE, toRemove, project, true);
-  //      }
-  //    }
-  //  });
-  //}
-
  @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
  @Nullable
  private static String extractDetails(@NotNull Throwable e) {
@@ -459,16 +311,6 @@ public class ExternalSystemUtil {
                                    @NotNull final String externalProjectPath,
                                    final boolean isPreviewMode,
                                    @NotNull final ProgressExecutionMode progressExecutionMode) {
-    final PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class);
-    refreshProject(project, platformFacade, externalSystemId, externalProjectPath, isPreviewMode, progressExecutionMode);
-  }
-
-  public static void refreshProject(@NotNull final Project project,
-                                    @NotNull final PlatformFacade platformFacade,
-                                    @NotNull final ProjectSystemId externalSystemId,
-                                    @NotNull final String externalProjectPath,
-                                    final boolean isPreviewMode,
-                                    @NotNull final ProgressExecutionMode progressExecutionMode) {
    refreshProject(project, externalSystemId, externalProjectPath, new ExternalProjectRefreshCallback() {
      @Override
      public void onSuccess(@Nullable final DataNode<ProjectData> externalProject) {
@@ -476,7 +318,7 @@ public class ExternalSystemUtil {
          return;
        }
        final boolean synchronous = progressExecutionMode == ProgressExecutionMode.MODAL_SYNC;
-        ServiceManager.getService(ProjectDataManager.class).importData(externalProject, project, platformFacade, synchronous);
+        ServiceManager.getService(ProjectDataManager.class).importData(externalProject, project, synchronous);
      }

      @Override
@@ -1014,31 +856,10 @@ public class ExternalSystemUtil {
      }

      myProjectDataManager.importData(externalProject, myProject, true);
-      processOrphanProjectLibraries();
    }

    @Override
    public void onFailure(@NotNull String errorMessage, @Nullable String errorDetails) {
    }
-
-    private void processOrphanProjectLibraries() {
-      final PlatformFacade platformFacade = ServiceManager.getService(PlatformFacade.class);
-      final List<Library> orphanIdeLibraries = ContainerUtilRt.newArrayList();
-
-      platformFacade.updateLibraryTable(myProject, new Consumer<LibraryTable.ModifiableModel>() {
-        @Override
-        public void consume(LibraryTable.ModifiableModel modifiableModel) {
-          for (Library library : modifiableModel.getLibraries()) {
-            if (!ExternalSystemApiUtil.isExternalSystemLibrary(library, myExternalSystemId)) continue;
-            if (ProjectStructureHelper.isOrphanProjectLibrary(library, platformFacade.getModules(myProject))) {
-              orphanIdeLibraries.add(library);
-            }
-          }
-          for (Library orphanIdeLibrary : orphanIdeLibraries) {
-            modifiableModel.removeLibrary(orphanIdeLibrary);
-          }
-        }
-      });
-    }
  }
 }
@@ -17,14 +17,13 @@ package com.intellij.openapi.externalSystem.view;

 import com.intellij.icons.AllIcons;
 import com.intellij.ide.projectView.PresentationData;
-import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.externalSystem.model.DataNode;
 import com.intellij.openapi.externalSystem.model.Key;
 import com.intellij.openapi.externalSystem.model.ProjectKeys;
 import com.intellij.openapi.externalSystem.model.project.LibraryDependencyData;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ModuleDependencyData;
-import com.intellij.openapi.externalSystem.service.project.ProjectStructureHelper;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemSettings;
 import com.intellij.openapi.externalSystem.settings.ExternalProjectSettings;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
@@ -41,7 +40,6 @@ import org.jetbrains.annotations.Nullable;

 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;

 /**
@@ -245,7 +243,7 @@ public class ExternalSystemViewDefaultContributor extends ExternalSystemViewCont
      if (data == null) return null;
      final Project project = getProject();
      if (project == null) return null;
-      return ServiceManager.getService(ProjectStructureHelper.class).findIdeModuleOrderEntry(data, project);
+      return new IdeModifiableModelsProviderImpl(project).findIdeModuleOrderEntry(data);
    }
  }
 }
@@ -15,17 +15,12 @@
 */
 package com.intellij.openapi.externalSystem.service.project

-import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.externalSystem.model.DataNode
 import com.intellij.openapi.externalSystem.model.project.ProjectData
 import com.intellij.openapi.externalSystem.test.AbstractExternalSystemTest
 import com.intellij.openapi.externalSystem.test.ExternalSystemTestUtil
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
-import com.intellij.openapi.roots.JavadocOrderRootType
-import com.intellij.openapi.roots.LibraryOrderEntry
-import com.intellij.openapi.roots.ModuleSourceOrderEntry
-import com.intellij.openapi.roots.OrderEntry
-import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.roots.*
 import com.intellij.openapi.util.io.FileUtil

 import static com.intellij.openapi.externalSystem.model.project.ExternalSystemSourceType.*
@@ -44,12 +39,11 @@ public class ExternalProjectServiceTest extends AbstractExternalSystemTest {

    applyProjectState([projectNode, projectNode])

-    def helper = ServiceManager.getService(ProjectStructureHelper.class)
-    def module = helper.findIdeModule('module', project)
+    def modelsProvider = new IdeModifiableModelsProviderImpl(project);
+    def module = modelsProvider.findIdeModule('module')
    assertNotNull(module)
-    
-    def facade = ServiceManager.getService(PlatformFacade.class)
-    def entries = facade.getOrderEntries(module)
+
+    def entries = modelsProvider.getOrderEntries(module)
    def dependencies = [:].withDefault { 0 }
    for (OrderEntry entry : entries) {
      if (entry instanceof LibraryOrderEntry) {
@@ -86,12 +80,10 @@ public class ExternalProjectServiceTest extends AbstractExternalSystemTest {

    applyProjectState([projectNodeInitial, projectNodeRefreshed])

-    def helper = ServiceManager.getService(ProjectStructureHelper.class)
-    def module = helper.findIdeModule('module', project)
+    def modelsProvider = new IdeModifiableModelsProviderImpl(project);
+    def module = modelsProvider.findIdeModule('module')
    assertNotNull(module)
-
-    def facade = ServiceManager.getService(PlatformFacade.class)
-    def entries = facade.getOrderEntries(module)
+    def entries = modelsProvider.getOrderEntries(module)
    def folders = [:].withDefault { 0 }
    for (OrderEntry entry : entries) {
      if (entry instanceof ModuleSourceOrderEntry) {
@@ -128,12 +120,11 @@ public class ExternalProjectServiceTest extends AbstractExternalSystemTest {
            lib('lib1', level: 'module', bin: [libBinPath.absolutePath], src: [libSrcPath.absolutePath],  doc: [libDocPath.absolutePath]) } } }
    ])

-    def helper = ServiceManager.getService(ProjectStructureHelper.class)
-    def module = helper.findIdeModule('module', project)
+    def modelsProvider = new IdeModifiableModelsProviderImpl(project);
+    def module = modelsProvider.findIdeModule('module')
    assertNotNull(module)

-    def facade = ServiceManager.getService(PlatformFacade.class)
-    def entries = facade.getOrderEntries(module)
+    def entries = modelsProvider.getOrderEntries(module)
    def dependencies = [:].withDefault { 0 }
    entries.each { OrderEntry entry ->
      if (entry instanceof LibraryOrderEntry) {
@@ -116,7 +116,9 @@ class ExternalProjectBuilder extends BuilderSupport {
    ['bin': LibraryPathType.BINARY, 'src': LibraryPathType.SOURCE, 'doc': LibraryPathType.DOC].each {
      key, type -> attributes[key]?.each { result.addPath(type, it as String) }
    }
-    projectNode.createChild(ProjectKeys.LIBRARY, result)
+    if (attributes.level != 'module') {
+      projectNode.createChild(ProjectKeys.LIBRARY, result)
+    }
    result
  }

@@ -15,11 +15,10 @@
 */
 package com.intellij.openapi.externalSystem.test

-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemLocalSettings
 import com.intellij.openapi.project.Project
 import org.jetbrains.annotations.NotNull
+
 /**
 * @author Denis Zhdanov
 * @since 8/8/13 5:21 PM
@@ -27,6 +26,6 @@ import org.jetbrains.annotations.NotNull
 class TestExternalSystemLocalSettings extends AbstractExternalSystemLocalSettings {

  TestExternalSystemLocalSettings(@NotNull Project project) {
-    super(ExternalSystemTestUtil.TEST_EXTERNAL_SYSTEM_ID, project, ServiceManager.getService(project, PlatformFacade.class))
+    super(ExternalSystemTestUtil.TEST_EXTERNAL_SYSTEM_ID, project)
  }
 }
@@ -12,11 +12,8 @@
    <applicationService
        serviceInterface="com.intellij.openapi.externalSystem.service.notification.ExternalSystemProgressNotificationManager"
        serviceImplementation="com.intellij.openapi.externalSystem.service.remote.ExternalSystemProgressNotificationManagerImpl"/>
-    <applicationService serviceInterface="com.intellij.openapi.externalSystem.service.project.PlatformFacade"
-                        serviceImplementation="com.intellij.openapi.externalSystem.service.project.PlatformFacadeImpl"/>
    <applicationService serviceInterface="com.intellij.openapi.externalSystem.service.project.ExternalLibraryPathTypeMapper"
                        serviceImplementation="com.intellij.openapi.externalSystem.service.project.ExternalLibraryPathTypeMapperImpl"/>
-    <applicationService serviceImplementation="com.intellij.openapi.externalSystem.service.project.ProjectStructureHelper"/>
    <applicationService serviceImplementation="com.intellij.openapi.externalSystem.service.internal.ExternalSystemProcessingManager"/>
    <projectService serviceImplementation="com.intellij.openapi.externalSystem.service.notification.ExternalSystemNotificationManager"/>
    <externalSystemNotificationExtension implementation="com.intellij.openapi.externalSystem.service.notification.ExternalSystemNotificationExtensionImpl" />
@@ -28,7 +28,7 @@ import com.intellij.packaging.artifacts.Artifact;
 import com.intellij.util.io.ZipUtil;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.maven.importing.FacetImporter;
-import org.jetbrains.idea.maven.importing.MavenModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import org.jetbrains.idea.maven.importing.MavenRootModelAdapter;
 import org.jetbrains.idea.maven.model.MavenArtifact;
 import org.jetbrains.idea.maven.model.MavenArtifactInfo;
@@ -93,7 +93,7 @@ public class AppEngineFacetImporter extends FacetImporter<AppEngineFacet, AppEng
  }

  @Override
-  protected void reimportFacet(MavenModifiableModelsProvider modelsProvider,
+  protected void reimportFacet(IdeModifiableModelsProvider modelsProvider,
                               Module module,
                               MavenRootModelAdapter rootModel,
                               AppEngineFacet facet,
@@ -108,7 +108,7 @@ public class AppEngineFacetImporter extends FacetImporter<AppEngineFacet, AppEng
      facet.getConfiguration().setSdkHomePath(FileUtil.toSystemIndependentName(mavenProject.getLocalRepository().getPath()) + relativePath);
      AppEngineWebIntegration.getInstance().setupDevServer(facet.getSdk());
      final String artifactName = module.getName() + ":war exploded";
-      final Artifact webArtifact = modelsProvider.getArtifactModel().findArtifact(artifactName);
+      final Artifact webArtifact = modelsProvider.getModifiableArtifactModel().findArtifact(artifactName);
      AppEngineWebIntegration.getInstance().setupRunConfiguration(facet.getSdk(), webArtifact, module.getProject());
    }
  }
@@ -18,9 +18,9 @@ package org.jetbrains.plugins.gradle.service;
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemJdkException;
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemJdkUtil;
 import com.intellij.openapi.externalSystem.service.notification.callback.OpenExternalSystemSettingsCallback;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.JdkUtil;
 import com.intellij.openapi.projectRoots.Sdk;
@@ -83,13 +83,8 @@ public class GradleInstallationManager {
    GRADLE_ENV_PROPERTY_NAME = System.getProperty("gradle.home.env.key", "GRADLE_HOME");
  }

-  @NotNull private final PlatformFacade myPlatformFacade;
  @Nullable private Ref<File> myCachedGradleHomeFromPath;

-  public GradleInstallationManager(@NotNull PlatformFacade facade) {
-    myPlatformFacade = facade;
-  }
-
  /**
   * Allows to get file handles for the gradle binaries to use.
   *
@@ -461,7 +456,7 @@ public class GradleInstallationManager {
    if (project == null) return null;

    if(rootProjectPath == null) {
-      for (Module module : myPlatformFacade.getModules(project)) {
+      for (Module module : ModuleManager.getInstance(project).getModules()) {
        rootProjectPath = module.getOptionValue(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY);
        List<File> result = findGradleSdkClasspath(project, rootProjectPath);
        if(!result.isEmpty()) return result;
@@ -25,7 +25,8 @@ import com.intellij.openapi.externalSystem.model.project.ExternalModuleBuildClas
 import com.intellij.openapi.externalSystem.model.project.ExternalProjectBuildClasspathPojo;
 import com.intellij.openapi.externalSystem.model.project.ModuleData;
 import com.intellij.openapi.externalSystem.model.project.ProjectData;
-import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataService;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemLocalSettings;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
@@ -52,7 +53,7 @@ import java.util.*;
 * @since 8/27/13
 */
@Order(ExternalSystemConstants.UNORDERED)
-public class BuildClasspathModuleGradleDataService implements ProjectDataService<BuildScriptClasspathData, Module> {
+public class BuildClasspathModuleGradleDataService extends AbstractProjectDataService<BuildScriptClasspathData, Module> {

  private static final Logger LOG = Logger.getInstance(BuildClasspathModuleGradleDataService.class);

@@ -64,8 +65,9 @@ public class BuildClasspathModuleGradleDataService implements ProjectDataService

  @Override
  public void importData(@NotNull final Collection<DataNode<BuildScriptClasspathData>> toImport,
+                         @Nullable ProjectData projectData,
                         @NotNull final Project project,
-                         boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (toImport.isEmpty()) {
      return;
    }
@@ -156,8 +158,4 @@ public class BuildClasspathModuleGradleDataService implements ProjectDataService

    GradleBuildClasspathManager.getInstance(project).reload();
  }
-
-  @Override
-  public void removeData(@NotNull Collection<? extends Module> toRemove, @NotNull Project project, boolean synchronous) {
-  }
 }
@@ -16,8 +16,13 @@
 package org.jetbrains.plugins.gradle.service.project.data;

 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.externalSystem.model.*;
-import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataService;
+import com.intellij.openapi.externalSystem.model.DataNode;
+import com.intellij.openapi.externalSystem.model.Key;
+import com.intellij.openapi.externalSystem.model.ProjectKeys;
+import com.intellij.openapi.externalSystem.model.ProjectSystemId;
+import com.intellij.openapi.externalSystem.model.project.ProjectData;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.manage.AbstractProjectDataService;
 import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.externalSystem.util.ExternalSystemUtil;
@@ -42,7 +47,7 @@ import java.util.Map;
 * @since 7/17/2014
 */
@Order(ExternalSystemConstants.BUILTIN_SERVICE_ORDER)
-public class ExternalProjectDataService implements ProjectDataService<ExternalProject, Project> {
+public class ExternalProjectDataService extends AbstractProjectDataService<ExternalProject, Project> {
  private static final Logger LOG = Logger.getInstance(ExternalProjectDataService.class);

  @NotNull public static final Key<ExternalProject> KEY = Key.create(ExternalProject.class, ProjectKeys.TASK.getProcessingWeight() + 1);
@@ -78,8 +83,9 @@ public class ExternalProjectDataService implements ProjectDataService<ExternalPr
  }

  public void importData(@NotNull final Collection<DataNode<ExternalProject>> toImport,
+                         @Nullable ProjectData projectData,
                         @NotNull final Project project,
-                         final boolean synchronous) {
+                         @NotNull IdeModifiableModelsProvider modelsProvider) {
    if(toImport.isEmpty()) return;
    if (toImport.size() != 1) {
      throw new IllegalArgumentException(
@@ -88,10 +94,6 @@ public class ExternalProjectDataService implements ProjectDataService<ExternalPr
    saveExternalProject(toImport.iterator().next().getData());
  }

-  @Override
-  public void removeData(@NotNull final Collection<? extends Project> modules, @NotNull Project project, boolean synchronous) {
-  }
-
  @Nullable
  public ExternalProject getRootExternalProject(@NotNull ProjectSystemId systemId, @NotNull File projectRootDir) {
    ExternalProject externalProject = myExternalRootProjects.get(Pair.create(systemId, projectRootDir));
@@ -1,7 +1,6 @@
 package org.jetbrains.plugins.gradle.settings;

 import com.intellij.openapi.components.*;
-import com.intellij.openapi.externalSystem.service.project.PlatformFacade;
 import com.intellij.openapi.externalSystem.settings.AbstractExternalSystemLocalSettings;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
@@ -17,8 +16,8 @@ public class GradleLocalSettings extends AbstractExternalSystemLocalSettings
  implements PersistentStateComponent<AbstractExternalSystemLocalSettings.State>
 {

-  public GradleLocalSettings(@NotNull Project project, @NotNull PlatformFacade facade) {
-    super(GradleConstants.SYSTEM_ID, project, facade);
+  public GradleLocalSettings(@NotNull Project project) {
+    super(GradleConstants.SYSTEM_ID, project);
  }

  @NotNull
@@ -73,8 +73,8 @@
        <SOURCES />
      </library>
    </orderEntry>
-    <orderEntry type="module" module-name="external-system-api" />
-    <orderEntry type="module" module-name="external-system-impl" />
+    <orderEntry type="module" module-name="external-system-api" exported="" />
+    <orderEntry type="module" module-name="external-system-impl" exported="" />
    <orderEntry type="library" name="Slf4j" level="project" />
    <orderEntry type="library" name="Log4J" level="project" />
    <orderEntry type="module" module-name="util-tests" scope="TEST" />
@@ -19,6 +19,7 @@ import com.intellij.facet.*;
 import com.intellij.framework.FrameworkType;
 import com.intellij.framework.detection.DetectionExcludesConfiguration;
 import com.intellij.framework.detection.impl.FrameworkDetectionUtil;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
@@ -66,7 +67,7 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
  public void preProcess(Module module,
                         MavenProject mavenProject,
                         MavenProjectChanges changes,
-                         MavenModifiableModelsProvider modifiableModelsProvider) {
+                         IdeModifiableModelsProvider modifiableModelsProvider) {
    prepareImporter(mavenProject);

    if (!isFacetDetectionDisabled(module.getProject())) {
@@ -75,8 +76,8 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
    }
  }

-  private void ensureFacetExists(Module module, MavenProject mavenProject, MavenModifiableModelsProvider modifiableModelsProvider) {
-    ModifiableFacetModel model = modifiableModelsProvider.getFacetModel(module);
+  private void ensureFacetExists(Module module, MavenProject mavenProject, IdeModifiableModelsProvider modifiableModelsProvider) {
+    ModifiableFacetModel model = modifiableModelsProvider.getModifiableFacetModel(module);

    FACET_TYPE f = findFacet(model);
    if (f != null) return;
@@ -89,7 +90,7 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
  protected void prepareImporter(MavenProject p) {
  }

-  private void disableFacetAutodetection(Module module, MavenModifiableModelsProvider provider) {
+  private void disableFacetAutodetection(Module module, IdeModifiableModelsProvider provider) {
    final DetectionExcludesConfiguration excludesConfiguration = DetectionExcludesConfiguration.getInstance(module.getProject());
    final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(myFacetType);
    if (frameworkType != null) {
@@ -102,7 +103,7 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
  protected abstract void setupFacet(FACET_TYPE f, MavenProject mavenProject);

  @Override
-  public void process(MavenModifiableModelsProvider modifiableModelsProvider,
+  public void process(IdeModifiableModelsProvider modifiableModelsProvider,
                      Module module,
                      MavenRootModelAdapter rootModel,
                      MavenProjectsTree mavenModel,
@@ -110,7 +111,7 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
                      MavenProjectChanges changes,
                      Map<MavenProject, String> mavenProjectToModuleName,
                      List<MavenProjectsProcessorTask> postTasks) {
-    FACET_TYPE f = findFacet(modifiableModelsProvider.getFacetModel(module));
+    FACET_TYPE f = findFacet(modifiableModelsProvider.getModifiableFacetModel(module));
    if (f == null) return; // facet may has been removed between preProcess and process calls

    if (!isFacetDetectionDisabled(module.getProject())) {
@@ -128,7 +129,7 @@ public abstract class FacetImporter<FACET_TYPE extends Facet, FACET_CONFIG_TYPE
    return result;
  }

-  protected abstract void reimportFacet(MavenModifiableModelsProvider modelsProvider,
+  protected abstract void reimportFacet(IdeModifiableModelsProvider modelsProvider,
                                        Module module,
                                        MavenRootModelAdapter rootModel,
                                        FACET_TYPE facet,
@@ -1,5 +1,6 @@
 package org.jetbrains.idea.maven.importing;

+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.Module;
 import com.intellij.util.PairConsumer;
 import org.jdom.Element;
@@ -26,11 +27,11 @@ public abstract class GroovyImporter extends MavenImporter {
  public void preProcess(Module module,
                         MavenProject mavenProject,
                         MavenProjectChanges changes,
-                         MavenModifiableModelsProvider modifiableModelsProvider) {
+                         IdeModifiableModelsProvider modifiableModelsProvider) {
  }

  @Override
-  public void process(MavenModifiableModelsProvider modifiableModelsProvider, Module module, MavenRootModelAdapter rootModel,
+  public void process(IdeModifiableModelsProvider modifiableModelsProvider, Module module, MavenRootModelAdapter rootModel,
                      MavenProjectsTree mavenModel,
                      MavenProject mavenProject,
                      MavenProjectChanges changes,
@@ -1,219 +0,0 @@
-/*
- * Copyright 2000-2009 JetBrains s.r.o.
- *
- * 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
- *
- * http://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 org.jetbrains.idea.maven.importing;
-
-import com.intellij.facet.Facet;
-import com.intellij.facet.FacetModel;
-import com.intellij.facet.FacetTypeId;
-import com.intellij.facet.ModifiableFacetModel;
-import com.intellij.openapi.module.ModifiableModuleModel;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.ModuleRootModel;
-import com.intellij.openapi.roots.OrderRootType;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
-import com.intellij.openapi.roots.ui.configuration.FacetsProvider;
-import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.packaging.artifacts.ArtifactModel;
-import com.intellij.packaging.artifacts.ModifiableArtifactModel;
-import com.intellij.packaging.elements.ManifestFileProvider;
-import com.intellij.packaging.elements.PackagingElementResolvingContext;
-import com.intellij.packaging.impl.artifacts.DefaultManifestFileProvider;
-import gnu.trove.THashMap;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.IdentityHashMap;
-import java.util.Map;
-
-public abstract class MavenBaseModifiableModelsProvider implements MavenModifiableModelsProvider {
-  protected ModifiableModuleModel myModuleModel;
-  protected Map<Module, ModifiableRootModel> myRootModels = new THashMap<Module, ModifiableRootModel>();
-  protected Map<Module, ModifiableFacetModel> myFacetModels = new THashMap<Module, ModifiableFacetModel>();
-  protected Map<Library, Library.ModifiableModel> myLibraryModels = new IdentityHashMap<Library, Library.ModifiableModel>();
-  protected ModifiableArtifactModel myArtifactModel;
-  protected final Project myProject;
-  private MavenBaseModifiableModelsProvider.MyPackagingElementResolvingContext myPackagingElementResolvingContext;
-  private final ArtifactExternalDependenciesImporter myArtifactExternalDependenciesImporter;
-
-  public MavenBaseModifiableModelsProvider(Project project) {
-    myProject = project;
-    myArtifactExternalDependenciesImporter = new ArtifactExternalDependenciesImporter();
-  }
-
-  public ModifiableModuleModel getModuleModel() {
-    if (myModuleModel == null) {
-      myModuleModel = doGetModuleModel();
-    }
-    return myModuleModel;
-  }
-
-  public ModifiableRootModel getRootModel(@NotNull Module module) {
-    ModifiableRootModel result = myRootModels.get(module);
-    if (result == null) {
-      result = doGetRootModel(module);
-      myRootModels.put(module, result);
-    }
-    return result;
-  }
-
-  public ModifiableFacetModel getFacetModel(Module module) {
-    ModifiableFacetModel result = myFacetModels.get(module);
-    if (result == null) {
-      result = doGetFacetModel(module);
-      myFacetModels.put(module, result);
-    }
-    return result;
-  }
-
-  public ModifiableArtifactModel getArtifactModel() {
-    if (myArtifactModel == null) {
-      myArtifactModel = doGetArtifactModel();
-    }
-    return myArtifactModel;
-  }
-
-  public PackagingElementResolvingContext getPackagingElementResolvingContext() {
-    if (myPackagingElementResolvingContext == null) {
-      myPackagingElementResolvingContext = new MyPackagingElementResolvingContext();
-    }
-    return myPackagingElementResolvingContext;
-  }
-
-  public ArtifactExternalDependenciesImporter getArtifactExternalDependenciesImporter() {
-    return myArtifactExternalDependenciesImporter;
-  }
-
-  public Library.ModifiableModel getLibraryModel(Library library) {
-    Library.ModifiableModel result = myLibraryModels.get(library);
-    if (result == null) {
-      result = doGetLibraryModel(library);
-      myLibraryModels.put(library, result);
-    }
-    return result;
-  }
-
-  @NotNull
-  @Override
-  public String[] getLibraryUrls(@NotNull Library library, @NotNull OrderRootType type) {
-    final Library.ModifiableModel model = myLibraryModels.get(library);
-    if (model != null) {
-      return model.getUrls(type);
-    }
-    return library.getUrls(type);
-  }
-
-  protected abstract ModifiableArtifactModel doGetArtifactModel();
-
-  protected abstract ModifiableModuleModel doGetModuleModel();
-
-  protected abstract ModifiableRootModel doGetRootModel(Module module);
-
-  protected abstract ModifiableFacetModel doGetFacetModel(Module module);
-
-  protected abstract Library.ModifiableModel doGetLibraryModel(Library library);
-
-  public Module[] getModules() {
-    return getModuleModel().getModules();
-  }
-
-  protected void processExternalArtifactDependencies() {
-    myArtifactExternalDependenciesImporter.applyChanges(getArtifactModel(), getPackagingElementResolvingContext());
-  }
-
-  public VirtualFile[] getContentRoots(Module module) {
-    return getRootModel(module).getContentRoots();
-  }
-
-  private class MyPackagingElementResolvingContext implements PackagingElementResolvingContext {
-    private final ModulesProvider myModulesProvider = new MavenModulesProvider();
-    private final MavenFacetsProvider myFacetsProvider = new MavenFacetsProvider();
-    private final DefaultManifestFileProvider myManifestFileProvider = new DefaultManifestFileProvider(this);
-
-    @NotNull
-    public Project getProject() {
-      return myProject;
-    }
-
-    @NotNull
-    public ArtifactModel getArtifactModel() {
-      return MavenBaseModifiableModelsProvider.this.getArtifactModel();
-    }
-
-    @NotNull
-    public ModulesProvider getModulesProvider() {
-      return myModulesProvider;
-    }
-
-    @NotNull
-    public FacetsProvider getFacetsProvider() {
-      return myFacetsProvider;
-    }
-
-    public Library findLibrary(@NotNull String level, @NotNull String libraryName) {
-      if (level.equals(LibraryTablesRegistrar.PROJECT_LEVEL)) {
-        return getLibraryByName(libraryName);
-      }
-      final LibraryTable table = LibraryTablesRegistrar.getInstance().getLibraryTableByLevel(level, myProject);
-      return table != null ? table.getLibraryByName(libraryName) : null;
-    }
-
-    @NotNull
-    @Override
-    public ManifestFileProvider getManifestFileProvider() {
-      return myManifestFileProvider;
-    }
-  }
-
-  private class MavenModulesProvider implements ModulesProvider {
-    @NotNull
-    public Module[] getModules() {
-      return getModuleModel().getModules();
-    }
-
-    public Module getModule(String name) {
-      return getModuleModel().findModuleByName(name);
-    }
-
-    public ModuleRootModel getRootModel(@NotNull Module module) {
-      return MavenBaseModifiableModelsProvider.this.getRootModel(module);
-    }
-
-    public FacetModel getFacetModel(@NotNull Module module) {
-      return MavenBaseModifiableModelsProvider.this.getFacetModel(module);
-    }
-  }
-
-  private class MavenFacetsProvider implements FacetsProvider {
-    @NotNull
-    public Facet[] getAllFacets(Module module) {
-      return getFacetModel(module).getAllFacets();
-    }
-
-    @NotNull
-    public <F extends Facet> Collection<F> getFacetsByType(Module module, FacetTypeId<F> type) {
-      return getFacetModel(module).getFacetsByType(type);
-    }
-
-    public <F extends Facet> F findFacet(Module module, FacetTypeId<F> type, String name) {
-      return getFacetModel(module).findFacet(type, name);
-    }
-  }
-}
@@ -1,149 +0,0 @@
-/*
- * Copyright 2000-2015 JetBrains s.r.o.
- *
- * 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
- *
- * http://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 org.jetbrains.idea.maven.importing;
-
-import com.intellij.facet.FacetManager;
-import com.intellij.facet.ModifiableFacetModel;
-import com.intellij.openapi.application.*;
-import com.intellij.openapi.module.ModifiableModuleModel;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModifiableRootModel;
-import com.intellij.openapi.roots.ModuleRootManager;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
-import com.intellij.openapi.roots.impl.ModifiableModelCommitter;
-import com.intellij.openapi.roots.impl.libraries.ProjectLibraryTable;
-import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.roots.libraries.LibraryTable;
-import com.intellij.packaging.artifacts.ArtifactManager;
-import com.intellij.packaging.artifacts.ModifiableArtifactModel;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-
-public class MavenDefaultModifiableModelsProvider extends MavenBaseModifiableModelsProvider {
-  private final LibraryTable.ModifiableModel myLibrariesModel;
-
-  public MavenDefaultModifiableModelsProvider(Project project) {
-    super(project);
-    myLibrariesModel = ProjectLibraryTable.getInstance(myProject).getModifiableModel();
-  }
-
-  @Override
-  protected ModifiableArtifactModel doGetArtifactModel() {
-    return new ReadAction<ModifiableArtifactModel>() {
-      protected void run(@NotNull final Result<ModifiableArtifactModel> result) {
-        result.setResult(ArtifactManager.getInstance(myProject).createModifiableModel());
-      }
-    }.execute().getResultObject();
-  }
-
-  @Override
-  protected ModifiableModuleModel doGetModuleModel() {
-    AccessToken accessToken = ApplicationManager.getApplication().acquireReadActionLock();
-    try {
-      return ModuleManager.getInstance(myProject).getModifiableModel();
-    }
-    finally {
-      accessToken.finish();
-    }
-  }
-
-  @Override
-  protected ModifiableRootModel doGetRootModel(@NotNull final Module module) {
-    return new ReadAction<ModifiableRootModel>() {
-      protected void run(@NotNull Result<ModifiableRootModel> result) throws Throwable {
-        result.setResult(ModuleRootManager.getInstance(module).getModifiableModel());
-      }
-    }.execute().getResultObject();
-  }
-
-  @Override
-  protected ModifiableFacetModel doGetFacetModel(Module module) {
-    return FacetManager.getInstance(module).createModifiableModel();
-  }
-
-  @Override
-  public LibraryTable.ModifiableModel getProjectLibrariesModel() {
-    return myLibrariesModel;
-  }
-
-  public Library[] getAllLibraries() {
-    return myLibrariesModel.getLibraries();
-  }
-
-  public Library getLibraryByName(String name) {
-    return myLibrariesModel.getLibraryByName(name);
-  }
-
-  public Library createLibrary(String name) {
-    return myLibrariesModel.createLibrary(name);
-  }
-
-  public void removeLibrary(Library library) {
-    myLibrariesModel.removeLibrary(library);
-  }
-
-  @Override
-  protected Library.ModifiableModel doGetLibraryModel(Library library) {
-    return library.getModifiableModel();
-  }
-
-  public void commit() {
-    ((ProjectRootManagerEx)ProjectRootManager.getInstance(myProject)).mergeRootsChangesDuring(new Runnable() {
-      public void run() {
-        processExternalArtifactDependencies();
-        for (Library.ModifiableModel each : myLibraryModels.values()) {
-          each.commit();
-        }
-        myLibrariesModel.commit();
-        Collection<ModifiableRootModel> rootModels = myRootModels.values();
-
-        ModifiableRootModel[] rootModels1 = rootModels.toArray(new ModifiableRootModel[rootModels.size()]);
-        for (ModifiableRootModel model : rootModels1) {
-          assert !model.isDisposed() : "Already disposed: " + model;
-        }
-
-        if (myModuleModel != null) {
-          ModifiableModelCommitter.multiCommit(rootModels1, myModuleModel);
-        }
-
-        for (ModifiableFacetModel each : myFacetModels.values()) {
-          each.commit();
-        }
-        if (myArtifactModel != null) {
-          myArtifactModel.commit();
-        }
-      }
-    });
-  }
-
-  public void dispose() {
-    for (ModifiableRootModel each : myRootModels.values()) {
-      each.dispose();
-    }
-    myModuleModel.dispose();
-    if (myArtifactModel != null) {
-      myArtifactModel.dispose();
-    }
-  }
-
-  public ModalityState getModalityStateForQuestionDialogs() {
-    return ModalityState.NON_MODAL;
-  }
-}
@@ -19,6 +19,7 @@ import com.intellij.ide.util.projectWizard.importSources.JavaModuleSourceRoot;
 import com.intellij.ide.util.projectWizard.importSources.JavaSourceRootDetectionUtil;
 import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.WriteAction;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.project.Project;
@@ -64,7 +65,7 @@ public class MavenFoldersImporter {
        MavenProject mavenProject = manager.findProject(each);
        if (mavenProject == null) continue;

-        MavenRootModelAdapter a = new MavenRootModelAdapter(mavenProject, each, new MavenDefaultModifiableModelsProvider(project));
+        MavenRootModelAdapter a = new MavenRootModelAdapter(mavenProject, each, new IdeModifiableModelsProviderImpl(project));
        new MavenFoldersImporter(mavenProject, settings, a).config(updateTargetFoldersOnly);

        ModifiableRootModel model = a.getRootModel();
@@ -16,6 +16,7 @@
 package org.jetbrains.idea.maven.importing;

 import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleType;
 import com.intellij.openapi.module.StdModuleTypes;
@@ -138,9 +139,9 @@ public abstract class MavenImporter {
  public abstract void preProcess(Module module,
                                  MavenProject mavenProject,
                                  MavenProjectChanges changes,
-                                  MavenModifiableModelsProvider modifiableModelsProvider);
+                                  IdeModifiableModelsProvider modifiableModelsProvider);

-  public abstract void process(MavenModifiableModelsProvider modifiableModelsProvider,
+  public abstract void process(IdeModifiableModelsProvider modifiableModelsProvider,
                               Module module,
                               MavenRootModelAdapter rootModel,
                               MavenProjectsTree mavenModel,
@@ -152,7 +153,7 @@ public abstract class MavenImporter {
  public void postProcess(Module module,
                          MavenProject mavenProject,
                          MavenProjectChanges changes,
-                          MavenModifiableModelsProvider modifiableModelsProvider) {
+                          IdeModifiableModelsProvider modifiableModelsProvider) {
  }

  public boolean processChangedModulesOnly() {
@@ -21,6 +21,7 @@ import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.application.ReadAction;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleType;
 import com.intellij.openapi.roots.*;
@@ -65,7 +66,7 @@ public class MavenModuleImporter {
  private final MavenProjectChanges myMavenProjectChanges;
  private final Map<MavenProject, String> myMavenProjectToModuleName;
  private final MavenImportingSettings mySettings;
-  private final MavenModifiableModelsProvider myModifiableModelsProvider;
+  private final IdeModifiableModelsProvider myModifiableModelsProvider;
  private MavenRootModelAdapter myRootModelAdapter;

  public MavenModuleImporter(Module module,
@@ -74,7 +75,7 @@ public class MavenModuleImporter {
                             @Nullable MavenProjectChanges changes,
                             Map<MavenProject, String> mavenProjectToModuleName,
                             MavenImportingSettings settings,
-                             MavenModifiableModelsProvider modifiableModelsProvider) {
+                             IdeModifiableModelsProvider modifiableModelsProvider) {
    myModule = module;
    myMavenTree = mavenTree;
    myMavenProject = mavenProject;
@@ -332,7 +333,7 @@ public class MavenModuleImporter {
          if (library == null) {
            library = myModifiableModelsProvider.createLibrary(libraryName);
          }
-          libraryModel = myModifiableModelsProvider.getLibraryModel(library);
+          libraryModel = myModifiableModelsProvider.getModifiableLibraryModel(library);

          LibraryOrderEntry entry = myRootModelAdapter.getRootModel().addLibraryEntry(library);
          entry.setScope(scope);
@@ -18,6 +18,7 @@ package org.jetbrains.idea.maven.importing;
 import com.intellij.compiler.impl.javaCompiler.javac.JavacConfiguration;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleType;
@@ -61,7 +62,7 @@ public class MavenProjectImporter {
  private volatile Map<MavenProject, MavenProjectChanges> myProjectsToImportWithChanges;
  private volatile Set<MavenProject> myAllProjects;
  private final boolean myImportModuleGroupsRequired;
-  private final MavenModifiableModelsProvider myModelsProvider;
+  private final IdeModifiableModelsProvider myModelsProvider;
  private final MavenImportingSettings myImportingSettings;

  private final ModifiableModuleModel myModuleModel;
@@ -77,7 +78,7 @@ public class MavenProjectImporter {
                              Map<VirtualFile, Module> fileToModuleMapping,
                              Map<MavenProject, MavenProjectChanges> projectsToImportWithChanges,
                              boolean importModuleGroupsRequired,
-                              MavenModifiableModelsProvider modelsProvider,
+                              IdeModifiableModelsProvider modelsProvider,
                              MavenImportingSettings importingSettings) {
    myProject = p;
    myProjectsTree = projectsTree;
@@ -87,7 +88,7 @@ public class MavenProjectImporter {
    myModelsProvider = modelsProvider;
    myImportingSettings = importingSettings;

-    myModuleModel = modelsProvider.getModuleModel();
+    myModuleModel = modelsProvider.getModifiableModuleModel();
  }

  @Nullable
@@ -605,12 +606,12 @@ public class MavenProjectImporter {
    Map<Module, ModuleRootModel> rootModels = new THashMap<Module, ModuleRootModel>();
    for (MavenProject each : myProjectsToImportWithChanges.keySet()) {
      Module module = myMavenProjectToModule.get(each);
-      ModifiableRootModel rootModel = myModelsProvider.getRootModel(module);
+      ModifiableRootModel rootModel = myModelsProvider.getModifiableRootModel(module);
      rootModels.put(module, rootModel);
    }
    for (Module each : myModuleModel.getModules()) {
      if (rootModels.containsKey(each)) continue;
-      rootModels.put(each, myModelsProvider.getRootModel(each));
+      rootModels.put(each, myModelsProvider.getModifiableRootModel(each));
    }
    return rootModels.values();
  }
@@ -17,6 +17,7 @@ package org.jetbrains.idea.maven.importing;

 import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ReadAction;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
 import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
@@ -61,10 +62,10 @@ public class MavenRootModelAdapter {

  private final Set<String> myOrderEntriesBeforeJdk = new THashSet<String>();

-  public MavenRootModelAdapter(@NotNull MavenProject p, @NotNull Module module, final MavenModifiableModelsProvider rootModelsProvider) {
+  public MavenRootModelAdapter(@NotNull MavenProject p, @NotNull Module module, final IdeModifiableModelsProvider rootModelsProvider) {
    myMavenProject = p;
-    myModuleModel = rootModelsProvider.getModuleModel();
-    myRootModel = rootModelsProvider.getRootModel(module);
+    myModuleModel = rootModelsProvider.getModifiableModuleModel();
+    myRootModel = rootModelsProvider.getModifiableRootModel(module);

    myRootModelModuleExtension = myRootModel.getModuleExtension(MavenSourceFoldersModuleExtension.class);
    myRootModelModuleExtension.init(module, myRootModel);
@@ -329,7 +330,7 @@ public class MavenRootModelAdapter {

  public void addLibraryDependency(MavenArtifact artifact,
                                   DependencyScope scope,
-                                   MavenModifiableModelsProvider provider,
+                                   IdeModifiableModelsProvider provider,
                                   MavenProject project) {
    assert !MavenConstants.SCOPE_SYSTEM.equals(artifact.getScope()); // System dependencies must be added ad module library, not as project wide library.

@@ -339,7 +340,7 @@ public class MavenRootModelAdapter {
    if (library == null) {
      library = provider.createLibrary(libraryName);
    }
-    Library.ModifiableModel libraryModel = provider.getLibraryModel(library);
+    Library.ModifiableModel libraryModel = provider.getModifiableLibraryModel(library);

    updateUrl(libraryModel, OrderRootType.CLASSES, artifact, null, null, true);
    updateUrl(libraryModel, OrderRootType.SOURCES, artifact, MavenExtraArtifactType.SOURCES, project, false);
@@ -27,6 +27,8 @@ import com.intellij.openapi.compiler.CompileContext;
 import com.intellij.openapi.compiler.CompileTask;
 import com.intellij.openapi.compiler.CompilerManager;
 import com.intellij.openapi.components.*;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.externalSystem.util.ExternalSystemConstants;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.module.Module;
@@ -55,9 +57,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.concurrency.AsyncPromise;
 import org.jetbrains.concurrency.Promise;
-import org.jetbrains.idea.maven.importing.MavenDefaultModifiableModelsProvider;
 import org.jetbrains.idea.maven.importing.MavenFoldersImporter;
-import org.jetbrains.idea.maven.importing.MavenModifiableModelsProvider;
 import org.jetbrains.idea.maven.importing.MavenProjectImporter;
 import org.jetbrains.idea.maven.model.*;
 import org.jetbrains.idea.maven.server.MavenEmbedderWrapper;
@@ -1130,10 +1130,10 @@ public class MavenProjectsManager extends MavenSimpleProjectComponent
  }

  public List<Module> importProjects() {
-    return importProjects(new MavenDefaultModifiableModelsProvider(myProject));
+    return importProjects(new IdeModifiableModelsProviderImpl(myProject));
  }

-  public List<Module> importProjects(final MavenModifiableModelsProvider modelsProvider) {
+  public List<Module> importProjects(final IdeModifiableModelsProvider modelsProvider) {
    final Map<MavenProject, MavenProjectChanges> projectsToImportWithChanges;
    final boolean importModuleGroupsRequired;
    synchronized (myImportingDataLock) {
@@ -1150,7 +1150,17 @@ public class MavenProjectsManager extends MavenSimpleProjectComponent
      public void run() {
        MavenProjectImporter projectImporter = new MavenProjectImporter(myProject,
                                                                        myProjectsTree,
-                                                                        getFileToModuleMapping(modelsProvider),
+                                                                        getFileToModuleMapping(new MavenModelsProvider() {
+                                                                          @Override
+                                                                          public Module[] getModules() {
+                                                                            return modelsProvider.getModules();
+                                                                          }
+
+                                                                          @Override
+                                                                          public VirtualFile[] getContentRoots(Module module) {
+                                                                            return modelsProvider.getContentRoots(module);
+                                                                          }
+                                                                        }),
                                                                        projectsToImportWithChanges,
                                                                        importModuleGroupsRequired,
                                                                        modelsProvider,
@@ -34,8 +34,8 @@ import com.intellij.projectImport.ProjectImportBuilder;
 import icons.MavenIcons;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.idea.maven.importing.MavenDefaultModifiableModelsProvider;
-import org.jetbrains.idea.maven.importing.MavenUIModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
+import com.intellij.openapi.externalSystem.service.project.IdeUIModifiableModelsProvider;
 import org.jetbrains.idea.maven.model.MavenExplicitProfiles;
 import org.jetbrains.idea.maven.model.MavenId;
 import org.jetbrains.idea.maven.project.*;
@@ -130,8 +130,8 @@ public class MavenProjectBuilder extends ProjectImportBuilder<MavenProject> {

    boolean isFromUI = model != null;
    return manager.importProjects(isFromUI
-                                  ? new MavenUIModifiableModelsProvider(project, model, (ModulesConfigurator)modulesProvider, artifactModel)
-                                  : new MavenDefaultModifiableModelsProvider(project));
+                                  ? new IdeUIModifiableModelsProvider(project, model, (ModulesConfigurator)modulesProvider, artifactModel)
+                                  : new IdeModifiableModelsProviderImpl(project));
  }

  private void appendProfilesFromString(Collection<String> selectedProfiles, String profilesList) {
@@ -16,9 +16,8 @@
 package org.jetbrains.idea.maven.importing;

 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.vfs.VirtualFile;
-import junit.framework.Test;
-import junit.framework.TestSuite;
 import org.jetbrains.idea.maven.MavenCustomRepositoryHelper;
 import org.jetbrains.idea.maven.MavenImportingTestCase;
 import org.jetbrains.idea.maven.project.MavenImportingSettings;
@@ -101,7 +100,7 @@ public class FoldersImportingTest extends MavenImportingTestCase {
      public void run() {
        MavenRootModelAdapter adapter = new MavenRootModelAdapter(myProjectsTree.findProject(myProjectPom),
                                                                  getModule("project"),
-                                                                  new MavenDefaultModifiableModelsProvider(myProject));
+                                                                  new IdeModifiableModelsProviderImpl(myProject));
        adapter.addSourceFolder(dir1.getPath(), JavaSourceRootType.SOURCE);
        adapter.addExcludedFolder(dir2.getPath());
        adapter.getRootModel().commit();
@@ -5,6 +5,7 @@
 package org.jetbrains.idea.maven.importing;

 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.libraries.Library;
 import org.jetbrains.idea.maven.MavenImportingTestCase;
@@ -487,7 +488,7 @@ public class GroovyImporterTest extends MavenImportingTestCase {
        public void run() {
          MavenRootModelAdapter a = new MavenRootModelAdapter(myProjectsTree.findProject(myProjectPom),
                                                              getModule("project"),
-                                                              new MavenDefaultModifiableModelsProvider(myProject));
+                                                              new IdeModifiableModelsProviderImpl(myProject));
          a.unregisterAll(getProjectPath() + "/target", true, true);
          a.getRootModel().commit();
        }
@@ -16,6 +16,7 @@
 package org.jetbrains.idea.maven.importing;

 import com.intellij.ProjectTopics;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import com.intellij.openapi.module.ModifiableModuleModel;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
@@ -367,7 +368,7 @@ public class MiscImportingTest extends MavenImportingTestCase {
    assertModules("project", "m1", "m2");

    myProjectsManager.scheduleImportInTests(myProjectsManager.getProjectsFiles());
-    myProjectsManager.importProjects(new MavenDefaultModifiableModelsProvider(myProject) {
+    myProjectsManager.importProjects(new IdeModifiableModelsProviderImpl(myProject) {
      @Override
      public void commit() {
        ModifiableModuleModel model = ModuleManager.getInstance(myProject).getModifiableModel();
@@ -23,7 +23,7 @@ import com.intellij.openapi.vcs.changes.ChangeListManager;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.Consumer;
 import org.jetbrains.idea.maven.MavenImportingTestCase;
-import org.jetbrains.idea.maven.importing.MavenDefaultModifiableModelsProvider;
+import com.intellij.openapi.externalSystem.service.project.IdeModifiableModelsProviderImpl;
 import org.jetbrains.idea.maven.importing.MavenFoldersImporter;
 import org.jetbrains.idea.maven.importing.MavenRootModelAdapter;
 import org.jetbrains.jps.model.java.JavaModuleSourceRootTypes;
@@ -140,7 +140,7 @@ public class MavenFoldersImporterTest extends MavenImportingTestCase {
      public void run() {
        MavenRootModelAdapter adapter = new MavenRootModelAdapter(myProjectsTree.findProject(myProjectPom),
                                                                  getModule("project"),
-                                                                  new MavenDefaultModifiableModelsProvider(myProject));
+                                                                  new IdeModifiableModelsProviderImpl(myProject));
        adapter.addSourceFolder(sourceDir.getPath(), JavaSourceRootType.SOURCE);
        adapter.getRootModel().commit();
      }
@@ -171,7 +171,7 @@ public class MavenFoldersImporterTest extends MavenImportingTestCase {
      public void run() {
        MavenRootModelAdapter adapter = new MavenRootModelAdapter(myProjectsTree.findProject(myProjectPom),
                                                                  getModule("project"),
-                                                                  new MavenDefaultModifiableModelsProvider(myProject));
+                                                                  new IdeModifiableModelsProviderImpl(myProject));
        adapter.useModuleOutput(new File(myProjectRoot.getPath(), "target/my-classes").getPath(),
                                new File(myProjectRoot.getPath(), "target/my-test-classes").getPath());
        adapter.getRootModel().commit();