make dependents look at file if nothing in codebase matches

parser-typechecker/src/Unison/Codebase.hs

@@ -130,7 +130,6 @@ import Control.Monad.Except (ExceptT)
 import Data.Map qualified as Map
 import Data.Set qualified as Set
 import Data.Text qualified as Text
-import Data.These (These (..))
 import U.Codebase.Branch qualified as V2Branch
 import U.Codebase.Causal qualified as V2Causal
 import U.Codebase.HashTags (CausalHash)
@@ -159,6 +158,7 @@ import Unison.DataDeclaration qualified as DD
 import Unison.Hash (Hash)
 import Unison.Hashing.V2.Convert qualified as Hashing
 import Unison.LabeledDependency qualified as LD
+import Unison.NamesUtils qualified as NamesUtils
 import Unison.Parser.Ann (Ann)
 import Unison.Parser.Ann qualified as Parser
 import Unison.Prelude
@@ -535,31 +535,14 @@ dependentsWithinBranchScope ::
   DefnsF Set Referent TypeReference ->
   Sqlite.Transaction (DefnsF Set TermReferenceId Reference.TypeReferenceId)
 dependentsWithinBranchScope branch0 refs = do
-  Operations.directDependentsWithinScope (Branch.deepDefnsIds branch0) (defnsToRefs refs)
+  Operations.directDependentsWithinScope (Branch.deepDefnsIds branch0) (NamesUtils.referentsToRefs refs)
 
 directDependencies ::
   DefnsF Set Referent TypeReference ->
   Sqlite.Transaction (DefnsF Set TermReference TypeReference)
 directDependencies refs = do
   Operations.directDependenciesOfScope Builtin.isBuiltinType (defnsToRefsIds refs)
 
-defnsToRefs :: DefnsF Set Referent TypeReference -> DefnsF Set TermReference TypeReference
-defnsToRefs defns =
-  Defns
-    { terms = termRefs,
-      types = Set.union constructorRefs defns.types
-    }
-  where
-    termRefs :: Set TermReference
-    constructorRefs :: Set TypeReference
-    (termRefs, constructorRefs) =
-      Set.unalignWith
-        ( \case
-            Referent.Con (ConstructorReference ref _) _ -> That ref
-            Referent.Ref ref -> This ref
-        )
-        defns.terms
-
 defnsToRefsIds :: DefnsF Set Referent TypeReference -> DefnsF Set TermReferenceId TypeReferenceId
 defnsToRefsIds defns =
   Defns

parser-typechecker/src/Unison/UnisonFile/Names.hs

@@ -54,7 +54,7 @@ typecheckedToNames uf = Names (terms <> ctors) types
       Relation.fromList
         [ (Name.unsafeParseVar v, Referent.Ref r)
           | (v, (_a, r, wk, _, _)) <- Map.toList $ UF.hashTerms uf,
-            wk == Nothing || wk == Just WK.TestWatch
+            WK.watchKindShouldBeStoredInDatabase wk
         ]
     types =
       Relation.fromList

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

@@ -4,7 +4,7 @@ module Unison.Codebase.Editor.HandleInput.Dependencies
 where
 
 import Control.Arrow ((***))
-import Data.Bifoldable (bifoldMap, binull)
+import Data.Bifoldable (binull)
 import Data.Set qualified as Set
 import Unison.Cli.Monad (Cli)
 import Unison.Cli.Monad qualified as Cli
@@ -16,7 +16,6 @@ import Unison.Codebase.Editor.Output
 import Unison.Codebase.Editor.StructuredArgument qualified as SA
 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.Prelude
@@ -25,13 +24,13 @@ import Unison.PrettyPrintEnv.Names qualified as PPE
 import Unison.Reference (Reference)
 import Unison.Referent qualified as Referent
 import Unison.Syntax.HashQualifiedPrime qualified as HQ'
-import Unison.Util.Defns (Defns (..), DefnsF)
+import Unison.Util.Defns (Defns (..), DefnsF, DefnsF2)
 
 handleDependencies :: HQ.HashQualified Name -> Cli ()
 handleDependencies hq = do
-  refs <- resolveHQName hq
+  dependentsRefs <- resolveHQName hq
 
-  when (binull refs) do
+  when (binull dependentsRefs) do
     Cli.returnEarly (LabeledReferenceNotFound hq)
 
   namespace <- Cli.getCurrentProjectRoot0
@@ -40,7 +39,7 @@ handleDependencies hq = do
          in PPE.makePPE (PPE.hqNamer 10 names) (PPE.suffixifyByHash names)
 
   dependencies <- do
-    Cli.runTransaction $ Codebase.directDependencies refs
+    Cli.runTransaction $ Codebase.directDependencies dependentsRefs
 
   let dependencyNames ::
         DefnsF
@@ -82,5 +81,11 @@ handleDependencies hq = do
     & map (SA.HashQualified . fst)
     & Cli.setNumberedArgs
 
-  let lds = bifoldMap (Set.map LD.referent) (Set.map LD.typeRef) refs
-  Cli.respond (ListDependencies ppe lds dependencyNames)
+  let dependentsNames :: DefnsF2 Set HQ.HashQualified Name Name
+      dependentsNames =
+        bimap
+          (Set.map (PPE.termNameOrHashOnly ppe))
+          (Set.map (PPE.typeNameOrHashOnly ppe))
+          dependentsRefs
+
+  Cli.respond (ListDependencies dependentsNames dependencyNames)