treewide: Expr.Types: add PositionSet

Author: Anton-Latukha

src/Nix/Builtins.hs

@@ -59,7 +59,6 @@ import           Nix.Effects
 import           Nix.Effects.Basic              ( fetchTarball )
 import           Nix.Exec
 import           Nix.Expr.Types
-import           Nix.Expr.Types.Annotated
 import qualified Nix.Eval                      as Eval
 import           Nix.Frames
 import           Nix.Json
@@ -441,7 +440,7 @@ hasAttrNix
 hasAttrNix x y =
   do
     (coerce -> key) <- fromStringNoContext =<< fromValue x
-    (aset, _) <- fromValue @(AttrSet (NValue t f m), KeyMap SourcePos) y
+    (aset, _) <- fromValue @(AttrSet (NValue t f m), PositionSet) y
 
     toValue $ M.member key aset
 
@@ -457,7 +456,7 @@ getAttrNix
 getAttrNix x y =
   do
     (coerce -> key) <- fromStringNoContext =<< fromValue x
-    (aset, _) <- fromValue @(AttrSet (NValue t f m), KeyMap SourcePos) y
+    (aset, _) <- fromValue @(AttrSet (NValue t f m), PositionSet) y
 
     attrsetGet key aset
 
@@ -477,7 +476,7 @@ unsafeGetAttrPosNix nvX nvY =
         maybe
           (pure nvNull)
           toValue
-          (M.lookup (stringIgnoreContext ns) apos)
+          (M.lookup @VarName (coerce $ stringIgnoreContext ns) apos)
       _xy -> throwError $ ErrorCall $ "Invalid types for builtins.unsafeGetAttrPosNix: " <> show _xy
 
 -- This function is a bit special in that it doesn't care about the contents
@@ -1074,10 +1073,10 @@ removeAttrsNix
   -> m (NValue t f m)
 removeAttrsNix set v =
   do
-    (m, p) <- fromValue @(AttrSet (NValue t f m), KeyMap SourcePos) set
+    (m, p) <- fromValue @(AttrSet (NValue t f m), PositionSet) set
     (nsToRemove :: [NixString]) <- fromValue $ Deeper v
-    toRemove <- traverse (fmap (coerce @Text @VarName) . fromStringNoContext) nsToRemove
-    toValue (go @VarName m toRemove, go @Text p (coerce @VarName <$> toRemove))
+    (coerce -> toRemove) <- traverse fromStringNoContext nsToRemove
+    toValue (go m toRemove, go p toRemove)
  where
   go :: forall k v . (Eq k, Hashable k) => HashMap k v -> [k] -> HashMap k v
   go = foldl' (flip M.delete)
@@ -1090,8 +1089,8 @@ intersectAttrsNix
   -> m (NValue t f m)
 intersectAttrsNix set1 set2 =
   do
-    (s1, p1) <- fromValue @(AttrSet (NValue t f m), KeyMap SourcePos) set1
-    (s2, p2) <- fromValue @(AttrSet (NValue t f m), KeyMap SourcePos) set2
+    (s1, p1) <- fromValue @(AttrSet (NValue t f m), PositionSet) set1
+    (s2, p2) <- fromValue @(AttrSet (NValue t f m), PositionSet) set2
 
     pure $ nvSet (p2 `M.intersection` p1) (s2 `M.intersection` s1)
 

src/Nix/Convert.hs

@@ -285,7 +285,7 @@ instance ( Convertible e t f m
   fromValue = fromMayToDeeperValue TSet
 
 instance Convertible e t f m
-  => FromValue (AttrSet (NValue t f m), KeyMap SourcePos) m
+  => FromValue (AttrSet (NValue t f m), PositionSet) m
               (NValue' t f m (NValue t f m)) where
 
   fromValueMay =
@@ -299,7 +299,7 @@ instance Convertible e t f m
 instance ( Convertible e t f m
          , FromValue a m (NValue t f m)
          )
-  => FromValue (AttrSet a, KeyMap SourcePos) m
+  => FromValue (AttrSet a, PositionSet) m
               (Deeper (NValue' t f m (NValue t f m))) where
 
   fromValueMay =
@@ -400,12 +400,12 @@ instance (Convertible e t f m, ToValue a m (NValue t f m))
       stub
 
 instance Convertible e t f m
-  => ToValue (AttrSet (NValue t f m), KeyMap SourcePos) m
+  => ToValue (AttrSet (NValue t f m), PositionSet) m
             (NValue' t f m (NValue t f m)) where
   toValue (s, p) = pure $ nvSet' p s
 
 instance (Convertible e t f m, ToValue a m (NValue t f m))
-  => ToValue (AttrSet a, KeyMap SourcePos) m
+  => ToValue (AttrSet a, PositionSet) m
             (Deeper (NValue' t f m (NValue t f m))) where
   toValue (s, p) =
     liftA2 (\ v s -> Deeper $ nvSet' s v)

src/Nix/Eval.hs

@@ -60,9 +60,9 @@ class (Show v, Monad m) => MonadEval v m where
   evalListElem   :: [m v] -> Int -> m v -> m v
   evalList       :: [v] -> m v
   evalSetElem    :: AttrSet (m v) -> Text -> m v -> m v
-  evalSet        :: AttrSet v -> KeyMap SourcePos -> m v
+  evalSet        :: AttrSet v -> PositionSet -> m v
   evalRecSetElem :: AttrSet (m v) -> Text -> m v -> m v
-  evalRecSet     :: AttrSet v -> KeyMap SourcePos -> m v
+  evalRecSet     :: AttrSet v -> PositionSet -> m v
   evalLetElem    :: Text -> m v -> m v
   evalLet        :: m v -> m v
 -}
@@ -76,8 +76,8 @@ type MonadNixEval v m
   , ToValue Bool m v
   , ToValue [v] m v
   , FromValue NixString m v
-  , ToValue (AttrSet v, KeyMap SourcePos) m v
-  , FromValue (AttrSet v, KeyMap SourcePos) m v
+  , ToValue (AttrSet v, PositionSet) m v
+  , FromValue (AttrSet v, PositionSet) m v
   )
 
 data EvalFrame m v
@@ -209,7 +209,7 @@ evalWithAttrSet aset body = do
   -- sure the action it evaluates is to force a thunk, so its value is only
   -- computed once.
   deferredAset <- defer $ withScopes scope aset
-  let attrSet = fst <$> (fromValue @(AttrSet v, KeyMap SourcePos) =<< demand deferredAset)
+  let attrSet = fst <$> (fromValue @(AttrSet v, PositionSet) =<< demand deferredAset)
 
   pushWeakScope attrSet body
 
@@ -219,9 +219,9 @@ attrSetAlter
   => [VarName]
   -> SourcePos
   -> AttrSet (m v)
-  -> KeyMap SourcePos
+  -> PositionSet
   -> m v
-  -> m (AttrSet (m v), KeyMap SourcePos)
+  -> m (AttrSet (m v), PositionSet)
 attrSetAlter [] _ _ _ _ = evalError @v $ ErrorCall "invalid selector with no components"
 attrSetAlter (k : ks) pos m p val =
   bool
@@ -230,7 +230,7 @@ attrSetAlter (k : ks) pos m p val =
       (recurse mempty mempty)
       (\x ->
         do
-          (st, sp) <- fromValue @(AttrSet v, KeyMap SourcePos) =<< x
+          (st, sp) <- fromValue @(AttrSet v, PositionSet) =<< x
           recurse (demand <$> st) sp
       )
       (M.lookup k m)
@@ -243,7 +243,7 @@ attrSetAlter (k : ks) pos m p val =
     (\(st', _) ->
       (M.insert
         k
-        (toValue @(AttrSet v, KeyMap SourcePos) =<< (, mempty) <$> sequence st')
+        (toValue @(AttrSet v, PositionSet) =<< (, mempty) <$> sequence st')
         m
       , M.insert (coerce k) pos p
       )
@@ -293,7 +293,7 @@ evalBinds
    . MonadNixEval v m
   => Bool
   -> [Binding (m v)]
-  -> m (AttrSet v, KeyMap SourcePos)
+  -> m (AttrSet v, PositionSet)
 evalBinds recursive binds =
   do
     scope <- currentScopes :: m (Scopes m v)
@@ -304,7 +304,7 @@ evalBinds recursive binds =
   buildResult
     :: Scopes m v
     -> [([VarName], SourcePos, m v)]
-    -> m (AttrSet v, KeyMap SourcePos)
+    -> m (AttrSet v, PositionSet)
   buildResult scope bindings =
     do
       (s, p) <- foldM insert (mempty, mempty) bindings
@@ -331,7 +331,7 @@ evalBinds recursive binds =
       pure $
         (\ (k, v) ->
           ( [k]
-          , fromMaybe pos $ M.lookup @Text (coerce k) p'
+          , fromMaybe pos $ M.lookup k p'
           , demand v
           )
         ) <$> M.toList o'
@@ -349,7 +349,7 @@ evalBinds recursive binds =
     processAttrSetKeys (h :| t) =
       maybe
         -- Empty attrset - return a stub.
-        (pure ( mempty, nullPos, toValue @(AttrSet v, KeyMap SourcePos) (mempty, mempty)) )
+        (pure ( mempty, nullPos, toValue @(AttrSet v, PositionSet) (mempty, mempty)) )
         (\ k ->
           list
             -- No more keys in the attrset - return the result
@@ -387,7 +387,7 @@ evalBinds recursive binds =
                     (withScopes scope $ lookupVar key)
                     (\ s ->
                       do
-                        (attrset, _) <- fromValue @(AttrSet v, KeyMap SourcePos) =<< s
+                        (attrset, _) <- fromValue @(AttrSet v, PositionSet) =<< s
 
                         clearScopes @v $ pushScope attrset $ lookupVar key
                     )
@@ -423,7 +423,7 @@ evalSelect aset attr =
 
       case x' of
         Nothing -> pure $ Left (x, path)
-        Just (s :: AttrSet v, p :: KeyMap SourcePos)
+        Just (s :: AttrSet v, p :: PositionSet)
           | Just t <- M.lookup k s ->
             do
               list
@@ -490,7 +490,7 @@ buildArgument params arg =
       Param name -> M.singleton name <$> argThunk
       ParamSet s isVariadic m ->
         do
-          (args, _) <- fromValue @(AttrSet v, KeyMap SourcePos) =<< arg
+          (args, _) <- fromValue @(AttrSet v, PositionSet) =<< arg
           let
             inject =
               maybe

src/Nix/Exec.hs

@@ -86,7 +86,7 @@ nvListP p l = addProvenance p $ nvList l
 nvSetP
   :: MonadCited t f m
   => Provenance m (NValue t f m)
-  -> KeyMap SourcePos
+  -> PositionSet
   -> AttrSet (NValue t f m)
   -> NValue t f m
 nvSetP p x s = addProvenance p $ nvSet x s

src/Nix/Expr/Types.hs

@@ -104,6 +104,10 @@ instance FromJSON Pos where
   parseJSON = fmap mkPos . parseJSON
 instance FromJSON SourcePos
 
+-- | Holds file positionng information for abstrations.
+-- A type synonym for @HashMap VarName SourcePos@.
+type PositionSet = HashMap VarName SourcePos
+
 
 -- * Components of Nix expressions
 

src/Nix/Lint.hs

@@ -273,9 +273,9 @@ instance ToValue [Symbolic m] m (Symbolic m) where
 
 instance FromValue NixString m (Symbolic m) where
 
-instance FromValue (AttrSet (Symbolic m), KeyMap SourcePos) m (Symbolic m) where
+instance FromValue (AttrSet (Symbolic m), PositionSet) m (Symbolic m) where
 
-instance ToValue (AttrSet (Symbolic m), KeyMap SourcePos) m (Symbolic m) where
+instance ToValue (AttrSet (Symbolic m), PositionSet) m (Symbolic m) where
 
 instance (MonadThunkId m, MonadAtomicRef m, MonadCatch m)
   => MonadValue (Symbolic m) m where

src/Nix/Type/Infer.hs

@@ -56,7 +56,6 @@ import qualified Nix.Eval                      as Eval
                                                 , evalWithAttrSet
                                                 )
 import           Nix.Expr.Types
-import           Nix.Expr.Types.Annotated
 import           Nix.Fresh
 import           Nix.String
 import           Nix.Scope
@@ -335,7 +334,7 @@ instance
 instance
   MonadInfer m
   => FromValue ( AttrSet (Judgment s)
-              , KeyMap SourcePos
+              , PositionSet
               ) (InferT s m) (Judgment s)
  where
   fromValueMay (Judgment _ _ (TSet _ xs)) =
@@ -350,7 +349,7 @@ instance
       <=< fromValueMay
 
 instance MonadInfer m
-  => ToValue (AttrSet (Judgment s), KeyMap SourcePos)
+  => ToValue (AttrSet (Judgment s), PositionSet)
             (InferT s m) (Judgment s) where
   toValue (xs, _) =
     liftA3

src/Nix/Value.hs

@@ -42,7 +42,6 @@ import           Lens.Family2.TH                ( makeTraversals
                                                 )
 import           Nix.Atoms
 import           Nix.Expr.Types
-import           Nix.Expr.Types.Annotated
 import           Nix.String
 import           Nix.Thunk
 
@@ -124,8 +123,8 @@ data NValueF p m r
     -- Quite frequently actions/processing happens with values
     -- (for example - forcing of values & recreation of the monad),
     -- but SourcePos does not change then
-    -- That would be good to flip all 'AttrSet.* KeyMap SourcePos'
-    | NVSetF (AttrSet r) (KeyMap SourcePos)
+    -- That would be good to flip all 'AttrSet.* PositionSet'
+    | NVSetF (AttrSet r) PositionSet
     | NVClosureF (Params ()) (p -> m r)
       -- ^ A function is a closed set of parameters representing the "call
       --   signature", used at application time to check the type of arguments
@@ -445,7 +444,7 @@ nvList' = NValue' . pure . NVListF
 
 -- | Haskell key-value to the Nix key-value,
 nvSet' :: Applicative f
-  => KeyMap SourcePos
+  => PositionSet
   -> AttrSet r
   -> NValue' t f m r
 --  2021-07-16: NOTE: that the arguments are flipped.
@@ -628,7 +627,7 @@ nvList = Free . nvList'
 
 
 nvSet :: Applicative f
-  => KeyMap SourcePos
+  => PositionSet
   -> AttrSet (NValue t f m)
   -> NValue t f m
 nvSet p s = Free $ nvSet' p s