Move getImportPath and related utils from JetPsiUtil to JetImportDirective

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java

@@ -19,17 +19,21 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
+import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.stubs.PsiJetImportDirectiveStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
+import org.jetbrains.jet.lang.resolve.ImportPath;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
 public class JetImportDirective extends JetElementImplStub<PsiJetImportDirectiveStub> {
 
     public static final TokenSet IMPORT_DIRECTIVE_EXPRESSIONS =
-               TokenSet.create(JetStubElementTypes.REFERENCE_EXPRESSION, JetStubElementTypes.DOT_QUALIFIED_EXPRESSION);
+            TokenSet.create(JetStubElementTypes.REFERENCE_EXPRESSION, JetStubElementTypes.DOT_QUALIFIED_EXPRESSION);
-    
+
     public JetImportDirective(@NotNull ASTNode node) {
         super(node);
     }
@@ -96,4 +100,63 @@ public class JetImportDirective extends JetElementImplStub<PsiJetImportDirective
         }
         return getNode().findChildByType(JetTokens.MUL) != null;
     }
+
+    @Nullable
+    @IfNotParsed
+    public ImportPath getImportPath() {
+        if (!isValidImport()) return null;
+
+        FqName importFqn = fqNameFromExpression(getImportedReference());
+        if (importFqn == null) {
+            return null;
+        }
+
+        Name alias = null;
+        String aliasName = getAliasName();
+        if (aliasName != null) {
+            alias = Name.identifier(aliasName);
+        }
+
+        return new ImportPath(importFqn, isAllUnder(), alias);
+    }
+
+    private boolean isValidImport() {
+        return !PsiTreeUtil.hasErrorElements(this);
+    }
+
+    @Nullable
+    private static FqName fqNameFromExpression(@Nullable JetExpression expression) {
+        if (expression == null) {
+            return null;
+        }
+
+        if (expression instanceof JetDotQualifiedExpression) {
+            JetDotQualifiedExpression dotQualifiedExpression = (JetDotQualifiedExpression) expression;
+            FqName parentFqn = fqNameFromExpression(dotQualifiedExpression.getReceiverExpression());
+            Name child = nameFromExpression(dotQualifiedExpression.getSelectorExpression());
+
+            return parentFqn != null && child != null ? parentFqn.child(child) : null;
+        }
+        else if (expression instanceof JetSimpleNameExpression) {
+            JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
+            return FqName.topLevel(simpleNameExpression.getReferencedNameAsName());
+        }
+        else {
+            throw new IllegalArgumentException("Can't construct fqn for: " + expression.getClass().toString());
+        }
+    }
+
+    @Nullable
+    private static Name nameFromExpression(@Nullable JetExpression expression) {
+        if (expression == null) {
+            return null;
+        }
+
+        if (expression instanceof JetSimpleNameExpression) {
+            return ((JetSimpleNameExpression) expression).getReferencedNameAsName();
+        }
+        else {
+            throw new IllegalArgumentException("Can't construct name for: " + expression.getClass().toString());
+        }
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java

@@ -37,9 +37,7 @@ import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.kdoc.psi.api.KDocElement;
 import org.jetbrains.jet.lang.parsing.JetExpressionParsing;
 import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
@@ -226,27 +224,6 @@ public class JetPsiUtil {
         return false;
     }
 
-    @Nullable
-    @IfNotParsed
-    public static ImportPath getImportPath(@NotNull JetImportDirective importDirective) {
-        if (PsiTreeUtil.hasErrorElements(importDirective)) {
-            return null;
-        }
-
-        FqName importFqn = getFQName(importDirective.getImportedReference());
-        if (importFqn == null) {
-            return null;
-        }
-
-        Name alias = null;
-        String aliasName = importDirective.getAliasName();
-        if (aliasName != null) {
-            alias = Name.identifier(aliasName);
-        }
-
-        return new ImportPath(importFqn, importDirective.isAllUnder(), alias);
-    }
-
     @Nullable
     public static <T extends PsiElement> T getDirectParentOfTypeForBlock(@NotNull JetBlockExpression block, @NotNull Class<T> aClass) {
         T parent = PsiTreeUtil.getParentOfType(block, aClass);
@@ -445,42 +422,6 @@ public class JetPsiUtil {
         return element instanceof JetSimpleNameExpression && isBackingFieldReference((JetSimpleNameExpression)element);
     }
 
-    @Nullable
-    private static FqName getFQName(@Nullable JetExpression expression) {
-        if (expression == null) {
-            return null;
-        }
-
-        if (expression instanceof JetDotQualifiedExpression) {
-            JetDotQualifiedExpression dotQualifiedExpression = (JetDotQualifiedExpression) expression;
-            FqName parentFqn = getFQName(dotQualifiedExpression.getReceiverExpression());
-            Name child = getName(dotQualifiedExpression.getSelectorExpression());
-
-            return parentFqn != null && child != null ? parentFqn.child(child) : null;
-        }
-        else if (expression instanceof JetSimpleNameExpression) {
-            JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression;
-            return FqName.topLevel(simpleNameExpression.getReferencedNameAsName());
-        }
-        else {
-            throw new IllegalArgumentException("Can't construct fqn for: " + expression.getClass().toString());
-        }
-    }
-
-    @Nullable
-    private static Name getName(@Nullable JetExpression expression) {
-        if (expression == null) {
-            return null;
-        }
-
-        if (expression instanceof JetSimpleNameExpression) {
-            return ((JetSimpleNameExpression) expression).getReferencedNameAsName();
-        }
-        else {
-            throw new IllegalArgumentException("Can't construct name for: " + expression.getClass().toString());
-        }
-    }
-
     @Nullable
     public static JetElement getLastStatementInABlock(@Nullable JetBlockExpression blockExpression) {
         if (blockExpression == null) return null;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ImportsProvider.java

@@ -20,7 +20,6 @@ import com.google.common.collect.*;
 import kotlin.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.storage.NotNullLazyValue;
@@ -73,7 +72,7 @@ class ImportsProvider {
             List<JetImportDirective> processedAllUnderImports = Lists.newArrayList();
 
             for (JetImportDirective anImport : importDirectives) {
-                ImportPath path = JetPsiUtil.getImportPath(anImport);
+                ImportPath path = anImport.getImportPath();
                 if (path == null) {
                     // Could be some parse errors
                     continue;

compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java

@@ -105,7 +105,7 @@ public class JetPsiUtilTest extends JetLiteFixture {
 
         assertNotNull("At least one import directive is expected", importDirective);
 
-        return JetPsiUtil.getImportPath(importDirective);
+        return importDirective.getImportPath();
     }
 
     private void checkIsSelectorInQualified() {

idea/src/org/jetbrains/jet/plugin/imports/KotlinImportOptimizer.kt

@@ -48,7 +48,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
             for (anImport in directives) {
                 directivesAfterCurrent.remove(anImport)
 
-                val importPath = JetPsiUtil.getImportPath(anImport)
+                val importPath = anImport.getImportPath()
                 if (importPath == null) {
                     continue
                 }

idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java

@@ -27,9 +27,9 @@ import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.NamePackage;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
 import org.jetbrains.jet.plugin.references.JetReference;
-import org.jetbrains.jet.lang.resolve.name.NamePackage;
 import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS;
 
 import java.util.List;
@@ -169,7 +169,7 @@ public class ImportInsertHelper {
         if (!importDirectives.isEmpty()) {
             // Check if import is already present
             for (JetImportDirective directive : importDirectives) {
-                ImportPath existentImportPath = JetPsiUtil.getImportPath(directive);
+                ImportPath existentImportPath = directive.getImportPath();
                 if (existentImportPath != null && NamePackage.isImported(importPath, existentImportPath)) {
                     return false;
                 }