diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,14 @@
 # Revision history for language-oberon
 
+## 0.3.4 -- 2025-01-01
+
+* Adjusted for major changes in `deep-transformations` version 0.4
+
+## 0.3.3.2 -- 2025-01-01
+
+* Fixed a few compiler warnings
+* Bumped the upper bound of `deep-transformations` and `template-haskell`
+
 ## 0.3.3.1 -- 2024-04-27
 
 * Fixed deprecation warnings
diff --git a/language-oberon.cabal b/language-oberon.cabal
--- a/language-oberon.cabal
+++ b/language-oberon.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                language-oberon
-version:             0.3.3.2
+version:             0.3.4
 synopsis:            Parser, pretty-printer, and more for the Oberon programming language
 description:
    The library and the executable support both the original Oberon and the Oberon-2 programming language, as described
@@ -35,7 +35,7 @@
                         parsers >= 0.12.7 && < 0.13, input-parsers >= 0.2.2 && < 0.4,
                         prettyprinter >= 1.2.1 && < 1.8, either == 5.*,
                         rank2classes >= 1.3 && < 1.6, grammatical-parsers >= 0.7 && < 0.8,
-                        deep-transformations >= 0.2 && < 0.4,
+                        deep-transformations >= 0.4 && < 0.5,
                         transformers >= 0.5 && < 0.7,
                         template-haskell >= 2.11 && < 2.24
   default-language:     Haskell2010
diff --git a/src/Language/Oberon/ConstantFolder.hs b/src/Language/Oberon/ConstantFolder.hs
--- a/src/Language/Oberon/ConstantFolder.hs
+++ b/src/Language/Oberon/ConstantFolder.hs
@@ -49,17 +49,15 @@
 -- functions. The value of the latter argument is typically 'predefined' or 'predefined2'.
 foldConstants :: (Abstract.Oberon l, Abstract.Nameable l,
                   Ord (Abstract.QualIdent l), Show (Abstract.QualIdent l),
-                  Atts (Inherited (Auto ConstantFold)) (Abstract.Block l l Sem Sem) ~ InhCF l,
-                  Atts (Synthesized (Auto ConstantFold)) (Abstract.Block l l Sem Sem)
+                  Atts (Inherited (Auto ConstantFold)) (Abstract.Block l l) ~ InhCF l,
+                  Atts (Synthesized (Auto ConstantFold)) (Abstract.Block l l)
                   ~ SynCFMod' l (Abstract.Block l l),
-                  Full.Functor (Auto ConstantFold) (Abstract.Block l l),
-                  Deep.Functor (Auto ConstantFold) (Abstract.Block l l))
+                  Full.Functor (AG.Knit (Auto ConstantFold)) (Abstract.Block l l))
               => Environment l -> Map AST.Ident (Placed (AST.Module l l Placed Placed))
               -> Map AST.Ident (Placed (AST.Module l l Placed Placed))
 foldConstants predef modules =
    getModules (modulesFolded $
-               syn (Transformation.apply (Auto ConstantFold)
-                                         (wrap (Auto ConstantFold Deep.<$> Modules modules))
+               syn ((AG.Knit (Auto ConstantFold) Full.<$> wrap (Modules modules))
                     `Rank2.apply`
                     Inherited (InhCFRoot predef)))
    where wrap = (,) (0, Trailing [], 0)
@@ -72,14 +70,9 @@
 
 data ConstantFold = ConstantFold
 
-type Sem = Semantics (Auto ConstantFold)
-
-instance Transformation.Transformation (Auto ConstantFold) where
-   type Domain (Auto ConstantFold) = Placed
-   type Codomain (Auto ConstantFold) = Semantics (Auto ConstantFold)
-
-instance AG.Revelation (Auto ConstantFold) where
-   reveal (Auto ConstantFold) = snd
+instance Attribution ConstantFold where
+   type Origin ConstantFold = Placed
+   unwrap ConstantFold = snd
 
 data InhCFRoot l = InhCFRoot{rootEnv :: Environment l} deriving Generic
 
@@ -106,61 +99,65 @@
 instance (Transformation.Transformation t, Functor (Transformation.Domain t), Deep.Functor t (AST.Module l l),
           Transformation.At t (AST.Module l l (Transformation.Codomain t) (Transformation.Codomain t))) =>
          Deep.Functor t (Modules l) where
-   t <$> ~(Modules ms) = Modules (mapModule <$> ms)
+   t <$> Modules ms = Modules (mapModule <$> ms)
       where mapModule m = t Transformation.$ ((t Deep.<$>) <$> m)
 
 instance Rank2.Functor (Modules l f') where
-   f <$> ~(Modules ms) = Modules (f <$> ms)
+   f <$> Modules ms = Modules (f <$> ms)
 
+instance Rank2.Foldable (Modules l f') where
+   foldMap f (Modules ms) = foldMap f ms
+
+instance Rank2.Traversable (Modules l f') where
+   traverse f (Modules ms) = Modules <$> traverse f ms
+
 instance Rank2.Apply (Modules l f') where
-   ~(Modules fs) <*> ~(Modules ms) = Modules (Map.intersectionWith Rank2.apply fs ms)
+   Modules fs <*> Modules ms = Modules (Map.intersectionWith Rank2.apply fs ms)
 
 instance (Transformation.Transformation t, Transformation.At t (AST.Module l l f f)) =>
          Shallow.Functor t (Modules l f) where
-   t <$> ~(Modules ms) = Modules ((t Transformation.$) <$> ms)
+   t <$> Modules ms = Modules ((t Transformation.$) <$> ms)
 
 -- * Boring attribute types
-type instance Atts (Synthesized ConstantFold) (Modules l _ _) = SynCFRoot (Modules l Placed Placed)
-type instance Atts (Synthesized ConstantFold) (AST.Module l l _ _) = SynCFMod' l (AST.Module l l)
-type instance Atts (Synthesized ConstantFold) (AST.Declaration l l _ _) = SynCFMod' l (AST.Declaration l l)
-type instance Atts (Synthesized ConstantFold) (AST.ProcedureHeading l l _ _) = SynCF' (AST.ProcedureHeading l l)
-type instance Atts (Synthesized ConstantFold) (AST.Block l l _ _) = SynCFMod' l (AST.Block l l)
-type instance Atts (Synthesized ConstantFold) (AST.FormalParameters l l _ _) = SynCF' (AST.FormalParameters l l)
-type instance Atts (Synthesized ConstantFold) (AST.FPSection l l _ _) = SynCF' (AST.FPSection l l)
-type instance Atts (Synthesized ConstantFold) (AST.Type l l _ _) = SynCF' (AST.Type l l)
-type instance Atts (Synthesized ConstantFold) (AST.FieldList l l _ _) = SynCF' (AST.FieldList l l)
-type instance Atts (Synthesized ConstantFold) (AST.StatementSequence l l _ _) =
-   SynCF' (AST.StatementSequence l l)
-type instance Atts (Synthesized ConstantFold) (AST.Expression λ l _ _) = SynCFExp λ l
-type instance Atts (Synthesized ConstantFold) (AST.Element l l _ _) = SynCF' (AST.Element l l)
-type instance Atts (Synthesized ConstantFold) (AST.Value l l _ _) = SynCF' (AST.Value l l)
-type instance Atts (Synthesized ConstantFold) (AST.Designator l l _ _) = SynCFDesignator l
-type instance Atts (Synthesized ConstantFold) (AST.Statement l l _ _) = SynCF' (AST.Statement l l)
-type instance Atts (Synthesized ConstantFold) (AST.Case l l _ _) = SynCF' (AST.Case l l)
-type instance Atts (Synthesized ConstantFold) (AST.CaseLabels l l _ _) = SynCF' (AST.CaseLabels l l)
-type instance Atts (Synthesized ConstantFold) (AST.ConditionalBranch l l _ _) =
-   SynCF' (AST.ConditionalBranch l l)
-type instance Atts (Synthesized ConstantFold) (AST.WithAlternative l l _ _) = SynCF' (AST.WithAlternative l l)
+type instance Atts (Synthesized ConstantFold) (Modules l) = SynCFRoot (Modules l Placed Placed)
+type instance Atts (Synthesized ConstantFold) (AST.Module l l) = SynCFMod' l (AST.Module l l)
+type instance Atts (Synthesized ConstantFold) (AST.Declaration l l) = SynCFMod' l (AST.Declaration l l)
+type instance Atts (Synthesized ConstantFold) (AST.ProcedureHeading l l) = SynCF' (AST.ProcedureHeading l l)
+type instance Atts (Synthesized ConstantFold) (AST.Block l l) = SynCFMod' l (AST.Block l l)
+type instance Atts (Synthesized ConstantFold) (AST.FormalParameters l l) = SynCF' (AST.FormalParameters l l)
+type instance Atts (Synthesized ConstantFold) (AST.FPSection l l) = SynCF' (AST.FPSection l l)
+type instance Atts (Synthesized ConstantFold) (AST.Type l l) = SynCF' (AST.Type l l)
+type instance Atts (Synthesized ConstantFold) (AST.FieldList l l) = SynCF' (AST.FieldList l l)
+type instance Atts (Synthesized ConstantFold) (AST.StatementSequence l l) = SynCF' (AST.StatementSequence l l)
+type instance Atts (Synthesized ConstantFold) (AST.Expression λ l) = SynCFExp λ l
+type instance Atts (Synthesized ConstantFold) (AST.Element l l) = SynCF' (AST.Element l l)
+type instance Atts (Synthesized ConstantFold) (AST.Value l l) = SynCF' (AST.Value l l)
+type instance Atts (Synthesized ConstantFold) (AST.Designator l l) = SynCFDesignator l
+type instance Atts (Synthesized ConstantFold) (AST.Statement l l) = SynCF' (AST.Statement l l)
+type instance Atts (Synthesized ConstantFold) (AST.Case l l) = SynCF' (AST.Case l l)
+type instance Atts (Synthesized ConstantFold) (AST.CaseLabels l l) = SynCF' (AST.CaseLabels l l)
+type instance Atts (Synthesized ConstantFold) (AST.ConditionalBranch l l) = SynCF' (AST.ConditionalBranch l l)
+type instance Atts (Synthesized ConstantFold) (AST.WithAlternative l l) = SynCF' (AST.WithAlternative l l)
 
-type instance Atts (Inherited ConstantFold) (Modules l _ _) = InhCFRoot l
-type instance Atts (Inherited ConstantFold) (AST.Module λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Declaration λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.ProcedureHeading λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Block λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.FormalParameters λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.FPSection λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Type λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.FieldList λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.StatementSequence λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Expression λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Element λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Value l l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Designator λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Statement λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.Case λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.CaseLabels λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.ConditionalBranch λ l _ _) = InhCF l
-type instance Atts (Inherited ConstantFold) (AST.WithAlternative λ l _ _) = InhCF l
+type instance Atts (Inherited ConstantFold) (Modules l) = InhCFRoot l
+type instance Atts (Inherited ConstantFold) (AST.Module λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Declaration λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.ProcedureHeading λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Block λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.FormalParameters λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.FPSection λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Type λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.FieldList λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.StatementSequence λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Expression λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Element λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Value l l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Designator λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Statement λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.Case λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.CaseLabels λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.ConditionalBranch λ l) = InhCF l
+type instance Atts (Inherited ConstantFold) (AST.WithAlternative λ l) = InhCF l
 
 type SynCF' node = SynCF (node Placed Placed)
 type SynCFMod' l node = SynCFMod l (node Placed Placed)
@@ -180,19 +177,19 @@
 -- * Rules
 
 instance {-# overlaps #-} Ord (Abstract.QualIdent l) =>
-                          Synthesizer (Auto ConstantFold) (Modules l) Sem Placed where
+                          Synthesizer (Auto ConstantFold) (Modules l) where
    synthesis _ (_, Modules self) inheritance (Modules ms) =
       SynCFRoot{modulesFolded= (Modules (getMapped . foldedMod . syn <$> ms))}
 
 instance {-# overlaps #-} Ord (Abstract.QualIdent l) =>
-                          Bequether (Auto ConstantFold) (Modules l) Sem Placed where
+                          Bequether (Auto ConstantFold) (Modules l) where
    bequest _ (_, Modules self) inheritance (Modules ms) = Modules (Map.mapWithKey moduleInheritance self)
       where moduleInheritance name mod = Inherited InhCF{env= rootEnv inheritance <> foldMap (moduleEnv . syn) ms,
                                                          currentModule= name}
 
 instance {-# overlaps #-} (Abstract.Oberon l, Abstract.Nameable l, Ord (Abstract.QualIdent l), Show (Abstract.QualIdent l),
-                           Atts (Synthesized (Auto ConstantFold)) (Abstract.Block l l Sem Sem) ~ SynCFMod' l (Abstract.Block l l)) =>
-                          Synthesizer (Auto ConstantFold) (AST.Module l l) Sem Placed where
+                           Atts (Synthesized (Auto ConstantFold)) (Abstract.Block l l) ~ SynCFMod' l (Abstract.Block l l)) =>
+                          Synthesizer (Auto ConstantFold) (AST.Module l l) where
    synthesis _ (pos, AST.Module moduleName imports _body) inheritance (AST.Module _ _ body) =
       SynCFMod{moduleEnv= exportedEnv,
                folded= Mapped (pos, AST.Module moduleName imports $ getMapped $ foldedMod (syn body))}
@@ -203,24 +200,24 @@
                | otherwise = q
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Synthesized (Auto ConstantFold)) (Abstract.Declaration l l Sem Sem) ~ SynCFMod' l (Abstract.Declaration l l),
-          Atts (Inherited (Auto ConstantFold)) (Abstract.StatementSequence l l Sem Sem) ~ InhCF l,
-          Atts (Inherited (Auto ConstantFold)) (Abstract.Declaration l l Sem Sem) ~ InhCF l) =>
-         Bequether (Auto ConstantFold) (AST.Block l l) Sem Placed where
+          Atts (Synthesized (Auto ConstantFold)) (Abstract.Declaration l l) ~ SynCFMod' l (Abstract.Declaration l l),
+          Atts (Inherited (Auto ConstantFold)) (Abstract.StatementSequence l l) ~ InhCF l,
+          Atts (Inherited (Auto ConstantFold)) (Abstract.Declaration l l) ~ InhCF l) =>
+         Bequether (Auto ConstantFold) (AST.Block l l) where
    bequest _ (pos, AST.Block _decls _stats) inheritance (AST.Block decls stats) =
       AST.Block (pure $ Inherited localEnv) (pure $ Inherited localEnv)
       where newEnv = Map.unions (moduleEnv . syn <$> decls)
             localEnv = InhCF (newEnv `Map.union` env inheritance) (currentModule inheritance)
 
 instance (Abstract.Nameable l, k ~ Abstract.QualIdent l, v ~ Abstract.Value l l Placed Placed, Ord k,
-          Atts (Synthesized (Auto ConstantFold)) (Abstract.Declaration l l Sem Sem)
+          Atts (Synthesized (Auto ConstantFold)) (Abstract.Declaration l l)
           ~ SynCFMod' l (Abstract.Declaration l l)) =>
-         SynthesizedField "moduleEnv" (Map k (Maybe v)) (Auto ConstantFold) (AST.Block l l) Sem Placed where
+         SynthesizedField "moduleEnv" (Map k (Maybe v)) (Auto ConstantFold) (AST.Block l l) where
    synthesizedField _ _ (_, AST.Block{}) _ (AST.Block decls _stats) = Map.unions (moduleEnv . syn <$> decls)
 
 instance (Abstract.Nameable l, k ~ Abstract.QualIdent l, v ~ Abstract.Value l l Placed Placed, Ord k,
-          Atts (Synthesized (Auto ConstantFold)) (Abstract.ConstExpression l l Sem Sem) ~ SynCFExp l l) =>
-         SynthesizedField "moduleEnv" (Map k (Maybe v)) (Auto ConstantFold) (AST.Declaration l l) Sem Placed where
+          Atts (Synthesized (Auto ConstantFold)) (Abstract.ConstExpression l l) ~ SynCFExp l l) =>
+         SynthesizedField "moduleEnv" (Map k (Maybe v)) (Auto ConstantFold) (AST.Declaration l l) where
    synthesizedField _ _ (_, AST.ConstantDeclaration namedef _) _ (AST.ConstantDeclaration _ expression) =
       Map.singleton (Abstract.nonQualIdent $ Abstract.getIdentDefName namedef)
                     ((snd <$>) . foldedValue $ syn expression)
@@ -230,10 +227,10 @@
    (Abstract.Oberon λ, Abstract.Nameable l, Ord (Abstract.QualIdent l),
     Abstract.Value l ~ AST.Value l,
     Pretty (AST.Value l l Identity Identity),
-    Atts (Synthesized (Auto ConstantFold)) (Abstract.Expression l l Sem Sem) ~ SynCFExp l l,
-    Atts (Synthesized (Auto ConstantFold)) (Abstract.Element l l Sem Sem) ~ SynCF' (Abstract.Element l l),
-    Atts (Synthesized (Auto ConstantFold)) (Abstract.Designator l l Sem Sem) ~ SynCFDesignator l) =>
-   Synthesizer (Auto ConstantFold) (AST.Expression λ l) Sem Placed where
+    Atts (Synthesized (Auto ConstantFold)) (Abstract.Expression l l) ~ SynCFExp l l,
+    Atts (Synthesized (Auto ConstantFold)) (Abstract.Element l l) ~ SynCF' (Abstract.Element l l),
+    Atts (Synthesized (Auto ConstantFold)) (Abstract.Designator l l) ~ SynCFDesignator l) =>
+   Synthesizer (Auto ConstantFold) (AST.Expression λ l) where
    synthesis _ (pos@(start, ls, end), AST.Relation op _ _) _ (AST.Relation _op left right) =
       case join (compareValues <$> foldedValue (syn left) <*> foldedValue (syn right))
       of Just value -> literalSynthesis value
@@ -469,7 +466,7 @@
          foldValues _ _ = Nothing
 
 instance (Ord (Abstract.QualIdent l), v ~ Abstract.Value l l Placed Placed) =>
-         SynthesizedField "designatorValue" (Maybe (Placed v)) (Auto ConstantFold) (AST.Designator l l) Sem Placed where
+         SynthesizedField "designatorValue" (Maybe (Placed v)) (Auto ConstantFold) (AST.Designator l l) where
    synthesizedField _ _ (pos, AST.Variable q) inheritance _ = (,) pos <$> join (Map.lookup q $ env inheritance)
    synthesizedField _ _ _ _ _ = Nothing
 
diff --git a/src/Language/Oberon/Resolver.hs b/src/Language/Oberon/Resolver.hs
--- a/src/Language/Oberon/Resolver.hs
+++ b/src/Language/Oberon/Resolver.hs
@@ -17,6 +17,7 @@
 import Data.Either.Validation (Validation(..), validationToEither)
 import Data.Foldable (toList)
 import Data.Functor.Compose (Compose(..))
+import Data.Functor.Identity (Identity)
 import qualified Data.Kind as K (Type)
 import Data.List.NonEmpty (NonEmpty(..))
 import qualified Data.List.NonEmpty as NonEmpty
@@ -28,6 +29,7 @@
 import Language.Haskell.TH (appT, conT, varT, newName)
 
 import qualified Text.Parser.Input.Position as Position
+import qualified Rank2
 import qualified Rank2.TH
 import qualified Transformation
 import qualified Transformation.Deep as Deep
@@ -554,6 +556,14 @@
    of (_, [(ws, x)]) -> Success ((start, ws, end), x)
       (errors, []) -> Failure (inv (sconcat $ NonEmpty.fromList errors) :| [])
       (_, multi) -> Failure (amb (snd <$> multi) :| [])
+
+instance (Rank2.Functor (g Grammar.NodeWrap), Deep.Functor (Rank2.Map Grammar.NodeWrap NodeWrap) g) =>
+         Full.Functor (Rank2.Map Grammar.NodeWrap NodeWrap) g where
+  (<$>) = Full.mapUpDefault
+
+instance (Rank2.Functor (g Placed), Deep.Functor (Rank2.Map Placed Identity) g) =>
+         Full.Functor (Rank2.Map Placed Identity) g where
+  (<$>) = Full.mapUpDefault
 
 $(Rank2.TH.deriveFunctor ''DeclarationRHS)
 $(Rank2.TH.deriveFoldable ''DeclarationRHS)
diff --git a/src/Language/Oberon/TypeChecker.hs b/src/Language/Oberon/TypeChecker.hs
--- a/src/Language/Oberon/TypeChecker.hs
+++ b/src/Language/Oberon/TypeChecker.hs
@@ -152,8 +152,6 @@
 
 data TypeCheck = TypeCheck
 
-type Sem = Semantics (Auto TypeCheck)
-
 data InhTCRoot l = InhTCRoot{rootEnv :: Environment l}
 
 data InhTC l = InhTC{env :: Environment l}
@@ -228,66 +226,68 @@
    foldMap t ~(Modules ms) = getConst (foldMap (t Transformation.$) ms)
 
 instance Rank2.Functor (Modules l f') where
-   f <$> ~(Modules ms) = Modules (f <$> ms)
+   f <$> Modules ms = Modules (f <$> ms)
 instance Rank2.Foldable (Modules l f) where
-   foldMap f ~(Modules ms) = foldMap f ms
+   foldMap f (Modules ms) = foldMap f ms
+instance Rank2.Traversable (Modules l f) where
+   traverse f (Modules ms) = Modules <$> traverse f ms
 instance Rank2.Apply (Modules l f') where
    ~(Modules fs) <*> ~(Modules ms) = Modules (Map.intersectionWith Rank2.apply fs ms)
 
 -- * Boring attribute types
-type instance Atts (Inherited TypeCheck) (Modules l _ _) = InhTCRoot l
-type instance Atts (Synthesized TypeCheck) (Modules l _ _) = SynTCMods l
-type instance Atts (Inherited TypeCheck) (AST.Module l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Module l l _ _) = SynTCMod l
-type instance Atts (Inherited TypeCheck) (AST.Declaration l l _ _) = InhTCDecl l
-type instance Atts (Synthesized TypeCheck) (AST.Declaration l l _ _) = SynTCMod l
-type instance Atts (Inherited TypeCheck) (AST.ProcedureHeading l l _ _) = InhTCDecl l
-type instance Atts (Synthesized TypeCheck) (AST.ProcedureHeading l l _ _) = SynTCHead l
-type instance Atts (Inherited TypeCheck) (AST.Block l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Block l l _ _) = SynTCMod l
-type instance Atts (Inherited TypeCheck) (AST.FormalParameters l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.FormalParameters l l _ _) = SynTCSig l
-type instance Atts (Inherited TypeCheck) (AST.FPSection l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.FPSection l l _ _) = SynTCSec l
-type instance Atts (Inherited TypeCheck) (AST.Type l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Type l l _ _) = SynTCType l
-type instance Atts (Inherited TypeCheck) (AST.FieldList l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.FieldList l l _ _) = SynTCFields l
-type instance Atts (Inherited TypeCheck) (AST.StatementSequence l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.StatementSequence l l _ _) = SynTC l
-type instance Atts (Inherited TypeCheck) (AST.Expression l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Expression l l _ _) = SynTCExp l
-type instance Atts (Inherited TypeCheck) (AST.Element l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Element l l _ _) = SynTCExp l
-type instance Atts (Inherited TypeCheck) (AST.Value l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Value l l _ _) = SynTCExp l
-type instance Atts (Inherited TypeCheck) (AST.Designator l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Designator l l _ _) = SynTCDes l
-type instance Atts (Inherited TypeCheck) (AST.Statement l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.Statement l l _ _) = SynTC l
-type instance Atts (Inherited TypeCheck) (AST.ConditionalBranch l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.ConditionalBranch l l _ _) = SynTC l
-type instance Atts (Inherited TypeCheck) (AST.Case l l _ _) = InhTCExp l
-type instance Atts (Synthesized TypeCheck) (AST.Case l l _ _) = SynTC l
-type instance Atts (Inherited TypeCheck) (AST.CaseLabels l l _ _) = InhTCExp l
-type instance Atts (Synthesized TypeCheck) (AST.CaseLabels l l _ _) = SynTC l
-type instance Atts (Inherited TypeCheck) (AST.WithAlternative l l _ _) = InhTC l
-type instance Atts (Synthesized TypeCheck) (AST.WithAlternative l l _ _) = SynTC l
+type instance Atts (Inherited TypeCheck) (Modules l) = InhTCRoot l
+type instance Atts (Synthesized TypeCheck) (Modules l) = SynTCMods l
+type instance Atts (Inherited TypeCheck) (AST.Module l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Module l l) = SynTCMod l
+type instance Atts (Inherited TypeCheck) (AST.Declaration l l) = InhTCDecl l
+type instance Atts (Synthesized TypeCheck) (AST.Declaration l l) = SynTCMod l
+type instance Atts (Inherited TypeCheck) (AST.ProcedureHeading l l) = InhTCDecl l
+type instance Atts (Synthesized TypeCheck) (AST.ProcedureHeading l l) = SynTCHead l
+type instance Atts (Inherited TypeCheck) (AST.Block l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Block l l) = SynTCMod l
+type instance Atts (Inherited TypeCheck) (AST.FormalParameters l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.FormalParameters l l) = SynTCSig l
+type instance Atts (Inherited TypeCheck) (AST.FPSection l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.FPSection l l) = SynTCSec l
+type instance Atts (Inherited TypeCheck) (AST.Type l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Type l l) = SynTCType l
+type instance Atts (Inherited TypeCheck) (AST.FieldList l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.FieldList l l) = SynTCFields l
+type instance Atts (Inherited TypeCheck) (AST.StatementSequence l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.StatementSequence l l) = SynTC l
+type instance Atts (Inherited TypeCheck) (AST.Expression l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Expression l l) = SynTCExp l
+type instance Atts (Inherited TypeCheck) (AST.Element l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Element l l) = SynTCExp l
+type instance Atts (Inherited TypeCheck) (AST.Value l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Value l l) = SynTCExp l
+type instance Atts (Inherited TypeCheck) (AST.Designator l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Designator l l) = SynTCDes l
+type instance Atts (Inherited TypeCheck) (AST.Statement l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.Statement l l) = SynTC l
+type instance Atts (Inherited TypeCheck) (AST.ConditionalBranch l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.ConditionalBranch l l) = SynTC l
+type instance Atts (Inherited TypeCheck) (AST.Case l l) = InhTCExp l
+type instance Atts (Synthesized TypeCheck) (AST.Case l l) = SynTC l
+type instance Atts (Inherited TypeCheck) (AST.CaseLabels l l) = InhTCExp l
+type instance Atts (Synthesized TypeCheck) (AST.CaseLabels l l) = SynTC l
+type instance Atts (Inherited TypeCheck) (AST.WithAlternative l l) = InhTC l
+type instance Atts (Synthesized TypeCheck) (AST.WithAlternative l l) = SynTC l
 
 -- * Rules
 
-instance Ord (Abstract.QualIdent l) => Bequether (Auto TypeCheck) (Modules l) Sem Placed where
+instance Ord (Abstract.QualIdent l) => Bequether (Auto TypeCheck) (Modules l) where
    bequest _ (_, Modules self) inheritance (Modules ms) =
      Modules (Map.mapWithKey moduleInheritance self)
      where moduleInheritance name mod = Inherited InhTC{env= rootEnv inheritance <> foldMap (moduleEnv . syn) ms}
-instance Ord (Abstract.QualIdent l) => Synthesizer (Auto TypeCheck) (Modules l) Sem Placed where
+instance Ord (Abstract.QualIdent l) => Synthesizer (Auto TypeCheck) (Modules l) where
   synthesis _ _ _ (Modules ms) = SynTCMods{errors= Map.foldMapWithKey moduleErrors ms}
      where moduleErrors name (Synthesized SynTCMod{errors= Folded errs}) =
               Folded [Error name pos t | Error () pos t <- errs]
 
 instance (Abstract.Oberon l, Abstract.Nameable l, k ~ Abstract.QualIdent l, Ord k,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Block l l Sem Sem) ~ SynTCMod l) =>
-         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Module l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Block l l) ~ SynTCMod l) =>
+         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Module l l) where
    synthesizedField _ _ (pos, AST.Module moduleName imports body) _inheritance (AST.Module _ _ body') = exportedEnv
       where exportedEnv = exportNominal <$> Map.mapKeysMonotonic export (moduleEnv $ syn body')
             export q
@@ -309,13 +309,13 @@
             exportNominal' t = t
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.ProcedureHeading l l Sem Sem) ~ InhTCDecl l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Block l l Sem Sem) ~ InhTC l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.ProcedureHeading l l Sem Sem) ~ SynTCHead l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.FormalParameters l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.ConstExpression l l Sem Sem) ~ InhTC l) =>
-         Bequether (Auto TypeCheck) (AST.Declaration l l) Sem Placed where
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Type l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.ProcedureHeading l l) ~ InhTCDecl l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Block l l) ~ InhTC l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.ProcedureHeading l l) ~ SynTCHead l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.FormalParameters l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.ConstExpression l l) ~ InhTC l) =>
+         Bequether (Auto TypeCheck) (AST.Declaration l l) where
    bequest _ (pos, AST.ProcedureDeclaration{})
            inheritance@InhTCDecl{env= declEnv} (AST.ProcedureDeclaration heading _body) =
       AST.ProcedureDeclaration (Inherited inheritance) (Inherited bodyInherited)
@@ -323,12 +323,12 @@
    bequest t local inheritance synthesized = AG.bequestDefault t local inheritance synthesized
 
 instance (Abstract.Nameable l, k ~ Abstract.QualIdent l, Ord k,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l Sem Sem) ~ SynTCMod l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ SynTCType l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l Sem Sem) ~ SynTCSig l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.ProcedureHeading l l Sem Sem) ~ SynTCHead l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l Sem Sem) ~ SynTCExp l) =>
-         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Declaration l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l) ~ SynTCMod l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l) ~ SynTCType l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l) ~ SynTCSig l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.ProcedureHeading l l) ~ SynTCHead l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l) ~ SynTCExp l) =>
+         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Declaration l l) where
    synthesizedField _ _ (pos, AST.ConstantDeclaration namedef _) _ (AST.ConstantDeclaration _ expression) =
       Map.singleton (Abstract.nonQualIdent $ Abstract.getIdentDefName namedef) (inferredType $ syn expression)
    synthesizedField _ _ (pos, AST.TypeDeclaration namedef _) _ (AST.TypeDeclaration _ definition) =
@@ -350,17 +350,17 @@
       foldMap (Map.singleton (Abstract.nonQualIdent $ Abstract.getIdentDefName namedef) . signatureType . syn) sig
 
 instance (Abstract.Nameable l, k ~ Abstract.QualIdent l, Ord k,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ SynTCType l) =>
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l) ~ SynTCType l) =>
          SynthesizedField "pointerTargets" (Folded (Map AST.Ident AST.Ident)) (Auto TypeCheck)
-                                           (AST.Declaration l l) Sem Placed where
+                                           (AST.Declaration l l) where
    synthesizedField _ _ (pos, AST.TypeDeclaration namedef _) _ (AST.TypeDeclaration _ definition) =
       foldMap (Folded . Map.singleton name) (pointerTarget $ syn definition)
       where name = Abstract.getIdentDefName namedef
    synthesizedField _ _ _ _ _ = mempty
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l Sem Sem) ~ SynTCSig l) =>
-         Synthesizer (Auto TypeCheck) (AST.ProcedureHeading l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l) ~ SynTCSig l) =>
+         Synthesizer (Auto TypeCheck) (AST.ProcedureHeading l l) where
    synthesis _ (pos, AST.ProcedureHeading indirect namedef _sig) _inheritance (AST.ProcedureHeading _indirect _ sig) =
       SynTCHead{errors= foldMap ((.errors) . syn) sig,
                 outsideEnv= Map.singleton (Abstract.nonQualIdent name) $
@@ -390,10 +390,10 @@
                      | otherwise -> Folded [Error () pos (NonRecordType t)]
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l), Show (Abstract.QualIdent l),
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l Sem Sem) ~ SynTCMod l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Declaration l l Sem Sem) ~ InhTCDecl l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ InhTC l) =>
-         Bequether (Auto TypeCheck) (AST.Block l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l) ~ SynTCMod l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Declaration l l) ~ InhTCDecl l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ InhTC l) =>
+         Bequether (Auto TypeCheck) (AST.Block l l) where
    bequest _ (pos, AST.Block{}) inheritance@InhTC{env} (AST.Block declarations _statements) =
       AST.Block (pure $ Inherited InhTCDecl{env= localEnv,
                                             pointerTargets= getFolded pointers})
@@ -404,13 +404,13 @@
             pointers= foldMap (\Synthesized{syn= SynTCMod{pointerTargets= ptrs}}-> ptrs) declarations
 
 instance (Abstract.Nameable l, k ~ Abstract.QualIdent l, Ord k, Show k,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l Sem Sem) ~ SynTCMod l) =>
-         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Block l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l) ~ SynTCMod l) =>
+         SynthesizedField "moduleEnv" (Map k (Type l)) (Auto TypeCheck) (AST.Block l l) where
    synthesizedField _ _ (pos, AST.Block{}) _inheritance (AST.Block declarations _statements) = newEnv declarations
 
 newEnv :: (Abstract.Nameable l, Ord (Abstract.QualIdent l), Show (Abstract.QualIdent l),
-           Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l Sem Sem) ~ SynTCMod l) =>
-          ZipList (Synthesized (Auto TypeCheck) (Abstract.Declaration l l Sem Sem)) -> Environment l
+           Atts (Synthesized (Auto TypeCheck)) (Abstract.Declaration l l) ~ SynTCMod l) =>
+          ZipList (Synthesized (Auto TypeCheck) (Abstract.Declaration l l sem sem)) -> Environment l
 newEnv declarations = Map.unionsWith mergeTypeBoundProcedures (moduleEnv . syn <$> declarations)
    where mergeTypeBoundProcedures (NominalType q (Just t1)) t2
             | Abstract.getNonQualIdentName q == Just "" = mergeTypeBoundProcedures t1 t2
@@ -433,8 +433,8 @@
          mergeTypeBoundProcedures t1 t2 = error (take 90 $ show t1)
             
 instance (Ord (Abstract.QualIdent l),
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.FPSection l l Sem Sem) ~ SynTCSec l) =>
-         Synthesizer (Auto TypeCheck) (AST.FormalParameters l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.FPSection l l) ~ SynTCSec l) =>
+         Synthesizer (Auto TypeCheck) (AST.FormalParameters l l) where
    synthesis _ (pos, AST.FormalParameters sections returnType) InhTC{env}
              (AST.FormalParameters sections' _) =
       SynTCSig{errors= foldMap ((.errors) . syn) sections' <> foldMap typeRefErrors returnType,
@@ -446,19 +446,19 @@
                | otherwise = Folded [Error () pos (UnknownName q)]
 
 instance (Abstract.Wirthy l, Ord (Abstract.QualIdent l),
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ SynTCType l) =>
-         Synthesizer (Auto TypeCheck) (AST.FPSection l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l) ~ SynTCType l) =>
+         Synthesizer (Auto TypeCheck) (AST.FPSection l l) where
    synthesis _ (pos, AST.FPSection var names _typeDef) _inheritance (AST.FPSection _var _names typeDef) =
       SynTCSec{errors= (syn typeDef).errors,
                sectionParameters= (var, definedType (syn typeDef)) <$ names,
                sectionEnv= Map.fromList (flip (,) (definedType $ syn typeDef) . Abstract.nonQualIdent <$> names)}
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l Sem Sem) ~ SynTCSig l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.FieldList l l Sem Sem) ~ SynTCFields l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ SynTCType l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l Sem Sem) ~ SynTCExp l) =>
-         Synthesizer (Auto TypeCheck) (AST.Type l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.FormalParameters l l) ~ SynTCSig l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.FieldList l l) ~ SynTCFields l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l) ~ SynTCType l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l) ~ SynTCExp l) =>
+         Synthesizer (Auto TypeCheck) (AST.Type l l) where
    synthesis _ (pos, AST.TypeReference q) InhTC{env} _ = 
       SynTCType{errors= if Map.member q env then mempty else Folded [Error () pos (UnknownName q)],
                 typeName= Abstract.getNonQualIdentName q,
@@ -500,20 +500,20 @@
                 pointerTarget= Nothing,
                 definedType= maybe (ProcedureType False [] Nothing) (signatureType . syn) signature'}
 
-instance (Abstract.Nameable l, Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l Sem Sem) ~ SynTCType l) =>
-         SynthesizedField "fieldEnv" (Map AST.Ident (Type l)) (Auto TypeCheck) (AST.FieldList l l) Sem Placed where
+instance (Abstract.Nameable l, Atts (Synthesized (Auto TypeCheck)) (Abstract.Type l l) ~ SynTCType l) =>
+         SynthesizedField "fieldEnv" (Map AST.Ident (Type l)) (Auto TypeCheck) (AST.FieldList l l) where
    synthesizedField _ _ (_, AST.FieldList names _declaredType) _inheritance (AST.FieldList _names declaredType) =
       foldMap (\name-> Map.singleton (Abstract.getIdentDefName name) (definedType $ syn declaredType)) names
 
 instance (Abstract.Wirthy l, Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.ConditionalBranch l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Case l l Sem Sem) ~ InhTCExp l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.WithAlternative l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ InhTC l,
-          Atts (Inherited (Auto TypeCheck)) (Abstract.Designator l l Sem Sem) ~ InhTC l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l) =>
-         Bequether (Auto TypeCheck) (AST.Statement l l) Sem Placed where
+          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.ConditionalBranch l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Case l l) ~ InhTCExp l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.WithAlternative l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Expression l l) ~ InhTC l,
+          Atts (Inherited (Auto TypeCheck)) (Abstract.Designator l l) ~ InhTC l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l) =>
+         Bequether (Auto TypeCheck) (AST.Statement l l) where
    bequest _ (_pos, AST.CaseStatement{}) i@InhTC{env} (AST.CaseStatement value _branches _fallback) =
       AST.CaseStatement (Inherited i) (pure $ Inherited InhTCExp{env= env,
                                                                  expectedType= inferredType $ syn value})
@@ -523,13 +523,13 @@
                            expectedType= error "No statement except CASE needs expectedType"} statement
 
 instance {-# overlaps #-} (Abstract.Wirthy l, Abstract.Nameable l, Ord (Abstract.QualIdent l),
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ SynTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l Sem Sem) ~ SynTCDes l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Case l l Sem Sem) ~ SynTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.ConditionalBranch l l Sem Sem) ~ SynTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.WithAlternative l l Sem Sem) ~ SynTC l) =>
-                          Synthesizer (Auto TypeCheck) (AST.Statement l l) Sem Placed where
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ SynTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l) ~ SynTCDes l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Case l l) ~ SynTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.ConditionalBranch l l) ~ SynTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.WithAlternative l l) ~ SynTC l) =>
+                          Synthesizer (Auto TypeCheck) (AST.Statement l l) where
    synthesis t (pos, _) InhTC{} statement@(AST.Assignment var value) =
       {-# SCC "Assignment" #-}
       SynTC{errors= assignmentCompatible pos (designatorType $ syn var) (inferredType $ syn value)
@@ -564,9 +564,9 @@
    synthesis t self _ statement = SynTC{errors= AG.foldedField (Proxy :: Proxy "errors") t statement}
 
 instance (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ InhTC l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ SynTC l) =>
-         Attribution (Auto TypeCheck) (AST.WithAlternative l l) Sem Placed where
+          Atts (Inherited (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ InhTC l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ SynTC l) =>
+         AG.At (Auto TypeCheck) (AST.WithAlternative l l) where
    attribution _ (pos, AST.WithAlternative var subtype _body)
                (Inherited InhTC{env},
                 AST.WithAlternative _var _subtype body) =
@@ -579,15 +579,15 @@
        AST.WithAlternative var subtype (Inherited $ InhTC $ maybe id (Map.insert var) (Map.lookup subtype env) env))
 
 instance (Abstract.Nameable l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l,
-          Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l Sem Sem) ~ SynTC l) =>
-         Synthesizer (Auto TypeCheck) (AST.ConditionalBranch l l) Sem Placed where
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l,
+          Atts (Synthesized (Auto TypeCheck)) (Abstract.StatementSequence l l) ~ SynTC l) =>
+         Synthesizer (Auto TypeCheck) (AST.ConditionalBranch l l) where
    synthesis _ (pos, _) _inheritance (AST.ConditionalBranch condition body) =
       SynTC{errors= booleanExpressionErrors pos (syn condition) <> (syn body).errors}
 
 instance {-# overlaps #-} (Abstract.Nameable l, Eq (Abstract.QualIdent l),
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l Sem Sem) ~ SynTCExp l) =>
-                          Synthesizer (Auto TypeCheck) (AST.CaseLabels l l) Sem Placed where
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.ConstExpression l l) ~ SynTCExp l) =>
+                          Synthesizer (Auto TypeCheck) (AST.CaseLabels l l) where
    synthesis _ (pos, _) inheritance (AST.SingleLabel value) =
       SynTC{errors= assignmentCompatibleIn inheritance pos (inferredType $ syn value)}
    synthesis _ (pos, _) inheritance (AST.LabelRange start end) =
@@ -595,12 +595,12 @@
                     <> assignmentCompatibleIn inheritance pos (inferredType $ syn end)}
 
 instance {-# overlaps #-} (Abstract.Nameable l, Ord (Abstract.QualIdent l),
-                           Atts (Inherited (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ InhTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Element l l Sem Sem) ~ SynTCExp l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Value l l Sem Sem) ~ SynTCExp l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l Sem Sem) ~ SynTCDes l) =>
-                          Synthesizer (Auto TypeCheck) (AST.Expression l l) Sem Placed where
+                           Atts (Inherited (Auto TypeCheck)) (Abstract.Expression l l) ~ InhTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Element l l) ~ SynTCExp l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Value l l) ~ SynTCExp l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l) ~ SynTCDes l) =>
+                          Synthesizer (Auto TypeCheck) (AST.Expression l l) where
    synthesis _ (pos, AST.Relation op _ _) InhTC{} (AST.Relation _op left right) =
       SynTCExp{errors= case (syn left).errors <> (syn right).errors
                        of Folded []
@@ -707,7 +707,7 @@
       SynTCExp{errors= booleanExpressionErrors pos (syn expr),
                inferredType= BuiltinType "BOOLEAN"}
   
-instance Abstract.Wirthy l => SynthesizedField "inferredType" (Type l) (Auto TypeCheck) (AST.Value l l) Sem Placed where
+instance Abstract.Wirthy l => SynthesizedField "inferredType" (Type l) (Auto TypeCheck) (AST.Value l l) where
    synthesizedField _ _ (_, AST.Integer x) _ _  = IntegerType (fromIntegral x)
    synthesizedField _ _ (_, AST.Real x) _ _     = BuiltinType "REAL"
    synthesizedField _ _ (_, AST.Boolean x) _ _  = BuiltinType "BOOLEAN"
@@ -716,21 +716,21 @@
    synthesizedField _ _ (_, AST.Nil) _ _        = NilType
    synthesizedField _ _ (_, AST.Builtin x) _ _  = BuiltinType x
 
-instance (Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l) =>
-         SynthesizedField "errors" (Folded [Error () l]) (Auto TypeCheck) (AST.Element l l) Sem Placed where
+instance (Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l) =>
+         SynthesizedField "errors" (Folded [Error () l]) (Auto TypeCheck) (AST.Element l l) where
    synthesizedField _ _ (pos, _) _inheritance (AST.Element expr) = integerExpressionErrors pos (syn expr)
    synthesizedField _ _ (pos, _) _inheritance (AST.Range low high) = integerExpressionErrors pos (syn high)
                                                                      <> integerExpressionErrors pos (syn low)
 
-instance SynthesizedField "inferredType" (Type l) (Auto TypeCheck) (AST.Element l l) Sem Placed where
+instance SynthesizedField "inferredType" (Type l) (Auto TypeCheck) (AST.Element l l) where
    synthesizedField _ _ _ _ _ = BuiltinType "SET"
 
 instance {-# overlaps #-} (Abstract.Nameable l, Abstract.Oberon l, Ord (Abstract.QualIdent l),
                            Show (Abstract.QualIdent l),
-                           Atts (Inherited (Auto TypeCheck)) (Abstract.Designator l l Sem Sem) ~ InhTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l Sem Sem) ~ SynTCExp l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l Sem Sem) ~ SynTCDes l) =>
-                          Synthesizer (Auto TypeCheck) (AST.Designator l l) Sem Placed where
+                           Atts (Inherited (Auto TypeCheck)) (Abstract.Designator l l) ~ InhTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Expression l l) ~ SynTCExp l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Designator l l) ~ SynTCDes l) =>
+                          Synthesizer (Auto TypeCheck) (AST.Designator l l) where
    synthesis _ (pos, AST.Variable q) InhTC{env} _ =
       SynTCDes{errors= case designatorType
                        of Nothing -> Folded [Error () pos (UnknownName q)]
@@ -958,15 +958,9 @@
 t1 `targetExtends` t2 | t1 == t2 = True
 t1 `targetExtends` t2 = False
 
-instance Transformation.Transformation (Auto TypeCheck) where
-   type Domain (Auto TypeCheck) = Placed
-   type Codomain (Auto TypeCheck) = Semantics (Auto TypeCheck)
-
-instance AG.Revelation (Auto TypeCheck) where
-   reveal (Auto TypeCheck) = snd
-
-instance Ord (Abstract.QualIdent l) => Transformation.At (Auto TypeCheck) (Modules l Sem Sem) where
-   ($) = AG.applyDefault snd
+instance Attribution TypeCheck where
+   type Origin TypeCheck = Placed
+   unwrap TypeCheck = snd
 
 -- * Unsafe Rank2 AST instances
 
@@ -978,14 +972,14 @@
 -- 'Map' keyed by module name. The first argument's value is typically 'predefined' or 'predefined2'.
 checkModules :: forall l. (Abstract.Oberon l, Abstract.Nameable l,
                            Ord (Abstract.QualIdent l), Show (Abstract.QualIdent l),
-                           Atts (Inherited (Auto TypeCheck)) (Abstract.Block l l Sem Sem) ~ InhTC l,
-                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Block l l Sem Sem) ~ SynTCMod l,
-                           Full.Functor (Auto TypeCheck) (Abstract.Block l l))
+                           Atts (Inherited (Auto TypeCheck)) (Abstract.Block l l) ~ InhTC l,
+                           Atts (Synthesized (Auto TypeCheck)) (Abstract.Block l l) ~ SynTCMod l,
+                           Full.Functor (AG.Knit (Auto TypeCheck)) (Abstract.Block l l))
              => Environment l -> Map AST.Ident (Placed (AST.Module l l Placed Placed)) -> [Error AST.Ident l]
 checkModules predef modules =
-   getFolded ((syn (Transformation.apply (Auto TypeCheck) (wrap $ Auto TypeCheck Deep.<$> Modules modules)
-                           `Rank2.apply`
-                           Inherited (InhTCRoot predef))).errors)
+   getFolded ((syn ((AG.Knit (Auto TypeCheck) Full.<$> wrap (Modules modules))
+                    `Rank2.apply`
+                    Inherited (InhTCRoot predef))).errors)
    where wrap = (,) (0, Trailing [], 0)
 
 predefined, predefined2 :: (Abstract.Wirthy l, Ord (Abstract.QualIdent l)) => Environment l