Multiresolve to alias and defmodule

src/org/elixir_lang/Elixir.bnf

@@ -2531,6 +2531,7 @@ unmatchedQualifiedAlias ::= unmatchedExpression dotInfixOperator alias
                               implements = "org.elixir_lang.psi.QualifiedAlias"
                               methods = [
                                 fullyQualifiedName
+                                getName
                                 getNameIdentifier
                                 getReference
                                 isModuleName

src/org/elixir_lang/psi/impl/ElixirPsiImplUtil.java

@@ -2590,8 +2590,8 @@ public static String getName(@NotNull ElixirAlias alias) {
     }
 
     @NotNull
-    public static String getName(@NotNull ElixirMatchedQualifiedAlias matchedQualifiedAlias) {
-        return matchedQualifiedAlias.getText();
+    public static String getName(@NotNull QualifiedAlias qualifiedAlias) {
+        return qualifiedAlias.getText();
     }
 
     @Contract(pure = true)

src/org/elixir_lang/psi/scope/module/MultiResolve.java

@@ -1,13 +1,22 @@
 package org.elixir_lang.psi.scope.module;
 
+import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.stubs.StubIndex;
 import com.intellij.psi.util.PsiTreeUtil;
+import org.elixir_lang.psi.NamedElement;
 import org.elixir_lang.psi.scope.Module;
+import org.elixir_lang.psi.stub.index.AllName;
+import org.elixir_lang.reference.module.UnaliasedName;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
+import static org.elixir_lang.Module.concat;
 import static org.elixir_lang.Module.split;
 import static org.elixir_lang.psi.impl.ElixirPsiImplUtil.ENTRANCE;
 
@@ -27,6 +36,19 @@ public static List<ResolveResult> resolveResultList(@NotNull String name,
      * Private Static Methods
      */
 
+    @NotNull
+    private static Collection<NamedElement> indexedNamedElements(@NotNull PsiNamedElement match,
+                                                                 @NotNull String unaliasedName) {
+        Project project = match.getProject();
+        return StubIndex.getElements(
+                AllName.KEY,
+                unaliasedName,
+                project,
+                GlobalSearchScope.allScope(project),
+                NamedElement.class
+        );
+    }
+
     @Nullable
     private static List<ResolveResult> resolveResultList(@NotNull String name,
                                                          boolean incompleteCode,
@@ -42,6 +64,20 @@ private static List<ResolveResult> resolveResultList(@NotNull String name,
         return multiResolve.getResolveResultList();
     }
 
+    @NotNull
+    private static String unaliasedName(@NotNull PsiNamedElement match, @NotNull List<String> namePartList) {
+        String matchUnaliasedName = UnaliasedName.unaliasedName(match);
+
+        List<String> unaliasedNamePartList = new ArrayList<String>(namePartList.size());
+        unaliasedNamePartList.add(matchUnaliasedName);
+
+        for (int i = 1; i < namePartList.size(); i++) {
+            unaliasedNamePartList.add(namePartList.get(i));
+        }
+
+        return concat(unaliasedNamePartList);
+    }
+
     /*
      * Fields
      */
@@ -84,26 +120,28 @@ public List<ResolveResult> getResolveResultList() {
     protected boolean executeOnAliasedName(@NotNull PsiNamedElement match,
                                            @NotNull String aliasedName,
                                            @NotNull ResolveState state) {
-        Boolean validResult = null;
-
         if (aliasedName.equals(name)) {
-            validResult = true;
+            List<String> namePartList = split(name);
+
+            // adds `Foo.SSH` in `alias Foo.SSH`
+            addToResolveResultList(match, true);
+
+            // adds `defmodule Foo.SSH` for `alias Foo.SSH`
+            addUnaliasedNamedElementsToResolveResultList(match, namePartList);
         } else {
             List<String> namePartList = split(name);
             String firstNamePart = namePartList.get(0);
 
             // alias Foo.SSH, then SSH.Key is name
             if (aliasedName.equals(firstNamePart)) {
-                validResult = true;
+                addToResolveResultList(match, true);
+
+                addUnaliasedNamedElementsToResolveResultList(match, namePartList);
             } else if (incompleteCode && aliasedName.startsWith(name)) {
-                validResult = false;
+                addToResolveResultList(match, false);
             }
         }
 
-        if (validResult != null) {
-            addToResolveResultList(match, validResult);
-        }
-
         return org.elixir_lang.psi.scope.MultiResolve.keepProcessing(incompleteCode, resolveResultList);
     }
 
@@ -116,4 +154,13 @@ private void addToResolveResultList(@NotNull PsiElement element, boolean validRe
                 resolveResultList, new PsiElementResolveResult(element, validResult)
         );
     }
+
+    private void addUnaliasedNamedElementsToResolveResultList(@NotNull PsiNamedElement match, List<String> namePartList) {
+        String unaliasedName = unaliasedName(match, namePartList);
+        Collection<NamedElement> namedElementCollection = indexedNamedElements(match, unaliasedName);
+
+        for (PsiElement element : namedElementCollection) {
+            addToResolveResultList(element, true);
+        }
+    }
 }

src/org/elixir_lang/psi/scope/module/Variants.java

@@ -8,10 +8,9 @@
 import com.intellij.psi.ResolveState;
 import com.intellij.psi.stubs.StubIndex;
 import com.intellij.util.containers.ContainerUtil;
-import org.elixir_lang.psi.QualifiableAlias;
 import org.elixir_lang.psi.scope.Module;
 import org.elixir_lang.psi.stub.index.AllName;
-import org.elixir_lang.reference.module.ResolvableName;
+import org.elixir_lang.reference.module.UnaliasedName;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -80,15 +79,7 @@ protected boolean executeOnAliasedName(@NotNull PsiNamedElement match, @NotNull
                 )
         );
 
-        final String unaliasedName;
-
-        if (match instanceof QualifiableAlias) {
-            QualifiableAlias matchQualfiableAlias = (QualifiableAlias) match;
-
-            unaliasedName = ResolvableName.resolvableName(matchQualfiableAlias);
-        } else {
-            unaliasedName = match.getName();
-        }
+        String unaliasedName = UnaliasedName.unaliasedName(match);
 
         if (unaliasedName != null) {
             List<String> unaliasedNestedNames = ContainerUtil.findAll(

src/org/elixir_lang/reference/module/UnaliasedName.java

@@ -0,0 +1,102 @@
+package org.elixir_lang.reference.module;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiNamedElement;
+import org.elixir_lang.psi.*;
+import org.elixir_lang.psi.call.Call;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import static org.elixir_lang.psi.call.name.Function.ALIAS;
+import static org.elixir_lang.psi.call.name.Module.KERNEL;
+import static org.elixir_lang.psi.impl.ElixirPsiImplUtil.finalArguments;
+import static org.elixir_lang.psi.impl.ElixirPsiImplUtil.hasKeywordKey;
+
+public class UnaliasedName {
+    /*
+     * Public Static Methods
+     */
+
+    @Nullable
+    public static String unaliasedName(@NotNull PsiNamedElement namedElement) {
+        String unaliasedName;
+
+        if (namedElement instanceof QualifiableAlias) {
+            unaliasedName = unaliasedName((QualifiableAlias) namedElement);
+        } else {
+            unaliasedName = namedElement.getName();
+        }
+
+        return unaliasedName;
+    }
+
+    /*
+     * Private Static Methods
+     */
+
+    @Nullable
+    private static String down(@NotNull PsiElement element) {
+        String unaliasedName = null;
+
+        if (element instanceof QualifiableAlias) {
+            PsiNamedElement namedElement = (PsiNamedElement) element;
+
+            unaliasedName = namedElement.getName();
+        }
+
+        return unaliasedName;
+    }
+
+    @Nullable
+    private static String unaliasedName(@NotNull QualifiableAlias qualifiableAlias) {
+        return up(qualifiableAlias.getParent(), qualifiableAlias);
+    }
+
+    @Nullable
+    private static String up(@NotNull Call call, @NotNull QualifiableAlias entrance) {
+        String unaliasedName = null;
+
+        if (call.isCalling(KERNEL, ALIAS)) {
+            PsiElement[] finalArguments = finalArguments(call);
+
+            if (finalArguments != null && finalArguments.length > 0) {
+                PsiElement firstArgument = finalArguments[0];
+
+                unaliasedName = down(firstArgument);
+            }
+        }
+
+        return unaliasedName;
+    }
+
+    @Nullable
+    private static String up(@Nullable PsiElement element, @NotNull QualifiableAlias entrance) {
+        String unaliasedName = null;
+
+        if (element instanceof Call) {
+            unaliasedName = up((Call) element, entrance);
+        } else if (element instanceof ElixirAccessExpression ||
+                element instanceof QuotableArguments ||
+                element instanceof QuotableKeywordList) {
+            unaliasedName = up(element.getParent(), entrance);
+        } else if (element instanceof ElixirMultipleAliases) {
+            unaliasedName = down(entrance);
+        } else if (element instanceof QuotableKeywordPair) {
+            unaliasedName =up((QuotableKeywordPair) element, entrance);
+        }
+
+        return unaliasedName;
+    }
+
+    @Nullable
+    private static String up(@NotNull QuotableKeywordPair element, @NotNull QualifiableAlias entrance) {
+        String unaliasedName = null;
+
+        if (hasKeywordKey(element, "as")) {
+            unaliasedName = up(element.getParent(), entrance);
+        }
+
+        return  unaliasedName;
+    }
+
+}