Snapshot ee98b298267d0e09d2cd2f0731b6480a56dd48e7 from master branch of git://git.jetbrains.org/idea/community.git

Change-Id: I4515f72af131fdea9fc6905a4dc0fe9532409a81

16 files changed, 279 insertions, 62 deletions

diff --git a/plugins/eclipse/common-eclipse-util/src/AbstractEclipseClasspathReader.java b/plugins/eclipse/common-eclipse-util/src/AbstractEclipseClasspathReader.java
index 22dce5bfe9f9..6b1f53e8bc99 100644
--- a/plugins/eclipse/common-eclipse-util/src/AbstractEclipseClasspathReader.java
+++ b/plugins/eclipse/common-eclipse-util/src/AbstractEclipseClasspathReader.java
@@ -68,6 +68,8 @@ public abstract class AbstractEclipseClasspathReader<T> {
                                            String srcUrl, ExpandMacroToPathMap macroMap);
   protected abstract String expandEclipsePath2Url(T rootModel, String path);
 
+  protected abstract Set<String> getDefinedCons();
+
   protected abstract int rearrange(T rootModel);
 
   protected void readClasspathEntry(T rootModel,
@@ -197,18 +199,15 @@ public abstract class AbstractEclipseClasspathReader<T> {
       else if (path.startsWith(EclipseXml.JUNIT_CONTAINER)) {
         final String junitName = IdeaXml.JUNIT + getPresentableName(path);
         addJUnitDefaultLib(rootModel, junitName, macroMap);
-      }
-      else if (path.equals(EclipseXml.GROOVY_DSL_CONTAINER)) {
-        eclipseModuleManager.addGroovySupport(EclipseXml.GROOVY_DSL_CONTAINER);
-        eclipseModuleManager.registerSrcPlace(EclipseXml.GROOVY_DSL_CONTAINER, idx);
-      }
-      else if (path.equals(EclipseXml.GROOVY_SUPPORT)) {
-        eclipseModuleManager.addGroovySupport(EclipseXml.GROOVY_SUPPORT);
-        eclipseModuleManager.registerSrcPlace(EclipseXml.GROOVY_SUPPORT, idx);
-      }
-      else {
-        eclipseModuleManager.registerUnknownCons(path);
-        addNamedLibrary(rootModel, new ArrayList<String>(), exported, path, true);
+      } else {
+        final Set<String> registeredCons = getDefinedCons();
+        if (registeredCons.contains(path)) {
+          eclipseModuleManager.registerCon(path);
+          eclipseModuleManager.registerSrcPlace(path, idx);
+        } else {
+          eclipseModuleManager.registerUnknownCons(path);
+          addNamedLibrary(rootModel, new ArrayList<String>(), exported, path, true);
+        }
       }
     }
     else {
diff --git a/plugins/eclipse/common-eclipse-util/src/EclipseModuleManager.java b/plugins/eclipse/common-eclipse-util/src/EclipseModuleManager.java
index 1aa34e21763d..1ef8e7492309 100644
--- a/plugins/eclipse/common-eclipse-util/src/EclipseModuleManager.java
+++ b/plugins/eclipse/common-eclipse-util/src/EclipseModuleManager.java
@@ -30,9 +30,9 @@ public interface EclipseModuleManager {
   @Nullable
   String getInvalidJdk();
 
-  void addGroovySupport(String name);
+  void registerCon(String name);
 
-  String[] getGroovySupport();
+  String[] getUsedCons();
 
   void registerEclipseVariablePath(String path, String var);
 
@@ -87,10 +87,10 @@ public interface EclipseModuleManager {
     }
 
     @Override
-    public void addGroovySupport(String name) {}
+    public void registerCon(String name) {}
 
     @Override
-    public String[] getGroovySupport() {
+    public String[] getUsedCons() {
       return ArrayUtil.EMPTY_STRING_ARRAY;
     }
 
diff --git a/plugins/eclipse/common-eclipse-util/src/EclipseProjectFinder.java b/plugins/eclipse/common-eclipse-util/src/EclipseProjectFinder.java
index 41041ae54198..a22a4066c38b 100644
--- a/plugins/eclipse/common-eclipse-util/src/EclipseProjectFinder.java
+++ b/plugins/eclipse/common-eclipse-util/src/EclipseProjectFinder.java
@@ -33,7 +33,6 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 import java.io.IOException;
 import java.util.List;
-import java.util.Set;
 
 public class EclipseProjectFinder implements EclipseXml {
   public static void findModuleRoots(final List<String> paths, final String rootPath, @Nullable Processor<String> progressUpdater) {
@@ -117,25 +116,6 @@ public class EclipseProjectFinder implements EclipseXml {
     return null;
   }
 
-  public static void collectUnknownNatures(String path, Set<String> naturesNames) {
-    final File projectfile = new File(path, DOT_PROJECT_EXT);
-    try {
-      final Element natures = JDOMUtil.loadDocument(projectfile).getRootElement().getChild("natures");
-      if (natures != null) {
-        final List naturesList = natures.getChildren("nature");
-        for (Object nature : naturesList) {
-          final String natureName = ((Element)nature).getText();
-          if (!StringUtil.isEmptyOrSpaces(natureName)) {
-            naturesNames.add(natureName);
-          }
-        }
-      }
-    }
-    catch (Exception ignore) {
-    }
-    naturesNames.remove("org.eclipse.jdt.core.javanature");
-  }
-
   public static class LinkedResource {
     private String myURI;
     private String myLocation;
diff --git a/plugins/eclipse/common-eclipse-util/src/IdeaXml.java b/plugins/eclipse/common-eclipse-util/src/IdeaXml.java
index e10c3cbdf4e5..b32fe838f018 100644
--- a/plugins/eclipse/common-eclipse-util/src/IdeaXml.java
+++ b/plugins/eclipse/common-eclipse-util/src/IdeaXml.java
@@ -28,6 +28,8 @@ public interface IdeaXml {
   @NonNls String SOURCE_FOLDER_TAG = "sourceFolder";
   @NonNls String CONTENT_ENTRY_TAG = "contentEntry";
   @NonNls String TEST_FOLDER_TAG = "testFolder";
+  @NonNls String PACKAGE_PREFIX_TAG = "packagePrefix";
+  @NonNls String PACKAGE_PREFIX_VALUE_ATTR = "value";
   @NonNls String EXCLUDE_FOLDER_TAG = "excludeFolder";
   @NonNls String FOR_TESTS_ATTR = "forTests";
   @NonNls String TRUE_VALUE = "true";
diff --git a/plugins/eclipse/common-eclipse-util/src/conversion/AbstractIdeaSpecificSettings.java b/plugins/eclipse/common-eclipse-util/src/conversion/AbstractIdeaSpecificSettings.java
index eb586af7cb6d..3218f3a4d2ac 100644
--- a/plugins/eclipse/common-eclipse-util/src/conversion/AbstractIdeaSpecificSettings.java
+++ b/plugins/eclipse/common-eclipse-util/src/conversion/AbstractIdeaSpecificSettings.java
@@ -34,7 +34,6 @@ public abstract class AbstractIdeaSpecificSettings<T, C, SdkType> {
     readLanguageLevel(root, model);
 
     setupCompilerOutputs(root, model);
-
     final List entriesElements = root.getChildren(IdeaXml.CONTENT_ENTRY_TAG);
     if (!entriesElements.isEmpty()) {
       for (Object o : entriesElements) {
@@ -53,6 +52,28 @@ public abstract class AbstractIdeaSpecificSettings<T, C, SdkType> {
     readLibraryLevels(root, levels);
   }
 
+  public void initLevels(final Element root, T model, Map<String, String> levels) throws InvalidDataException {
+    expandElement(root, model);
+    readLanguageLevel(root, model);
+    readLibraryLevels(root, levels);
+  }
+
+  public void updateEntries(Element root, T model, @Nullable SdkType projectSdkType) {
+    setupJdk(root, model, projectSdkType);
+    setupCompilerOutputs(root, model);
+    final List entriesElements = root.getChildren(IdeaXml.CONTENT_ENTRY_TAG);
+    if (!entriesElements.isEmpty()) {
+      for (Object o : entriesElements) {
+        readContentEntry((Element)o, createContentEntry(model, ((Element)o).getAttributeValue(IdeaXml.URL_ATTR)), model);
+      }
+    } else {
+      final C[] entries = getEntries(model);//todo
+      if (entries.length > 0) {
+        readContentEntry(root, entries[0], model);
+      }
+    }
+  }
+
   protected abstract void readLibraryLevels(Element root, Map<String, String> levels);
 
   protected abstract C[] getEntries(T model);
diff --git a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathReader.java b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathReader.java
index 5adca0bb5ed7..72a7065ba800 100644
--- a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathReader.java
+++ b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathReader.java
@@ -200,6 +200,11 @@ class JpsEclipseClasspathReader extends AbstractEclipseClasspathReader<JpsModule
     return prepareValidUrlInsideJar(url);
   }
 
+  @Override
+  protected Set<String> getDefinedCons() {
+    return Collections.emptySet();
+  }
+
 
   @Override
   protected int rearrange(JpsModule rootModel) {
diff --git a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathSerializer.java b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathSerializer.java
index 0da330c5437a..c7124f8ca8ea 100644
--- a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathSerializer.java
+++ b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsEclipseClasspathSerializer.java
@@ -48,15 +48,24 @@ public class JpsEclipseClasspathSerializer extends JpsModuleClasspathSerializer
       final String eml = module.getName() + EclipseXml.IDEA_SETTINGS_POSTFIX;
       final File emlFile = new File(baseModulePath, eml);
       final Map<String, String> levels = new HashMap<String, String>();
+      final JpsIdeaSpecificSettings settings;
+      final Element root;
       if (emlFile.isFile()) {
         final Document emlDocument = JDOMUtil.loadDocument(emlFile);
-        final Element root = emlDocument.getRootElement();
-        new JpsIdeaSpecificSettings(expander).readIDEASpecific(root, module, projectSdkType, levels);
+        root = emlDocument.getRootElement();
+        settings = new JpsIdeaSpecificSettings(expander);
+        settings.initLevels(root, module, levels);
+      } else {
+        settings = null;
+        root = null;
       }
 
       final Document document = JDOMUtil.loadDocument(classpathFile);
       final JpsEclipseClasspathReader reader = new JpsEclipseClasspathReader(classpathDir, paths, new HashSet<String>(), levels);
       reader.readClasspath(module, null, document.getRootElement(), expander);//todo
+      if (settings != null) {
+        settings.updateEntries(root, module, projectSdkType);
+      }
     }
     catch (Exception e) {
       LOG.info(e);
diff --git a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsIdeaSpecificSettings.java b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsIdeaSpecificSettings.java
index 9d722746650e..593ce86b4f0b 100644
--- a/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsIdeaSpecificSettings.java
+++ b/plugins/eclipse/jps-plugin/src/org/jetbrains/jps/eclipse/model/JpsIdeaSpecificSettings.java
@@ -18,11 +18,13 @@ package org.jetbrains.jps.eclipse.model;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.SystemInfo;
+import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.ArrayUtil;
 import org.jdom.Element;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.eclipse.IdeaXml;
 import org.jetbrains.idea.eclipse.conversion.AbstractIdeaSpecificSettings;
+import org.jetbrains.jps.model.JpsSimpleElement;
 import org.jetbrains.jps.model.java.*;
 import org.jetbrains.jps.model.library.sdk.JpsSdkType;
 import org.jetbrains.jps.model.module.JpsDependenciesList;
@@ -31,6 +33,7 @@ import org.jetbrains.jps.model.module.JpsModuleSourceRoot;
 import org.jetbrains.jps.model.serialization.JpsMacroExpander;
 import org.jetbrains.jps.model.serialization.library.JpsSdkTableSerializer;
 
+import java.io.File;
 import java.util.List;
 import java.util.Map;
 
@@ -150,6 +153,25 @@ class JpsIdeaSpecificSettings extends AbstractIdeaSpecificSettings<JpsModule, St
       }
       model.addSourceRoot(url, JavaSourceRootType.TEST_SOURCE);
     }
+
+    for (Object o : root.getChildren(IdeaXml.EXCLUDE_FOLDER_TAG)) {
+      final String excludeUrl = ((Element)o).getAttributeValue(IdeaXml.URL_ATTR);
+      if (FileUtil.isAncestor(new File(contentUrl), new File(excludeUrl), false)) {
+        model.getExcludeRootsList().addUrl(excludeUrl);
+      }
+    }
+
+    for (Object o : root.getChildren(IdeaXml.PACKAGE_PREFIX_TAG)) {
+      Element ppElement = (Element)o;
+      final String prefix = ppElement.getAttributeValue(IdeaXml.PACKAGE_PREFIX_VALUE_ATTR);
+      final String url = ppElement.getAttributeValue(IdeaXml.URL_ATTR);
+      for (JpsModuleSourceRoot sourceRoot : model.getSourceRoots()) {
+        if (Comparing.strEqual(sourceRoot.getUrl(), url)) {
+          ((JpsSimpleElement)sourceRoot.getProperties()).setData(new JavaSourceRootProperties(prefix));
+          break;
+        }
+      }
+    }
   }
 
   private static JpsJavaExtensionService getService() {
diff --git a/plugins/eclipse/resources/EclipseBundle.properties b/plugins/eclipse/resources/EclipseBundle.properties
index bbf5b559ef25..658e139041d4 100644
--- a/plugins/eclipse/resources/EclipseBundle.properties
+++ b/plugins/eclipse/resources/EclipseBundle.properties
@@ -45,6 +45,6 @@ eclipse.message.rename.failed=Following modules could not be renamed because of
 eclipse.title.unresolved.projects=Unresolved module references
 eclipse.message.unresolved.projects=Some modules contain unresolved Eclipse-style project-relative library references:\n\n{0}
 eclipse.file.type.descr=Eclipse project files
-eclipse.create.library.title=Locate Eclipse installation
+eclipse.create.library.title=Locate Eclipse Installation
 eclipse.create.library.description=<html>Some of the projects you are importing depend on Eclipse platform.<br>\
 IntelliJ IDEA will create a global library named {0} containing Eclipse libraries.</html>
\ No newline at end of file
diff --git a/plugins/eclipse/resources/META-INF/plugin.xml b/plugins/eclipse/resources/META-INF/plugin.xml
index 18b92dd21ad5..a17e668f79d5 100644
--- a/plugins/eclipse/resources/META-INF/plugin.xml
+++ b/plugins/eclipse/resources/META-INF/plugin.xml
@@ -24,4 +24,7 @@
       <add-to-group group-id="ExportImportGroup" anchor="last"/>
     </action>
   </actions>
+  <extensionPoints>
+    <extensionPoint name="natureImporter" interface="org.jetbrains.idea.eclipse.importWizard.EclipseNatureImporter"/>
+  </extensionPoints>
 </idea-plugin>
\ No newline at end of file
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/config/EclipseModuleManagerImpl.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/config/EclipseModuleManagerImpl.java
index 8ac2a9d1c500..0450e375ab64 100644
--- a/plugins/eclipse/src/org/jetbrains/idea/eclipse/config/EclipseModuleManagerImpl.java
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/config/EclipseModuleManagerImpl.java
@@ -63,7 +63,7 @@ public class EclipseModuleManagerImpl implements EclipseModuleManager, Persisten
   private Map<String, Integer> mySrcPlace = new LinkedHashMap<String, Integer>();
   private String myInvalidJdk;
 
-  private Set<String> myGroovyDslSupport = new LinkedHashSet<String>();
+  private Set<String> myKnownCons = new LinkedHashSet<String>();
 
   public EclipseModuleManagerImpl(Module module) {
     myModule = module;
@@ -80,13 +80,13 @@ public class EclipseModuleManagerImpl implements EclipseModuleManager, Persisten
   }
 
   @Override
-  public void addGroovySupport(String name) {
-    myGroovyDslSupport.add(name);
+  public void registerCon(String name) {
+    myKnownCons.add(name);
   }
 
   @Override
-  public String[] getGroovySupport() {
-    return ArrayUtil.toStringArray(myGroovyDslSupport);
+  public String[] getUsedCons() {
+    return ArrayUtil.toStringArray(myKnownCons);
   }
 
   public static EclipseModuleManagerImpl getInstance(Module module) {
@@ -260,7 +260,7 @@ public class EclipseModuleManagerImpl implements EclipseModuleManager, Persisten
     myEclipseVariablePaths.clear();
     myUnknownCons.clear();
     mySrcPlace.clear();
-    myGroovyDslSupport.clear();
+    myKnownCons.clear();
   }
 
   @Override
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathReader.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathReader.java
index b02f00013e76..951d161f9354 100644
--- a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathReader.java
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathReader.java
@@ -41,6 +41,7 @@ import org.jdom.Element;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.eclipse.*;
 import org.jetbrains.idea.eclipse.config.EclipseModuleManagerImpl;
+import org.jetbrains.idea.eclipse.importWizard.EclipseNatureImporter;
 import org.jetbrains.idea.eclipse.util.ErrorLog;
 
 import java.io.IOException;
@@ -128,6 +129,11 @@ public class EclipseClasspathReader extends AbstractEclipseClasspathReader<Modif
   }
 
   @Override
+  protected Set<String> getDefinedCons() {
+    return EclipseNatureImporter.getAllDefinedCons();
+  }
+
+  @Override
   protected void addModuleLibrary(ModifiableRootModel rootModel,
                                   Element element,
                                   boolean exported,
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathWriter.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathWriter.java
index 4234301c7661..598d74cfb3f0 100644
--- a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathWriter.java
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/EclipseClasspathWriter.java
@@ -80,7 +80,7 @@ public class EclipseClasspathWriter {
         outputPath = EPathUtil.collapse2EclipsePath(compilerOutputUrl, myModel);
       }
     }
-    for (String support : eclipseModuleManager.getGroovySupport()) {
+    for (String support : eclipseModuleManager.getUsedCons()) {
       final Integer place = eclipseModuleManager.getSrcPlace(support);
       addOrderEntry(EclipseXml.CON_KIND, support, classpathElement, place != null ? place.intValue() : -1);
     }
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/IdeaSpecificSettings.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/IdeaSpecificSettings.java
index 904e7ee4f97f..fa34a48a548d 100644
--- a/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/IdeaSpecificSettings.java
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/conversion/IdeaSpecificSettings.java
@@ -27,7 +27,6 @@ import com.intellij.openapi.module.Module;
 import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleUtil;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.projectRoots.JavaSdk;
 import com.intellij.openapi.projectRoots.ProjectJdkTable;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.roots.*;
@@ -38,6 +37,7 @@ import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.JarFileSystem;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -215,21 +215,41 @@ public class IdeaSpecificSettings extends AbstractIdeaSpecificSettings<Modifiabl
 
   @Override
   public void readContentEntry(Element root, ContentEntry entry, ModifiableRootModel model) {
+    final SourceFolder[] folders = entry.getSourceFolders();
+    final String[] sourceFoldersUrls = new String[folders.length];
+    for (int i = 0; i < folders.length; i++) {
+      final SourceFolder folder = folders[i];
+      sourceFoldersUrls[i] = folder.getUrl();
+      entry.removeSourceFolder(folder);
+    }
+
+    final boolean[] testFolders = new boolean[sourceFoldersUrls.length];
     for (Object o : root.getChildren(IdeaXml.TEST_FOLDER_TAG)) {
       final String url = ((Element)o).getAttributeValue(IdeaXml.URL_ATTR);
-      SourceFolder folderToBeTest = null;
+      for (int i = 0; i < sourceFoldersUrls.length; i++) {
+        if (Comparing.strEqual(sourceFoldersUrls[i], url)) {
+          testFolders[i] = true;
+          break;
+        }
+      }
+    }
+
+    for (int i = 0; i < sourceFoldersUrls.length; i++) {
+      entry.addSourceFolder(sourceFoldersUrls[i], testFolders[i]);
+    }
+    
+    for (Object o : root.getChildren(IdeaXml.PACKAGE_PREFIX_TAG)) {
+      Element ppElement = (Element)o;
+      final String prefix = ppElement.getAttributeValue(IdeaXml.PACKAGE_PREFIX_VALUE_ATTR);
+      final String url = ppElement.getAttributeValue(IdeaXml.URL_ATTR);
       for (SourceFolder folder : entry.getSourceFolders()) {
         if (Comparing.strEqual(folder.getUrl(), url)) {
-          folderToBeTest = folder;
+          folder.setPackagePrefix(prefix);
           break;
         }
       }
-      if (folderToBeTest != null) {
-        entry.removeSourceFolder(folderToBeTest);
-      }
-      entry.addSourceFolder(url, true);
     }
-
+    
     final String url = entry.getUrl();
     for (Object o : root.getChildren(IdeaXml.EXCLUDE_FOLDER_TAG)) {
       final String excludeUrl = ((Element)o).getAttributeValue(IdeaXml.URL_ATTR);
@@ -278,6 +298,14 @@ public class IdeaSpecificSettings extends AbstractIdeaSpecificSettings<Modifiabl
           element.setAttribute(IdeaXml.URL_ATTR, sourceFolder.getUrl());
           isModified = true;
         }
+        final String packagePrefix = sourceFolder.getPackagePrefix();
+        if (!StringUtil.isEmptyOrSpaces(packagePrefix)) {
+          Element element = new Element(IdeaXml.PACKAGE_PREFIX_TAG);
+          contentEntryElement.addContent(element);
+          element.setAttribute(IdeaXml.URL_ATTR, sourceFolder.getUrl());
+          element.setAttribute(IdeaXml.PACKAGE_PREFIX_VALUE_ATTR, packagePrefix);
+          isModified = true;
+        }
       }
 
       final VirtualFile entryFile = entry.getFile();
@@ -315,8 +343,7 @@ public class IdeaSpecificSettings extends AbstractIdeaSpecificSettings<Modifiabl
       }
       if (entry instanceof JdkOrderEntry) {
         final Sdk jdk = ((JdkOrderEntry)entry).getJdk();
-        if (EclipseModuleManagerImpl.getInstance(entry.getOwnerModule()).getInvalidJdk() != null || 
-            (jdk != null && !(jdk.getSdkType() instanceof JavaSdk))) {
+        if (EclipseModuleManagerImpl.getInstance(entry.getOwnerModule()).getInvalidJdk() != null || jdk != null) {
           if (entry instanceof InheritedJdkOrderEntry) {
             root.setAttribute(INHERIT_JDK, "true");
           } else {
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseImportBuilder.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseImportBuilder.java
index c25a9429e8f3..fdbea3cafb7b 100644
--- a/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseImportBuilder.java
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseImportBuilder.java
@@ -41,6 +41,7 @@ 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.ModulesProvider;
+import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Comparing;
@@ -54,6 +55,7 @@ import com.intellij.packaging.artifacts.ModifiableArtifactModel;
 import com.intellij.projectImport.ProjectImportBuilder;
 import com.intellij.util.Function;
 import com.intellij.util.Processor;
+import com.intellij.util.containers.HashMap;
 import gnu.trove.THashSet;
 import icons.EclipseIcons;
 import org.jdom.Element;
@@ -171,17 +173,20 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
   public boolean validate(final Project currentProject, final Project dstProject) {
     final Ref<Exception> refEx = new Ref<Exception>();
     final HashSet<String> variables = new HashSet<String>();
-    final Set<String> naturesNames = new HashSet<String>();
+    final Map<String, String> naturesNames = new HashMap<String, String>();  
+    final List<String> projectsToConvert = getParameters().projectsToConvert;
+    final boolean oneProjectToConvert = projectsToConvert.size() == 1;
+    final String separator = oneProjectToConvert ? "<br>" : ", ";
     ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
       public void run() {
         try {
-          for (String path : getParameters().projectsToConvert) {
+          for (String path : projectsToConvert) {
             final File classpathfile = new File(path, EclipseXml.DOT_CLASSPATH_EXT);
             if (classpathfile.exists()) {
               final Element classpathElement = JDOMUtil.loadDocument(classpathfile).getRootElement();
               EclipseClasspathReader.collectVariables(variables, classpathElement, path);
             }
-            EclipseProjectFinder.collectUnknownNatures(path, naturesNames);
+            collectUnknownNatures(path, naturesNames, separator);
           }
         }
         catch (IOException e) {
@@ -206,7 +211,19 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
       public void run() {
         if (!naturesNames.isEmpty()) {
           final String title = "Unknown Natures Detected";
-          Notifications.Bus.notify(new Notification(title, title, "Imported projects contain unknown natures:<br>" + StringUtil.join(naturesNames, "<br>")+ "<br>" +
+          final String naturesByProject;
+          if (oneProjectToConvert) {
+            naturesByProject = naturesNames.values().iterator().next();
+          }
+          else {
+            naturesByProject = StringUtil.join(naturesNames.keySet(), new Function<String, String>() {
+              @Override
+              public String fun(String projectPath) {
+                return projectPath + "(" + naturesNames.get(projectPath) + ")";
+              }
+            }, "<br>");
+          }
+          Notifications.Bus.notify(new Notification(title, title, "Imported projects contain unknown natures:<br>" + naturesByProject + "<br>" +
                                                                   "Some settings may be lost after import.", NotificationType.WARNING));
         }
       }
@@ -224,6 +241,7 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
     final Collection<String> unknownJdks = new TreeSet<String>();
     final Set<String> refsToModules = new HashSet<String>();
     final List<Module> result = new ArrayList<Module>();
+    final Map<Module, Set<String>> module2NatureNames = new HashMap<Module, Set<String>>();
 
     try {
       final ModifiableModuleModel moduleModel = model != null ? model : ModuleManager.getInstance(project).getModifiableModel();
@@ -296,6 +314,11 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
         final Module module = moduleModel.newModule(modulesDirectory + "/" + EclipseProjectFinder.findProjectName(path) + IdeaXml.IML_EXT,
                                                     StdModuleTypes.JAVA.getId());
         result.add(module);
+        final Set<String> natures = collectNatures(path);
+
+        if (natures.size() > 0) {
+          module2NatureNames.put(module, natures);
+        }
         final ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel();
         rootModels[idx++] = rootModel;
 
@@ -330,7 +353,7 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
     catch (Exception e) {
       LOG.error(e);
     }
-
+    scheduleNaturesImporting(project, module2NatureNames);
     createEclipseLibrary(project, unknownLibraries, IdeaXml.ECLIPSE_LIBRARY);
 
     StringBuffer message = new StringBuffer();
@@ -400,6 +423,40 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
     return result;
   }
 
+  private static void scheduleNaturesImporting(@NotNull final Project project,
+                                               @NotNull final Map<Module, Set<String>> module2NatureNames) {
+    if (module2NatureNames.size() == 0) {
+      return;
+    }
+    ApplicationManager.getApplication().invokeLater(new Runnable() {
+      @Override
+      public void run() {
+        StartupManager.getInstance(project).runWhenProjectIsInitialized(new Runnable() {
+          @Override
+          public void run() {
+            for (EclipseNatureImporter importer : EclipseNatureImporter.EP_NAME.getExtensions()) {
+              final String importerNatureName = importer.getNatureName();
+              final List<Module> modulesToImport = new ArrayList<Module>();
+
+              for (Map.Entry<Module, Set<String>> entry : module2NatureNames.entrySet()) {
+                final Module module = entry.getKey();
+                final Set<String> natureNames = entry.getValue();
+
+                if (natureNames.contains(importerNatureName)) {
+                  modulesToImport.add(module);
+                }
+              }
+
+              if (modulesToImport.size() > 0) {
+                importer.doImport(project, modulesToImport);
+              }
+            }
+          }
+        });
+      }
+    });
+  }
+
   private static void createEclipseLibrary(final Project project, final Collection<String> libraries, final String libraryName) {
     if (libraries.contains(libraryName)) {
       final FileChooserDescriptor fileChooserDescriptor = new FileChooserDescriptor(false, true, false, false, false, false) {
@@ -452,4 +509,38 @@ public class EclipseImportBuilder extends ProjectImportBuilder<String> implement
     }
     return parameters;
   }
+
+  public static void collectUnknownNatures(String path, Map<String, String> naturesNames, String separator) {
+    final Set<String> natures = collectNatures(path);
+    natures.remove("org.eclipse.jdt.core.javanature");
+
+    for (EclipseNatureImporter importer : EclipseNatureImporter.EP_NAME.getExtensions()) {
+      natures.remove(importer.getNatureName());
+    }
+
+    if (!natures.isEmpty()) {
+      naturesNames.put(path, StringUtil.join(natures, separator));
+    }
+  }
+
+  @NotNull
+  public static Set<String> collectNatures(@NotNull String path) {
+    final Set<String> naturesNames = new HashSet<String>();
+    final File projectfile = new File(path, EclipseXml.DOT_PROJECT_EXT);
+    try {
+      final Element natures = JDOMUtil.loadDocument(projectfile).getRootElement().getChild("natures");
+      if (natures != null) {
+        final List naturesList = natures.getChildren("nature");
+        for (Object nature : naturesList) {
+          final String natureName = ((Element)nature).getText();
+          if (!StringUtil.isEmptyOrSpaces(natureName)) {
+            naturesNames.add(natureName);
+          }
+        }
+      }
+    }
+    catch (Exception ignore) {
+    }
+    return naturesNames;
+  }
 }
diff --git a/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseNatureImporter.java b/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseNatureImporter.java
new file mode 100644
index 000000000000..d496d24145b4
--- /dev/null
+++ b/plugins/eclipse/src/org/jetbrains/idea/eclipse/importWizard/EclipseNatureImporter.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2000-2013 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.eclipse.importWizard;
+
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.util.containers.HashSet;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.idea.eclipse.EclipseXml;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @author Eugene.Kudelevsky
+ */
+public abstract class EclipseNatureImporter {
+  public static final ExtensionPointName<EclipseNatureImporter> EP_NAME =
+    ExtensionPointName.create("org.jetbrains.idea.eclipse.natureImporter");
+
+  @NotNull
+  public abstract String getNatureName();
+  public abstract Set<String> getProvidedCons();
+
+  public abstract void doImport(@NotNull Project project, @NotNull List<Module> modules);
+
+  public static Set<String> getAllDefinedCons() {
+    final Set<String> allCons = new HashSet<String>();
+    allCons.add(EclipseXml.GROOVY_SUPPORT);
+    allCons.add(EclipseXml.GROOVY_DSL_CONTAINER);
+
+    for (EclipseNatureImporter provider : Extensions.getExtensions(EP_NAME)) {
+      allCons.addAll(provider.getProvidedCons());
+    }
+    return allCons;
+  }
+}