Persist name resolution for measure names

liquid-prelude/src/Language/Haskell/Liquid/Bag.hs

@@ -5,13 +5,6 @@ module Language.Haskell.Liquid.Bag where
 import qualified Data.Map      as M
 
 {-@ embed   Bag as Bag_t                             @-}
-{-@ measure Bag_empty     :: Int -> Bag a            @-}
-{-@ measure Bag_sng       :: a -> Int -> Bag a       @-}
-{-@ measure Bag_count     :: Bag a -> a -> Int       @-}
-{-@ measure Bag_union     :: Bag a -> Bag a -> Bag a @-}
-{-@ measure Bag_union_max :: Bag a -> Bag a -> Bag a @-}
-{-@ measure Bag_inter_min :: Bag a -> Bag a -> Bag a @-}
-{-@ measure Bag_sub       :: Bag a -> Bag a -> Bool  @-}
 {-@ measure bagSize       :: Bag a -> Int            @-}
 
 -- if I just write measure fromList the measure definition is not imported

liquidhaskell-boot/src-ghc/Liquid/GHC/API.hs

@@ -768,6 +768,7 @@ import GHC.Unit.Module                as Ghc
     , stableModuleCmp
     , fsToUnit
     , mkModuleNameFS
+    , moduleEnvKeys
     , moduleNameFS
     , moduleStableString
     , toUnitId

liquidhaskell-boot/src-ghc/Liquid/GHC/API/Extra.hs

@@ -32,7 +32,6 @@ import Data.Data (Data, gmapQr, gmapT)
 import Data.Generics (extQ, extT)
 import Data.Foldable                  (asum)
 import Data.List                      (sortOn)
-import qualified Data.Set as S
 import GHC.Builtin.Names ( dollarIdKey, minusName )
 import GHC.Core                       as Ghc
 import GHC.Core.Coercion              as Ghc
@@ -81,8 +80,8 @@ dataConSig dc
   = (dataConUnivAndExTyCoVars dc, dataConTheta dc, map irrelevantMult $ dataConOrigArgTys dc, dataConOrigResTy dc)
 
 -- | Extracts the direct imports of a module.
-directImports :: TcGblEnv -> S.Set Module
-directImports = S.fromList . moduleEnvKeys . imp_mods . tcg_imports
+directImports :: TcGblEnv -> [Module]
+directImports = moduleEnvKeys . imp_mods . tcg_imports
 
 -- | Abstraction of 'EpaComment'.
 data ApiComment

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare.hs

@@ -101,7 +101,7 @@ makeTargetSpec cfg localVars lnameEnv lmap targetSrc bareSpec dependencies = do
   where
     secondPhase :: [Warning] -> Ghc.TcRn (Either Diagnostics ([Warning], TargetSpec, LiftedSpec))
     secondPhase phaseOneWarns = do
-      diagOrSpec <- makeGhcSpec cfg localVars (fromTargetSrc targetSrc) lmap bareSpec legacyDependencies
+      diagOrSpec <- makeGhcSpec cfg lnameEnv localVars (fromTargetSrc targetSrc) lmap bareSpec legacyDependencies
       case diagOrSpec of
         Left d -> return $ Left d
         Right (warns, ghcSpec) -> do
@@ -129,26 +129,27 @@ makeTargetSpec cfg localVars lnameEnv lmap targetSrc bareSpec dependencies = do
           exportedAssumption _ = True
       return lspec { liftedAsmSigs = S.filter (exportedAssumption . val . fst) (liftedAsmSigs lspec) }
 
-    ghcSpecToLiftedSpec = toLiftedSpec . toBareSpecLHName cfg lnameEnv . _gsLSpec
+    ghcSpecToLiftedSpec = toLiftedSpec lnameEnv . toBareSpecLHName cfg lnameEnv . _gsLSpec
 
 
 -------------------------------------------------------------------------------------
 -- | @makeGhcSpec@ invokes @makeGhcSpec0@ to construct the @GhcSpec@ and then
 --   validates it using @checkGhcSpec@.
 -------------------------------------------------------------------------------------
 makeGhcSpec :: Config
+            -> LogicNameEnv
             -> Bare.LocalVars
             -> GhcSrc
             -> LogicMap
             -> Ms.BareSpec
             -> [(ModName, Ms.BareSpec)]
             -> Ghc.TcRn (Either Diagnostics ([Warning], GhcSpec))
 -------------------------------------------------------------------------------------
-makeGhcSpec cfg localVars src lmap targetSpec dependencySpecs = do
+makeGhcSpec cfg lenv localVars src lmap targetSpec dependencySpecs = do
   ghcTyLookupEnv <- Bare.makeGHCTyLookupEnv (_giCbs src)
   tcg <- Ghc.getGblEnv
   instEnvs <- Ghc.tcGetInstEnvs
-  (dg0, sp) <- makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs localVars src lmap targetSpec dependencySpecs
+  (dg0, sp) <- makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs lenv localVars src lmap targetSpec dependencySpecs
   let diagnostics = Bare.checkTargetSpec (targetSpec : map snd dependencySpecs)
                                          (toTargetSrc src)
                                          (ghcSpecEnv sp)
@@ -191,13 +192,14 @@ makeGhcSpec0
   -> Bare.GHCTyLookupEnv
   -> Ghc.TcGblEnv
   -> Ghc.InstEnvs
+  -> LogicNameEnv
   -> Bare.LocalVars
   -> GhcSrc
   -> LogicMap
   -> Ms.BareSpec
   -> [(ModName, Ms.BareSpec)]
   -> Ghc.TcRn (Diagnostics, GhcSpec)
-makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs localVars src lmap targetSpec dependencySpecs = do
+makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs lenv localVars src lmap targetSpec dependencySpecs = do
   -- build up environments
   tycEnv <- makeTycEnv1 name env (tycEnv0, datacons) coreToLg simplifier
   let tyi      = Bare.tcTyConMap   tycEnv
@@ -219,7 +221,7 @@ makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs localVars src lmap targetSpec depen
   let (dg4, measEnv) = withDiagnostics $ addOpaqueReflMeas cfg tycEnv env mySpec measEnv0 specs eqs
   let qual     = makeSpecQual cfg env tycEnv measEnv rtEnv specs
   let (dg5, spcVars) = withDiagnostics $ makeSpecVars cfg src mySpec env measEnv
-  let (dg6, spcTerm) = withDiagnostics $ makeSpecTerm cfg     mySpec env       name
+  let (dg6, spcTerm) = withDiagnostics $ makeSpecTerm cfg     mySpec lenv env
   let sData    = makeSpecData  src env sigEnv measEnv elaboratedSig specs
   let finalLiftedSpec = makeLiftedSpec name src env refl sData elaboratedSig qual myRTE (lSpec0 <> lSpec1)
   let diags    = mconcat [dg0, dg1, dg2, dg3, dg4, dg5, dg6]
@@ -252,7 +254,7 @@ makeGhcSpec0 cfg ghcTyLookupEnv tcg instEnvs localVars src lmap targetSpec depen
                     | v <- gsReflects refl
                     ]
                 , dataDecls = Bare.dataDeclSize mySpec $ dataDecls mySpec
-                , measures  = Ms.measures mySpec
+                , measures  = mconcat $ map Ms.measures $ mySpec : map snd dependencySpecs
                   -- We want to export measures in a 'LiftedSpec', especially if they are
                   -- required to check termination of some 'liftedSigs' we export. Due to the fact
                   -- that 'lSpec1' doesn't contain the measures that we compute via 'makeHaskellMeasures',
@@ -531,11 +533,11 @@ tyConSortRaw :: F.Located Ghc.TyCon -> F.Sort
 tyConSortRaw = FTC . F.symbolFTycon . fmap F.symbol
 
 ------------------------------------------------------------------------------------------
-makeSpecTerm :: Config -> Ms.BareSpec -> Bare.Env -> ModName ->
+makeSpecTerm :: Config -> Ms.BareSpec -> LogicNameEnv -> Bare.Env ->
                 Bare.Lookup GhcSpecTerm
 ------------------------------------------------------------------------------------------
-makeSpecTerm cfg mySpec env name = do
-  sizes  <- if structuralTerm cfg then pure mempty else makeSize env name mySpec
+makeSpecTerm cfg mySpec lenv env = do
+  sizes  <- if structuralTerm cfg then pure mempty else makeSize lenv env mySpec
   lazies <- makeLazy     env mySpec
   autos  <- makeAutoSize env mySpec
   gfail  <- makeFail env mySpec
@@ -597,12 +599,20 @@ makeAutoSize env
   . S.toList
   . Ms.autosize
 
-makeSize :: Bare.Env -> ModName -> Ms.BareSpec -> Bare.Lookup (S.HashSet Ghc.Var)
-makeSize env name
+makeSize :: LogicNameEnv -> Bare.Env -> Ms.BareSpec -> Bare.Lookup (S.HashSet Ghc.Var)
+makeSize lenv env
   = fmap S.fromList
-  . mapM (Bare.lookupGhcVar env name "Var")
+  . mapM lookupGhcSize
   . Mb.mapMaybe getSizeFuns
   . Ms.dataDecls
+  where
+    lookupGhcSize :: LocSymbol -> Bare.Lookup Ghc.Var
+    lookupGhcSize s =
+      case lookupSEnv (val s) (lneLHName lenv) of
+        Nothing -> panic (Just $ GM.fSrcSpan s) $ "symbol not in scope: " ++ show (val s)
+        Just n -> case maybeReflectedLHName n of
+          Nothing -> panic (Just $ GM.fSrcSpan s) $ "symbol not reflected: " ++ show (val s)
+          Just rn -> Bare.lookupGhcIdLHName env (makeGHCLHName rn (symbol rn) <$ s)
 
 getSizeFuns :: DataDecl -> Maybe LocSymbol
 getSizeFuns decl
@@ -1032,12 +1042,12 @@ makeInvariants env sigEnv (name, spec) =
     , let ts = Bare.cookSpecType env sigEnv name Bare.GenTV <$> bts
   ]
 
-makeSizeInv :: F.LocSymbol -> Located SpecType -> Located SpecType
+makeSizeInv :: F.Symbol -> Located SpecType -> Located SpecType
 makeSizeInv s lst = lst{val = go (val lst)}
   where go (RApp c ts rs r) = RApp c ts rs (r `meet` nat)
         go (RAllT a t r)    = RAllT a (go t) r
         go t = t
-        nat  = MkUReft (Reft (vv_, PAtom Le (ECon $ I 0) (EApp (EVar $ val s) (eVar vv_))))
+        nat  = MkUReft (Reft (vv_, PAtom Le (ECon $ I 0) (EApp (EVar s) (eVar vv_))))
                        mempty
 
 makeMeasureInvariants :: Bare.Env -> ModName -> GhcSpecSig -> Ms.BareSpec

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare/DataType.hs

@@ -422,10 +422,10 @@ makeConTypes'' env name spec dcs vdcs = do
 
 
 type DSizeMap = M.HashMap LHName (F.Symbol, [LHName])
-normalizeDSize :: [([LocBareType], F.LocSymbol)] -> DSizeMap
+normalizeDSize :: [([LocBareType], F.Symbol)] -> DSizeMap
 normalizeDSize ds = M.fromList (concatMap go ds)
   where go (ts,x) = let xs = Mb.mapMaybe (getTc . val) ts
-                    in [(tc, (val x, xs)) | tc <- xs]
+                    in [(tc, (x, xs)) | tc <- xs]
         getTc (RAllT _ t _)  = getTc t
         getTc (RApp c _ _ _) = Just (val $ btc_tc c)
         getTc _ = Nothing

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare/Measure.hs

@@ -62,7 +62,7 @@ import qualified Data.List as L
 
 --------------------------------------------------------------------------------
 makeHaskellMeasures :: Bool -> GhcSrc -> Bare.TycEnv -> LogicMap -> Ms.BareSpec
-                    -> [Measure (Located BareType) LocSymbol]
+                    -> [Measure (Located BareType) (Located LHName)]
 --------------------------------------------------------------------------------
 makeHaskellMeasures allowTC src tycEnv lmap spec
           = Bare.measureToBare <$> ms
@@ -362,7 +362,7 @@ makeMeasureSpec :: Bare.Env -> Bare.SigEnv -> ModName -> (ModName, Ms.BareSpec)
                    Bare.Lookup (Ms.MSpec SpecType Ghc.DataCon)
 ----------------------------------------------------------------------------------------------
 makeMeasureSpec env sigEnv myName (name, spec)
-  = mkMeasureDCon env               name
+  = mkMeasureDCon env
   . mkMeasureSort env               name
   . first val
   . bareMSpec     env sigEnv myName name
@@ -506,43 +506,39 @@ collectDataCons expr = go expr S.empty
     goBind (Ghc.NonRec _ e) acc = go e acc
     goBind (Ghc.Rec binds) acc = foldr (go . snd) acc binds
 
-bareMSpec :: Bare.Env -> Bare.SigEnv -> ModName -> ModName -> Ms.BareSpec -> Ms.MSpec LocBareType LocSymbol
+bareMSpec :: Bare.Env -> Bare.SigEnv -> ModName -> ModName -> Ms.BareSpec -> Ms.MSpec LocBareType (Located LHName)
 bareMSpec env sigEnv myName name spec = Ms.mkMSpec ms cms ims oms
   where
-    cms        = F.notracepp "CMS" $ filter inScope1 $             Ms.cmeasures spec
-    ms         = F.notracepp "UMS" $ filter inScope2 $ expMeas <$> Ms.measures  spec
-    ims        = F.notracepp "IMS" $ filter inScope2 $ expMeas <$> Ms.imeasures spec
-    oms        = F.notracepp "OMS" $ filter inScope2 $ expMeas <$> Ms.omeasures spec
+    cms        = F.notracepp "CMS" $ filter inScope $             Ms.cmeasures spec
+    ms         = F.notracepp "UMS" $ filter inScope $ expMeas <$> Ms.measures  spec
+    ims        = F.notracepp "IMS" $ filter inScope $ expMeas <$> Ms.imeasures spec
+    oms        = F.notracepp "OMS" $ filter inScope $ expMeas <$> Ms.omeasures spec
     expMeas    = expandMeasure env name  rtEnv
     rtEnv      = Bare.sigRTEnv          sigEnv
     force      = name == myName
-    inScope1 z = F.notracepp ("inScope1: " ++ F.showpp (msName z)) (force ||  okSort z)
-    inScope2 z = F.notracepp ("inScope2: " ++ F.showpp (msName z)) (force || (okSort z && okCtors z))
+    inScope z = F.notracepp ("inScope1: " ++ F.showpp (msName z)) (force ||  okSort z)
     okSort     = Bare.knownGhcType env name . msSort
-    okCtors    = all (Bare.knownGhcDataCon env name . ctor) . msEqns
 
-mkMeasureDCon :: Bare.Env -> ModName -> Ms.MSpec t LocSymbol -> Bare.Lookup (Ms.MSpec t Ghc.DataCon)
-mkMeasureDCon env name m = do
+mkMeasureDCon :: Bare.Env -> Ms.MSpec t (F.Located LHName) -> Bare.Lookup (Ms.MSpec t Ghc.DataCon)
+mkMeasureDCon env m = do
   let ns = measureCtors m
-  dcs   <- mapM (Bare.lookupGhcDataCon env name "measure-datacon") ns
+  dcs   <- mapM (Bare.lookupGhcDataConLHName env) ns
   return $ mkMeasureDCon_ m (zip (val <$> ns) dcs)
 
 -- mkMeasureDCon env name m = mkMeasureDCon_ m [ (val n, symDC n) | n <- measureCtors m ]
 --   where
 --     symDC                = Bare.lookupGhcDataCon env name "measure-datacon"
 
-mkMeasureDCon_ :: Ms.MSpec t LocSymbol -> [(F.Symbol, Ghc.DataCon)] -> Ms.MSpec t Ghc.DataCon
-mkMeasureDCon_ m ndcs = m' {Ms.ctorMap = cm'}
+mkMeasureDCon_ :: Ms.MSpec t (F.Located LHName) -> [(LHName, Ghc.DataCon)] -> Ms.MSpec t Ghc.DataCon
+mkMeasureDCon_ m ndcs = fmap (tx . val) m
   where
-    m'                = fmap (tx.val) m
-    cm'               = Misc.hashMapMapKeys (F.symbol . tx) $ Ms.ctorMap m'
     tx                = Misc.mlookup (M.fromList ndcs)
 
-measureCtors ::  Ms.MSpec t LocSymbol -> [LocSymbol]
+measureCtors ::  Ms.MSpec t (F.Located LHName) -> [F.Located LHName]
 measureCtors = Misc.sortNub . fmap ctor . concat . M.elems . Ms.ctorMap
 
-mkMeasureSort :: Bare.Env -> ModName -> Ms.MSpec BareType LocSymbol
-              -> Ms.MSpec SpecType LocSymbol
+mkMeasureSort :: Bare.Env -> ModName -> Ms.MSpec BareType (F.Located LHName)
+              -> Ms.MSpec SpecType (F.Located LHName)
 mkMeasureSort env name (Ms.MSpec c mm cm im) =
   Ms.MSpec (map txDef <$> c) (tx <$> mm) (tx <$> cm) (tx <$> im)
     where
@@ -568,7 +564,7 @@ expandMeasure env name rtEnv m = m
   , msEqns = expandMeasureDef env name rtEnv <$> msEqns m
   }
 
-expandMeasureDef :: Bare.Env -> ModName -> BareRTEnv -> Def t LocSymbol -> Def t LocSymbol
+expandMeasureDef :: Bare.Env -> ModName -> BareRTEnv -> Def t (Located LHName) -> Def t (Located LHName)
 expandMeasureDef env name rtEnv d = d
   { body  = F.notracepp msg $ Bare.qualifyExpand env name rtEnv l bs (body d) }
   where

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare/Resolve.hs

@@ -339,8 +339,8 @@ instance Qualify TyConMap where
 instance Qualify TyConP where
   qualify env name _ bs tcp = tcp { tcpSizeFun = qualify env name (tcpLoc tcp) bs <$> tcpSizeFun tcp }
 
-instance Qualify SizeFun where
-  qualify env name _ bs (SymSizeFun lx) = SymSizeFun (qualify env name (F.loc lx) bs lx)
+instance Qualify v => Qualify (SizeFunV v) where
+  qualify env name _ bs (SymSizeFun x) = SymSizeFun (qualify env name (F.loc (F.dummyLoc x)) bs x)
   qualify _   _    _ _  sf              = sf
 
 instance Qualify F.Equation where

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare/ToBare.hs

@@ -15,10 +15,10 @@ import           Data.Bifunctor
 import qualified Language.Fixpoint.Types as F
 import           Language.Haskell.Liquid.GHC.Misc
 import           Liquid.GHC.API
+import           Language.Haskell.Liquid.Types.Names
 import           Language.Haskell.Liquid.Types.RefType
 import           Language.Haskell.Liquid.Types.RType
 import           Language.Haskell.Liquid.Types.Specs
-import           Language.Haskell.Liquid.Types.Types
 
 --------------------------------------------------------------------------------
 specToBare :: SpecType -> BareType
@@ -36,12 +36,8 @@ measureToBare :: SpecMeasure -> BareMeasure
 --------------------------------------------------------------------------------
 measureToBare = bimap (fmap specToBare) dataConToBare
 
-dataConToBare :: DataCon -> LocSymbol
-dataConToBare d = dropModuleNames . F.symbol <$> locNamedThing d
-  where
-    _msg  = "dataConToBare dc = " ++ show d ++ " v = " ++ show v ++ " vx = " ++ show vx
-    v     = dataConWorkId d
-    vx    = F.symbol v
+dataConToBare :: DataCon -> F.Located LHName
+dataConToBare d = makeGHCLHNameFromId . dataConWorkId <$> locNamedThing d
 
 specToBareTC :: RTyCon -> BTyCon
 specToBareTC = tyConBTyCon . rtc_tc

liquidhaskell-boot/src/Language/Haskell/Liquid/Bare/Types.hs

@@ -36,6 +36,7 @@ import qualified Data.HashMap.Strict                   as M
 import qualified Language.Fixpoint.Types               as F 
 import qualified Language.Haskell.Liquid.Measure       as Ms
 import           Language.Haskell.Liquid.Types.DataDecl
+import           Language.Haskell.Liquid.Types.Names
 import qualified Language.Haskell.Liquid.Types.RefType as RT 
 import           Language.Haskell.Liquid.Types.RType
 import           Language.Haskell.Liquid.Types.Types
@@ -153,7 +154,7 @@ data MeasEnv = MeasEnv
   , meDataCons    :: ![(Ghc.Var,  LocSpecType)]           
   , meClasses     :: ![DataConP]                           
   , meMethods     :: ![(ModName, Ghc.Var, LocSpecType)]  
-  , meOpaqueRefl  :: ![(Ghc.Var, Measure (Located BareType) LocSymbol)] -- the opaque-reflected symbols and the corresponding measures
+  , meOpaqueRefl  :: ![(Ghc.Var, Measure (Located BareType) (F.Located LHName))] -- the opaque-reflected symbols and the corresponding measures
   }
 
 instance Semigroup MeasEnv where

liquidhaskell-boot/src/Language/Haskell/Liquid/GHC/CoreToLogic.hs

@@ -20,7 +20,7 @@ coreToLogic = unlines
   , "define Data.Set.Internal.null x           = (Set_emp x)"
   , "define Data.Set.Internal.member x xs      = (Set_mem x xs)"
   , "define Data.Set.Internal.isSubsetOf x y   = (Set_sub x y)"
-  , "define Data.Set.Internal.fromList xs      = (listElts xs)"
+  , "define Data.Set.Internal.fromList xs      = (Data.Set_LHAssumptions.listElts xs)"
   , ""
   , "define GHC.Internal.Real.fromIntegral x = (x)"
   , ""
@@ -40,9 +40,6 @@ coreToLogic = unlines
   , "define Language.Haskell.Liquid.Bag.sub a b      = (Bag_sub a b)"
   , "define Language.Haskell.Liquid.Bag.empty        = (Bag_empty 0)"
   , ""
-  , "define Language.Haskell.Liquid.String.stringEmp = (stringEmp)"
-  , "define Data.RString.RString.stringEmp = (stringEmp)"
-  , "define String.stringEmp  = (stringEmp)"
   , "define Main.mempty       = (mempty)"
   , "define Language.Haskell.Liquid.ProofCombinators.cast x y = (y)"
   , "define Language.Haskell.Liquid.ProofCombinators.withProof x y = (x)"

liquidhaskell-boot/src/Language/Haskell/Liquid/GHC/Plugin.hs

@@ -47,8 +47,6 @@ import           Data.Coerce
 import           Data.Function                            ((&))
 import qualified Data.List                               as L
 import           Data.IORef
-import qualified Data.Set                                as S
-import           Data.Set                                 ( Set )
 import qualified Data.Map                                as M
 import           Data.Map                                 ( Map )
 
@@ -375,7 +373,7 @@ processInputSpec
 processInputSpec cfg pipelineData modSummary inputSpec = do
   tcg <- getGblEnv
   debugLog $ " Input spec: \n" ++ show (fromBareSpecParsed inputSpec)
-  debugLog $ "Direct ===> \n" ++ unlines (renderModule <$> S.toList (directImports tcg))
+  debugLog $ "Direct ===> \n" ++ unlines (renderModule <$> directImports tcg)
 
   logicMap :: LogicMap <- liftIO LH.makeLogicMap
 
@@ -494,7 +492,7 @@ data LiquidHaskellContext = LiquidHaskellContext {
   , lhModuleSummary    :: ModSummary
   , lhModuleTcData     :: TcData
   , lhModuleGuts       :: ModGuts
-  , lhRelevantModules  :: Set Module
+  , lhRelevantModules  :: [Module]
   }
 
 --------------------------------------------------------------------------------
@@ -524,7 +522,7 @@ processModule LiquidHaskellContext{..} = do
   _                   <- liftIO $ LH.checkFilePragmas $ Ms.pragmas bareSpec0
 
   withPragmas lhGlobalCfg file (Ms.pragmas bareSpec0) $ \moduleCfg -> do
-    dependencies <- loadDependencies moduleCfg (S.toList lhRelevantModules)
+    dependencies <- loadDependencies moduleCfg lhRelevantModules
 
     debugLog $ "Found " <> show (HM.size $ getDependencies dependencies) <> " dependencies:"
     when debugLogs $