remove some noLocs

lib/Quox/Syntax/Dim.idr

@@ -83,7 +83,7 @@ DSubst : Nat -> Nat -> Type
 DSubst = Subst Dim
 
 
-public export FromVar Dim where fromVarLoc = B
+public export FromVar Dim where fromVar = B
 
 
 export

lib/Quox/Syntax/DimEq.idr

@@ -70,13 +70,13 @@ toMaybe (Just x) = Just x
 
 
 export
-fromGround' : Context' DimConst d -> DimEq' d
-fromGround' [<]        = [<]
-fromGround' (ctx :< e) = fromGround' ctx :< Just (K e noLoc)
+fromGround' : BContext d -> Context' DimConst d -> DimEq' d
+fromGround' [<]       [<]        = [<]
+fromGround' (xs :< x) (ctx :< e) = fromGround' xs ctx :< Just (K e x.loc)
 
 export
-fromGround : Context' DimConst d -> DimEq d
-fromGround = C . fromGround'
+fromGround : BContext d -> Context' DimConst d -> DimEq d
+fromGround = C .: fromGround'
 
 
 public export %inline
@@ -243,7 +243,7 @@ prettyCsts : {opts : _} -> BContext d -> DimEq' d ->
 prettyCsts [<] [<] = pure [<]
 prettyCsts dnames (eqs :< Nothing) = prettyCsts (tail dnames) eqs
 prettyCsts dnames (eqs :< Just q)  =
-  [|prettyCsts (tail dnames) eqs :< prettyCst dnames (BV 0 noLoc) (weakD 1 q)|]
+  [|prettyCsts (tail dnames) eqs :< prettyCst dnames (BV 0 q.loc) (weakD 1 q)|]
 
 export
 prettyDimEq' : {opts : _} -> BContext d -> DimEq' d -> Eff Pretty (Doc opts)

lib/Quox/Syntax/Subst.idr

@@ -49,7 +49,7 @@ interface FromVar term => CanSubstSelf term where
 
 public export
 getLoc : FromVar term => Subst term from to -> Var from -> Loc -> term to
-getLoc (Shift by) i      loc = fromVarLoc (shift by i) loc
+getLoc (Shift by) i      loc = fromVar (shift by i) loc
 getLoc (t ::: th) VZ     _   = t
 getLoc (t ::: th) (VS i) loc = getLoc th i loc
 
@@ -95,18 +95,18 @@ map f (t ::: th) = f t ::: map f th
 
 
 public export %inline
-push : CanSubstSelf f => Subst f from to -> Subst f (S from) (S to)
-push th = fromVar VZ ::: (th . shift 1)
+push : CanSubstSelf f => Subst f from to -> Loc -> Subst f (S from) (S to)
+push th loc = fromVar VZ loc ::: (th . shift 1)
 
 -- [fixme] a better way to do this?
 public export
 pushN : CanSubstSelf f => (s : Nat) ->
-        Subst f from to -> Subst f (s + from) (s + to)
-pushN 0     th = th
-pushN (S s) th =
+        Subst f from to -> Loc -> Subst f (s + from) (s + to)
+pushN 0     th _   = th
+pushN (S s) th loc =
   rewrite plusSuccRightSucc s from in
   rewrite plusSuccRightSucc s to in
-  pushN s $ fromVar VZ ::: (th . shift 1)
+  pushN s (fromVar VZ loc ::: (th . shift 1)) loc
 
 public export
 drop1 : Subst f (S from) to -> Subst f from to

lib/Quox/Syntax/Term/Subst.idr

@@ -56,12 +56,12 @@ namespace DSubst.DScopeTermN
   (//) : {s : Nat} ->
          DScopeTermN s d1 n -> Lazy (DSubst d1 d2) ->
          DScopeTermN s d2 n
-  S ns (Y body) // th = S ns $ Y $ body // pushN s th
+  S ns (Y body) // th = S ns $ Y $ body // pushN s th body.loc
   S ns (N body) // th = S ns $ N $ body // th
 
 
-export %inline FromVar (Elim d) where fromVarLoc = B
-export %inline FromVar (Term d) where fromVarLoc = E .: fromVar
+export %inline FromVar (Elim d) where fromVar = B
+export %inline FromVar (Term d) where fromVar = E .: fromVar
 
 
 ||| does the minimal reasonable work:
@@ -104,7 +104,7 @@ namespace ScopeTermN
   (//) : {s : Nat} ->
          ScopeTermN s d n1 -> Lazy (TSubst d n1 n2) ->
          ScopeTermN s d n2
-  S ns (Y body) // th = S ns $ Y $ body // pushN s th
+  S ns (Y body) // th = S ns $ Y $ body // pushN s th body.loc
   S ns (N body) // th = S ns $ N $ body // th
 
 namespace DScopeTermN
@@ -189,12 +189,12 @@ dsub1 t p = dsubN t [< p]
 
 
 public export %inline
-(.zero) : DScopeTerm d n -> {default noLoc loc : Loc} -> Term d n
-body.zero = dsub1 body $ K Zero loc
+(.zero) : DScopeTerm d n -> Term d n
+body.zero = dsub1 body $ K Zero body.loc
 
 public export %inline
-(.one) : DScopeTerm d n -> {default noLoc loc : Loc} -> Term d n
-body.one = dsub1 body $ K One loc
+(.one) : DScopeTerm d n -> Term d n
+body.one = dsub1 body $ K One body.loc
 
 
 public export

lib/Quox/Syntax/Var.idr

@@ -139,13 +139,9 @@ weakIsSpec p i = toNatInj $ trans (weakCorrect p i) (sym $ weakSpecCorrect p i)
 
 
 public export
-interface FromVar f where %inline fromVarLoc : Var n -> Loc -> f n
+interface FromVar f where %inline fromVar : Var n -> Loc -> f n
 
-public export %inline
-fromVar : FromVar f => Var n -> {default noLoc loc : Loc} -> f n
-fromVar x = fromVarLoc x loc
-
-public export FromVar Var where fromVarLoc x _ = x
+public export FromVar Var where fromVar x _ = x
 
 export
 tabulateV : {0 tm : Nat -> Type} -> (forall n. Var n -> tm n) ->