Import type: insert namespace qualifiers where needed

Author: auduchinok

ReSharper.FSharp/src/FSharp.Psi.Features/src/Util/OpensUtil.fs

@@ -170,6 +170,13 @@ let addOpen (offset: DocumentOffset) (fsFile: IFSharpFile) (settings: IContextBo
         |> Seq.tail
         |> Seq.tryHead
         |> Option.iter insertBeforeModuleMember
+
+    | :? IDeclaredModuleDeclaration as moduleDecl when
+            let keyword = moduleDecl.ModuleOrNamespaceKeyword
+            isNotNull keyword && keyword.GetTreeStartOffset().Offset > offset.Offset ->
+        // Don't insert open after the reference.
+        ()
+
     | _ ->
 
     match Seq.tryHead moduleDecl.MembersEnumerable with

ReSharper.FSharp/src/FSharp.Psi/src/Impl/FSharpReferenceBindingUtil.cs

@@ -38,15 +38,55 @@ public static string SuggestShortReferenceName(IDeclaredElement declaredElement,
     public static string SuggestShortReferenceName(string sourceName, PsiLanguageType language) =>
       NamingManager.GetNamingLanguageService(language).MangleNameIfNecessary(sourceName);
 
+    [CanBeNull]
+    private static INamespace GetNamespace([NotNull] IClrDeclaredElement declaredElement)
+    {
+      if (declaredElement is ITypeElement typeElement)
+        return typeElement.GetContainingNamespace();
+
+      if (declaredElement.GetContainingType() is { } containingType)
+        return containingType.GetContainingNamespace();
+
+      if (declaredElement is INamespace ns)
+        return ns.GetContainingNamespace();
+
+      return null;
+    }
+
+    private static bool IsNamespaceQualifierRequired([NotNull] FSharpSymbolReference reference)
+    {
+      var attribute = reference.GetTreeNode().GetContainingNode<IAttribute>();
+      return NamedModuleDeclarationNavigator.GetByAttribute(attribute) != null;
+    }
+
+    private static void SetNamespaceQualifiesIfNeeded([NotNull] FSharpSymbolReference reference,
+      [NotNull] IClrDeclaredElement declaredElement)
+    {
+      if (!IsNamespaceQualifierRequired(reference))
+        return;
+
+      var ns = GetNamespace(declaredElement);
+      if (ns == null || ns.IsRootNamespace)
+        return;
+
+      reference.SetQualifier(ns);
+    }
+
     public static void SetRequiredQualifiers([NotNull] FSharpSymbolReference reference,
       [NotNull] IClrDeclaredElement declaredElement)
     {
       var containingType = declaredElement.GetContainingType();
       if (containingType == null)
+      {
+        SetNamespaceQualifiesIfNeeded(reference, declaredElement);
         return;
+      }
 
       if (containingType.IsModule() && !containingType.RequiresQualifiedAccess())
+      {
+        SetNamespaceQualifiesIfNeeded(reference, containingType);
         return;
+      }
 
       reference.SetQualifier(containingType);
     }

ReSharper.FSharp/test/data/features/quickFixes/importType/Qualifiers - Namespace 01.fs

@@ -0,0 +1,3 @@
+[<Optional{caret}>]
+module M
+()

ReSharper.FSharp/test/data/features/quickFixes/importType/Qualifiers - Namespace 01.fs.gold

@@ -0,0 +1,3 @@
+[<System.Runtime.InteropServices.Optional{caret}>]
+module M
+()

ReSharper.FSharp/test/src/FSharp.Tests/QuickFixes/ImportTypeTest.fs

@@ -39,4 +39,6 @@ type ImportTypeTest() =
     [<Test>] member x.``Qualifiers - Reference name - Type 01``() = x.DoNamedTest()
     [<Test>] member x.``Qualifiers - Type extension 01``() = x.DoNamedTest()
 
+    [<Test>] member x.``Qualifiers - Namespace 01``() = x.DoNamedTest()
+
     [<Test; NotAvailable>] member x.``Not available 01 - Open``() = x.DoNamedTest()