show full names in dependents output

unison-cli/src/Unison/Codebase/Editor/HandleInput/Dependents.hs

@@ -3,66 +3,77 @@ module Unison.Codebase.Editor.HandleInput.Dependents
   )
 where
 
+import Data.Bifoldable (bifoldMap, binull)
 import Data.Set qualified as Set
-import U.Codebase.Sqlite.Queries qualified as Queries
+import U.Codebase.Sqlite.Operations qualified as Operations
 import Unison.Cli.Monad (Cli)
 import Unison.Cli.Monad qualified as Cli
-import Unison.Cli.NameResolutionUtils (resolveHQToLabeledDependencies)
-import Unison.Cli.NamesUtils qualified as Cli
-import Unison.Codebase qualified as Codebase
+import Unison.Cli.MonadUtils qualified as Cli
+import Unison.Cli.NameResolutionUtils (resolveHQName)
+import Unison.Codebase.Branch qualified as Branch
+import Unison.Codebase.Branch.Names qualified as Branch
 import Unison.Codebase.Editor.Output
 import Unison.Codebase.Editor.StructuredArgument qualified as SA
-import Unison.ConstructorReference (GConstructorReference (..))
 import Unison.HashQualified qualified as HQ
 import Unison.HashQualifiedPrime qualified as HQ'
 import Unison.LabeledDependency qualified as LD
 import Unison.Name (Name)
 import Unison.Name qualified as Name
-import Unison.NameSegment qualified as NameSegment
 import Unison.Prelude
 import Unison.PrettyPrintEnv qualified as PPE
 import Unison.PrettyPrintEnv.Names qualified as PPE
-import Unison.PrettyPrintEnvDecl qualified as PPE hiding (biasTo, empty)
-import Unison.PrettyPrintEnvDecl.Names qualified as PPED
-import Unison.Reference (Reference)
+import Unison.Reference qualified as Reference
 import Unison.Referent qualified as Referent
-import Unison.Syntax.HashQualified qualified as HQ (toText)
-import Unison.Util.List (nubOrdOn)
+import Unison.Syntax.HashQualifiedPrime qualified as HQ' (toText)
+import Unison.Util.Defns (Defns (..), DefnsF)
+import Unison.Util.Set qualified as Set
 
 handleDependents :: HQ.HashQualified Name -> Cli ()
 handleDependents hq = do
-  -- todo: add flag to handle transitive efficiently
-  lds <- resolveHQToLabeledDependencies hq
-  -- Use an unsuffixified PPE here, so we display full names (relative to the current path),
-  -- rather than the shortest possible unambiguous name.
-  names <- Cli.currentNames
-  let pped = PPED.makePPED (PPE.hqNamer 10 names) (PPE.suffixifyByHash names)
-  let fqppe = PPE.unsuffixifiedPPE pped
-  let ppe = PPE.suffixifiedPPE pped
-  when (null lds) do
+  refs <- resolveHQName hq
+
+  when (binull refs) do
     Cli.returnEarly (LabeledReferenceNotFound hq)
 
-  results <- for (toList lds) \ld -> do
-    -- The full set of dependent references, any number of which may not have names in the current namespace.
-    dependents <-
-      let tp = Codebase.dependents Queries.ExcludeOwnComponent
-          tm = \case
-            Referent.Ref r -> Codebase.dependents Queries.ExcludeOwnComponent r
-            Referent.Con (ConstructorReference r _cid) _ct ->
-              Codebase.dependents Queries.ExcludeOwnComponent r
-       in Cli.runTransaction (LD.fold tp tm ld)
-    let -- True is term names, False is type names
-        results :: [(Bool, HQ.HashQualified Name, Reference)]
-        results = do
-          r <- Set.toList dependents
-          Just (isTerm, hq) <- [(True,) <$> PPE.terms fqppe (Referent.Ref r), (False,) <$> PPE.types fqppe r]
-          fullName <- [HQ'.toName hq]
-          guard (not (Name.beginsWithSegment fullName NameSegment.libSegment))
-          Just shortName <- pure $ PPE.terms ppe (Referent.Ref r) <|> PPE.types ppe r
-          pure (isTerm, HQ'.toHQ shortName, r)
-    pure results
-  let sort = fmap fst . nubOrdOn snd . Name.sortByText (HQ.toText . fst)
-  let types = sort [(n, r) | (False, n, r) <- join results]
-  let terms = sort [(n, r) | (True, n, r) <- join results]
-  Cli.setNumberedArgs . map SA.HashQualified $ types <> terms
-  Cli.respond (ListDependents ppe lds types terms)
+  namespace <- Cli.getCurrentProjectRoot0
+  let ppe =
+        let names = Branch.toNames namespace
+         in PPE.makePPE (PPE.hqNamer 10 names) (PPE.suffixifyByHash names)
+
+  let namespaceWithoutLibdeps = Branch.deleteLibdeps namespace
+  let ppeWithoutLibdeps =
+        let names = Branch.toNames namespaceWithoutLibdeps
+         in PPE.makePPE (PPE.hqNamer 10 names) (PPE.suffixifyByHash names)
+
+  dependents <- do
+    Cli.runTransaction do
+      Operations.directDependentsWithinScope
+        ( Set.union
+            (Set.mapMaybe Reference.toId (Branch.deepTypeReferences namespaceWithoutLibdeps))
+            (Set.mapMaybe Referent.toTermReferenceId (Branch.deepReferents namespaceWithoutLibdeps))
+        )
+        (bifoldMap (Set.map Referent.toReference) id refs)
+
+  let dependentNames ::
+        DefnsF
+          []
+          (HQ'.HashQualified Name, HQ'.HashQualified Name)
+          (HQ'.HashQualified Name, HQ'.HashQualified Name)
+      dependentNames =
+        bimap
+          (f (Referent.fromTermReferenceId >>> PPE.termNames ppeWithoutLibdeps))
+          (f (Reference.fromId >>> PPE.typeNames ppeWithoutLibdeps))
+          dependents
+        where
+          f g =
+            Set.toList
+              >>> mapMaybe (g >>> listToMaybe)
+              >>> Name.sortByText (fst >>> HQ'.toText)
+
+  -- Set numbered args
+  (dependentNames.types ++ dependentNames.terms)
+    & map (SA.HashQualified . HQ'.toHQ . fst)
+    & Cli.setNumberedArgs
+
+  let lds = bifoldMap (Set.map LD.referent) (Set.map LD.typeRef) refs
+  Cli.respond (ListDependents ppe lds dependentNames)

unison-cli/src/Unison/Codebase/Editor/Output.hs

@@ -338,7 +338,14 @@ data Output
   | NoBranchWithHash ShortCausalHash
   | ListDependencies PPE.PrettyPrintEnv (Set LabeledDependency) [HQ.HashQualified Name] [HQ.HashQualified Name] -- types, terms
   | -- | List dependents of a type or term.
-    ListDependents PPE.PrettyPrintEnv (Set LabeledDependency) [HQ.HashQualified Name] [HQ.HashQualified Name] -- types, terms
+    ListDependents
+      PPE.PrettyPrintEnv
+      (Set LabeledDependency)
+      ( DefnsF
+          []
+          (HQ'.HashQualified Name, HQ'.HashQualified Name)
+          (HQ'.HashQualified Name, HQ'.HashQualified Name)
+      )
   | DumpNumberedArgs HashLength NumberedArgs
   | DumpBitBooster CausalHash (Map CausalHash [CausalHash])
   | DumpUnisonFileHashes Int [(Name, Reference.Id)] [(Name, Reference.Id)] [(Name, Reference.Id)]

unison-cli/src/Unison/CommandLine/OutputMessages.hs

@@ -1437,8 +1437,15 @@ notifyUser dir = \case
               "",
               "Paste that output into http://bit-booster.com/graph.html"
             ]
-  ListDependents ppe lds types terms ->
-    pure $ listDependentsOrDependencies ppe "Dependents" "dependents" lds types terms
+  ListDependents ppe lds defns ->
+    pure $
+      listDependentsOrDependencies
+        ppe
+        "Dependents"
+        "dependents"
+        lds
+        (map (HQ'.toHQ . fst) defns.types)
+        (map (HQ'.toHQ . fst) defns.terms)
   ListDependencies ppe lds types terms ->
     pure $ listDependentsOrDependencies ppe "Dependencies" "dependencies" lds types terms
   ListStructuredFind terms ->

unison-src/transcripts/idempotent/dependents-dependencies-debugfile.md

@@ -111,7 +111,7 @@ scratch/main> dependents d
 
     Terms:
 
-    1. r
+    1. inside.r
 
   Tip: Try `view 1` to see the source of any numbered item in
        the above list.