Introduce IsPass; refactor wrappers.

There are two main payloads of this patch:

1. This introduces IsPass, which allows e.g. printing
   code to ask what pass it is running in (Renamed vs
   Typechecked) and thus print extension fields. See
   Note [IsPass] in Hs.Extension

2. This moves the HsWrap constructor into an extension
   field, where it rightly belongs. This is done for
   HsExpr and HsCmd, but not for HsPat, which is left
   as an exercise for the reader.

There is also some refactoring around SyntaxExprs, but this
is really just incidental.

This patch subsumes !1721 (sorry @chreekat).

Along the way, there is a bit of refactoring in GHC.Hs.Extension,
including the removal of NameOrRdrName in favor of NoGhcTc.
This meant that we had no real need for GHC.Hs.PlaceHolder, so
I got rid of it.

Updates haddock submodule.

-------------------------
Metric Decrease:
    haddock.compiler
-------------------------

1 files changed, 140 insertions, 547 deletions

diff --git a/compiler/GHC/Hs/Extension.hs b/compiler/GHC/Hs/Extension.hs
index be0333933a..ee82e4a0f9 100644
--- a/compiler/GHC/Hs/Extension.hs
+++ b/compiler/GHC/Hs/Extension.hs
@@ -11,8 +11,14 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
-                                      -- in module GHC.Hs.PlaceHolder
+{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
+                                      -- in module GHC.Hs.Extension
+{-# LANGUAGE UndecidableSuperClasses #-}  -- for IsPass; see Note [NoGhcTc]
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}      -- for pprIfTc, etc.
 
 module GHC.Hs.Extension where
 
@@ -22,7 +28,6 @@ module GHC.Hs.Extension where
 import GhcPrelude
 
 import Data.Data hiding ( Fixity )
-import GHC.Hs.PlaceHolder
 import Name
 import RdrName
 import Var
@@ -54,6 +59,74 @@ additional information for the tool, in a natural way.
 A further goal is to provide a means to harmonise the Template Haskell and
 haskell-src-exts ASTs as well.
 
+Wrinkle: In order to print out the AST, we need to know it is Outputable.
+We also sometimes need to branch on the particular pass that we're in
+(e.g. to print out type information once we know it). In order to allow
+both of these actions, we define OutputableBndrId, which gathers the necessary
+OutputableBndr and IsPass constraints. The use of this constraint in instances
+generally requires UndecidableInstances.
+
+See also Note [IsPass] and Note [NoGhcTc].
+
+Note [IsPass]
+~~~~~~~~~~~~~
+One challenge with the Trees That Grow approach
+is that we sometimes have different information in different passes.
+For example, we have
+
+  type instance XViaStrategy GhcPs = LHsSigType GhcPs
+  type instance XViaStrategy GhcRn = LHsSigType GhcRn
+  type instance XViaStrategy GhcTc = Type
+
+This means that printing a DerivStrategy (which contains an XViaStrategy)
+might need to print a LHsSigType, or it might need to print a type. Yet we
+want one Outputable instance for a DerivStrategy, instead of one per pass. We
+could have a large constraint, including e.g. (Outputable (XViaStrategy p),
+Outputable (XViaStrategy GhcTc)), and pass that around in every context where
+we might output a DerivStrategy. But a simpler alternative is to pass a
+witness to whichever pass we're in. When we pattern-match on that (GADT)
+witness, we learn the pass identity and can then print away. To wit, we get
+the definition of GhcPass and the functions isPass. These allow us to do away
+with big constraints, passing around all manner of dictionaries we might or
+might not use. It does mean that we have to manually use isPass when printing,
+but these places are few.
+
+See Note [NoGhcTc] about the superclass constraint to IsPass.
+
+Note [NoGhcTc]
+~~~~~~~~~~~~~~
+An expression is parsed into HsExpr GhcPs, renamed into HsExpr GhcRn, and
+then type-checked into HsExpr GhcTc. Not so for types! These get parsed
+into HsType GhcPs, renamed into HsType GhcRn, and then type-checked into
+Type. We never build an HsType GhcTc. Why do this? Because we need to be
+able to compare type-checked types for equality, and we don't want to do
+this with HsType.
+
+This causes wrinkles within the AST, where we normally thing that the whole
+AST travels through the GhcPs --> GhcRn --> GhcTc pipeline as one. So we
+have the NoGhcTc type family, which just replaces GhcTc with GhcRn, so that
+user-written types can be preserved (as HsType GhcRn) even in e.g. HsExpr GhcTc.
+
+For example, this is used in ExprWithTySig:
+    | ExprWithTySig
+                (XExprWithTySig p)
+
+                (LHsExpr p)
+                (LHsSigWcType (NoGhcTc p))
+
+If we have (e :: ty), we still want to be able to print that (with the :: ty)
+after type-checking. So we retain the LHsSigWcType GhcRn, even in an
+HsExpr GhcTc. That's what NoGhcTc does.
+
+When we're printing the type annotation, we need to know
+(Outputable (LHsSigWcType GhcRn)), even though we've assumed only that
+(OutputableBndrId GhcTc). We thus must be able to prove OutputableBndrId (NoGhcTc p)
+from OutputableBndrId p. The extra constraints in OutputableBndrId and
+the superclass constraints of IsPass allow this. Note that the superclass
+constraint of IsPass is *recursive*: it asserts that IsPass (NoGhcTcPass p) holds.
+For this to make sense, we need -XUndecidableSuperClasses and the other constraint,
+saying that NoGhcTcPass is idempotent.
+
 -}
 
 -- | A placeholder type for TTG extension points that are not currently
@@ -93,6 +166,12 @@ instance Outputable NoExtCon where
 noExtCon :: NoExtCon -> a
 noExtCon x = case x of {}
 
+-- | GHC's L prefixed variants wrap their vanilla variant in this type family,
+-- to add 'SrcLoc' info via 'Located'. Other passes than 'GhcPass' not
+-- interested in location information can define this instance as @f p@.
+type family XRec p (f :: * -> *) = r | r -> p f
+type instance XRec (GhcPass p) f = Located (f (GhcPass p))
+
 {-
 Note [NoExtCon and strict fields]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -130,10 +209,19 @@ the strict field changes described above and delete gobs of code involving
 code that consumes unused extension constructors.
 -}
 
--- | Used as a data type index for the hsSyn AST
-data GhcPass (c :: Pass)
-deriving instance Eq (GhcPass c)
-deriving instance Typeable c => Data (GhcPass c)
+-- | Used as a data type index for the hsSyn AST; also serves
+-- as a singleton type for Pass
+data GhcPass (c :: Pass) where
+  GhcPs :: GhcPs
+  GhcRn :: GhcRn
+  GhcTc :: GhcTc
+
+-- This really should never be entered, but the data-deriving machinery
+-- needs the instance to exist.
+instance Typeable p => Data (GhcPass p) where
+  gunfold _ _ _ = panic "instance Data GhcPass"
+  toConstr  _   = panic "instance Data GhcPass"
+  dataTypeOf _  = panic "instance Data GhcPass"
 
 data Pass = Parsed | Renamed | Typechecked
          deriving (Data)
@@ -144,23 +232,43 @@ type GhcRn   = GhcPass 'Renamed     -- Old 'Name' type param
 type GhcTc   = GhcPass 'Typechecked -- Old 'Id' type para,
 type GhcTcId = GhcTc                -- Old 'TcId' type param
 
--- | GHC's L prefixed variants wrap their vanilla variant in this type family,
--- to add 'SrcLoc' info via 'Located'. Other passes than 'GhcPass' not
--- interested in location information can define this instance as @f p@.
-type family XRec p (f :: * -> *) = r | r -> p f
-type instance XRec (GhcPass p) f = Located (f (GhcPass p))
+-- | Allows us to check what phase we're in at GHC's runtime.
+-- For example, this class allows us to write
+-- >  f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah
+-- >  f e = case ghcPass @p of
+-- >          GhcPs ->    ... in this RHS we have HsExpr GhcPs...
+-- >          GhcRn ->    ... in this RHS we have HsExpr GhcRn...
+-- >          GhcTc ->    ... in this RHS we have HsExpr GhcTc...
+-- which is very useful, for example, when pretty-printing.
+-- See Note [IsPass].
+class ( NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p
+      , IsPass (NoGhcTcPass p)
+      ) => IsPass p where
+  ghcPass :: GhcPass p
+
+instance IsPass 'Parsed where
+  ghcPass = GhcPs
+instance IsPass 'Renamed where
+  ghcPass = GhcRn
+instance IsPass 'Typechecked where
+  ghcPass = GhcTc
 
 -- | Maps the "normal" id type for a given pass
 type family IdP p
-type instance IdP GhcPs = RdrName
-type instance IdP GhcRn = Name
-type instance IdP GhcTc = Id
+type instance IdP (GhcPass p) = IdGhcP p
+
+-- | Maps the "normal" id type for a given GHC pass
+type family IdGhcP pass where
+  IdGhcP 'Parsed      = RdrName
+  IdGhcP 'Renamed     = Name
+  IdGhcP 'Typechecked = Id
 
 type LIdP p = Located (IdP p)
 
 -- | Marks that a field uses the GhcRn variant even when the pass
 -- parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because
 -- HsType GhcTc should never occur.
+-- See Note [NoGhcTc]
 type family NoGhcTc (p :: Type) where
     -- this way, GHC can figure out that the result is a GhcPass
   NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)
@@ -179,23 +287,10 @@ type family XHsIPBinds       x x'
 type family XEmptyLocalBinds x x'
 type family XXHsLocalBindsLR x x'
 
-type ForallXHsLocalBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =
-       ( c (XHsValBinds      x x')
-       , c (XHsIPBinds       x x')
-       , c (XEmptyLocalBinds x x')
-       , c (XXHsLocalBindsLR x x')
-       )
-
 -- ValBindsLR type families
 type family XValBinds    x x'
 type family XXValBindsLR x x'
 
-type ForallXValBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =
-       ( c (XValBinds    x x')
-       , c (XXValBindsLR x x')
-       )
-
-
 -- HsBindsLR type families
 type family XFunBind    x x'
 type family XPatBind    x x'
@@ -204,51 +299,22 @@ type family XAbsBinds   x x'
 type family XPatSynBind x x'
 type family XXHsBindsLR x x'
 
-type ForallXHsBindsLR (c :: * -> Constraint) (x :: *) (x' :: *) =
-       ( c (XFunBind    x x')
-       , c (XPatBind    x x')
-       , c (XVarBind    x x')
-       , c (XAbsBinds   x x')
-       , c (XPatSynBind x x')
-       , c (XXHsBindsLR x x')
-       )
-
 -- ABExport type families
 type family XABE x
 type family XXABExport x
 
-type ForallXABExport (c :: * -> Constraint) (x :: *) =
-       ( c (XABE       x)
-       , c (XXABExport x)
-       )
-
 -- PatSynBind type families
 type family XPSB x x'
 type family XXPatSynBind x x'
 
-type ForallXPatSynBind  (c :: * -> Constraint) (x :: *) (x' :: *) =
-       ( c (XPSB         x x')
-       , c (XXPatSynBind x x')
-       )
-
 -- HsIPBinds type families
 type family XIPBinds    x
 type family XXHsIPBinds x
 
-type ForallXHsIPBinds (c :: * -> Constraint) (x :: *) =
-       ( c (XIPBinds    x)
-       , c (XXHsIPBinds x)
-       )
-
 -- IPBind type families
 type family XCIPBind x
 type family XXIPBind x
 
-type ForallXIPBind (c :: * -> Constraint) (x :: *) =
-       ( c (XCIPBind x)
-       , c (XXIPBind x)
-       )
-
 -- Sig type families
 type family XTypeSig          x
 type family XPatSynSig        x
@@ -263,30 +329,10 @@ type family XSCCFunSig        x
 type family XCompleteMatchSig x
 type family XXSig             x
 
-type ForallXSig (c :: * -> Constraint) (x :: *) =
-       ( c (XTypeSig          x)
-       , c (XPatSynSig        x)
-       , c (XClassOpSig       x)
-       , c (XIdSig            x)
-       , c (XFixSig           x)
-       , c (XInlineSig        x)
-       , c (XSpecSig          x)
-       , c (XSpecInstSig      x)
-       , c (XMinimalSig       x)
-       , c (XSCCFunSig        x)
-       , c (XCompleteMatchSig x)
-       , c (XXSig             x)
-       )
-
 -- FixitySig type families
 type family XFixitySig          x
 type family XXFixitySig         x
 
-type ForallXFixitySig (c :: * -> Constraint) (x :: *) =
-       ( c (XFixitySig         x)
-       , c (XXFixitySig        x)
-       )
-
 -- StandaloneKindSig type families
 type family XStandaloneKindSig  x
 type family XXStandaloneKindSig x
@@ -311,44 +357,16 @@ type family XDocD        x
 type family XRoleAnnotD  x
 type family XXHsDecl     x
 
-type ForallXHsDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XTyClD       x)
-       , c (XInstD       x)
-       , c (XDerivD      x)
-       , c (XValD        x)
-       , c (XSigD        x)
-       , c (XKindSigD    x)
-       , c (XDefD        x)
-       , c (XForD        x)
-       , c (XWarningD    x)
-       , c (XAnnD        x)
-       , c (XRuleD       x)
-       , c (XSpliceD     x)
-       , c (XDocD        x)
-       , c (XRoleAnnotD  x)
-       , c (XXHsDecl    x)
-       )
-
 -- -------------------------------------
 -- HsGroup type families
 type family XCHsGroup      x
 type family XXHsGroup      x
 
-type ForallXHsGroup (c :: * -> Constraint) (x :: *) =
-       ( c (XCHsGroup       x)
-       , c (XXHsGroup       x)
-       )
-
 -- -------------------------------------
 -- SpliceDecl type families
 type family XSpliceDecl       x
 type family XXSpliceDecl      x
 
-type ForallXSpliceDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XSpliceDecl        x)
-       , c (XXSpliceDecl       x)
-       )
-
 -- -------------------------------------
 -- TyClDecl type families
 type family XFamDecl       x
@@ -357,24 +375,11 @@ type family XDataDecl      x
 type family XClassDecl     x
 type family XXTyClDecl     x
 
-type ForallXTyClDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XFamDecl       x)
-       , c (XSynDecl       x)
-       , c (XDataDecl      x)
-       , c (XClassDecl     x)
-       , c (XXTyClDecl     x)
-       )
-
 -- -------------------------------------
 -- TyClGroup type families
 type family XCTyClGroup      x
 type family XXTyClGroup      x
 
-type ForallXTyClGroup (c :: * -> Constraint) (x :: *) =
-       ( c (XCTyClGroup       x)
-       , c (XXTyClGroup       x)
-       )
-
 -- -------------------------------------
 -- FamilyResultSig type families
 type family XNoSig            x
@@ -382,75 +387,37 @@ type family XCKindSig         x -- Clashes with XKindSig above
 type family XTyVarSig         x
 type family XXFamilyResultSig x
 
-type ForallXFamilyResultSig (c :: * -> Constraint) (x :: *) =
-       ( c (XNoSig            x)
-       , c (XCKindSig         x)
-       , c (XTyVarSig         x)
-       , c (XXFamilyResultSig x)
-       )
-
 -- -------------------------------------
 -- FamilyDecl type families
 type family XCFamilyDecl      x
 type family XXFamilyDecl      x
 
-type ForallXFamilyDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCFamilyDecl       x)
-       , c (XXFamilyDecl       x)
-       )
-
 -- -------------------------------------
 -- HsDataDefn type families
 type family XCHsDataDefn      x
 type family XXHsDataDefn      x
 
-type ForallXHsDataDefn (c :: * -> Constraint) (x :: *) =
-       ( c (XCHsDataDefn       x)
-       , c (XXHsDataDefn       x)
-       )
-
 -- -------------------------------------
 -- HsDerivingClause type families
 type family XCHsDerivingClause      x
 type family XXHsDerivingClause      x
 
-type ForallXHsDerivingClause (c :: * -> Constraint) (x :: *) =
-       ( c (XCHsDerivingClause       x)
-       , c (XXHsDerivingClause       x)
-       )
-
 -- -------------------------------------
 -- ConDecl type families
 type family XConDeclGADT   x
 type family XConDeclH98    x
 type family XXConDecl      x
 
-type ForallXConDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XConDeclGADT    x)
-       , c (XConDeclH98     x)
-       , c (XXConDecl       x)
-       )
-
 -- -------------------------------------
 -- FamEqn type families
 type family XCFamEqn      x r
 type family XXFamEqn      x r
 
-type ForallXFamEqn (c :: * -> Constraint) (x :: *) (r :: *) =
-       ( c (XCFamEqn       x r)
-       , c (XXFamEqn       x r)
-       )
-
 -- -------------------------------------
 -- ClsInstDecl type families
 type family XCClsInstDecl      x
 type family XXClsInstDecl      x
 
-type ForallXClsInstDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCClsInstDecl       x)
-       , c (XXClsInstDecl       x)
-       )
-
 -- -------------------------------------
 -- ClsInstDecl type families
 type family XClsInstD      x
@@ -458,23 +425,11 @@ type family XDataFamInstD  x
 type family XTyFamInstD    x
 type family XXInstDecl     x
 
-type ForallXInstDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XClsInstD       x)
-       , c (XDataFamInstD   x)
-       , c (XTyFamInstD     x)
-       , c (XXInstDecl      x)
-       )
-
 -- -------------------------------------
 -- DerivDecl type families
 type family XCDerivDecl      x
 type family XXDerivDecl      x
 
-type ForallXDerivDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCDerivDecl       x)
-       , c (XXDerivDecl       x)
-       )
-
 -- -------------------------------------
 -- DerivStrategy type family
 type family XViaStrategy x
@@ -484,96 +439,48 @@ type family XViaStrategy x
 type family XCDefaultDecl      x
 type family XXDefaultDecl      x
 
-type ForallXDefaultDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCDefaultDecl       x)
-       , c (XXDefaultDecl       x)
-       )
-
 -- -------------------------------------
 -- DefaultDecl type families
 type family XForeignImport     x
 type family XForeignExport     x
 type family XXForeignDecl      x
 
-type ForallXForeignDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XForeignImport      x)
-       , c (XForeignExport      x)
-       , c (XXForeignDecl       x)
-       )
-
 -- -------------------------------------
 -- RuleDecls type families
 type family XCRuleDecls      x
 type family XXRuleDecls      x
 
-type ForallXRuleDecls (c :: * -> Constraint) (x :: *) =
-       ( c (XCRuleDecls       x)
-       , c (XXRuleDecls       x)
-       )
-
-
 -- -------------------------------------
 -- RuleDecl type families
 type family XHsRule          x
 type family XXRuleDecl       x
 
-type ForallXRuleDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XHsRule           x)
-       , c (XXRuleDecl        x)
-       )
-
 -- -------------------------------------
 -- RuleBndr type families
 type family XCRuleBndr      x
 type family XRuleBndrSig    x
 type family XXRuleBndr      x
 
-type ForallXRuleBndr (c :: * -> Constraint) (x :: *) =
-       ( c (XCRuleBndr       x)
-       , c (XRuleBndrSig     x)
-       , c (XXRuleBndr       x)
-       )
-
 -- -------------------------------------
 -- WarnDecls type families
 type family XWarnings        x
 type family XXWarnDecls      x
 
-type ForallXWarnDecls (c :: * -> Constraint) (x :: *) =
-       ( c (XWarnings        x)
-       , c (XXWarnDecls      x)
-       )
-
 -- -------------------------------------
 -- AnnDecl type families
 type family XWarning        x
 type family XXWarnDecl      x
 
-type ForallXWarnDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XWarning        x)
-       , c (XXWarnDecl      x)
-       )
-
 -- -------------------------------------
 -- AnnDecl type families
 type family XHsAnnotation  x
 type family XXAnnDecl      x
 
-type ForallXAnnDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XHsAnnotation  x)
-       , c (XXAnnDecl      x)
-       )
-
 -- -------------------------------------
 -- RoleAnnotDecl type families
 type family XCRoleAnnotDecl  x
 type family XXRoleAnnotDecl  x
 
-type ForallXRoleAnnotDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCRoleAnnotDecl  x)
-       , c (XXRoleAnnotDecl  x)
-       )
-
 -- =====================================================================
 -- Type families for the HsExpr extension points
 
@@ -622,75 +529,18 @@ type family XSCC            x
 type family XCoreAnn        x
 type family XTickPragma     x
 type family XXPragE         x
-
-type ForallXExpr (c :: * -> Constraint) (x :: *) =
-       ( c (XVar            x)
-       , c (XUnboundVar     x)
-       , c (XConLikeOut     x)
-       , c (XRecFld         x)
-       , c (XOverLabel      x)
-       , c (XIPVar          x)
-       , c (XOverLitE       x)
-       , c (XLitE           x)
-       , c (XLam            x)
-       , c (XLamCase        x)
-       , c (XApp            x)
-       , c (XAppTypeE       x)
-       , c (XOpApp          x)
-       , c (XNegApp         x)
-       , c (XPar            x)
-       , c (XSectionL       x)
-       , c (XSectionR       x)
-       , c (XExplicitTuple  x)
-       , c (XExplicitSum    x)
-       , c (XCase           x)
-       , c (XIf             x)
-       , c (XMultiIf        x)
-       , c (XLet            x)
-       , c (XDo             x)
-       , c (XExplicitList   x)
-       , c (XRecordCon      x)
-       , c (XRecordUpd      x)
-       , c (XExprWithTySig  x)
-       , c (XArithSeq       x)
-       , c (XSCC            x)
-       , c (XCoreAnn        x)
-       , c (XBracket        x)
-       , c (XRnBracketOut   x)
-       , c (XTcBracketOut   x)
-       , c (XSpliceE        x)
-       , c (XProc           x)
-       , c (XStatic         x)
-       , c (XTick           x)
-       , c (XBinTick        x)
-       , c (XTickPragma     x)
-       , c (XWrap           x)
-       , c (XXExpr          x)
-       )
 -- ---------------------------------------------------------------------
 
 type family XUnambiguous        x
 type family XAmbiguous          x
 type family XXAmbiguousFieldOcc x
 
-type ForallXAmbiguousFieldOcc (c :: * -> Constraint) (x :: *) =
-       ( c (XUnambiguous        x)
-       , c (XAmbiguous          x)
-       , c (XXAmbiguousFieldOcc x)
-       )
-
 -- ----------------------------------------------------------------------
 
 type family XPresent  x
 type family XMissing  x
 type family XXTupArg  x
 
-type ForallXTupArg (c :: * -> Constraint) (x :: *) =
-       ( c (XPresent x)
-       , c (XMissing x)
-       , c (XXTupArg x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XTypedSplice   x
@@ -699,14 +549,6 @@ type family XQuasiQuote    x
 type family XSpliced       x
 type family XXSplice       x
 
-type ForallXSplice (c :: * -> Constraint) (x :: *) =
-       ( c (XTypedSplice   x)
-       , c (XUntypedSplice x)
-       , c (XQuasiQuote    x)
-       , c (XSpliced       x)
-       , c (XXSplice       x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XExpBr      x
@@ -718,67 +560,31 @@ type family XVarBr      x
 type family XTExpBr     x
 type family XXBracket   x
 
-type ForallXBracket (c :: * -> Constraint) (x :: *) =
-       ( c (XExpBr      x)
-       , c (XPatBr      x)
-       , c (XDecBrL     x)
-       , c (XDecBrG     x)
-       , c (XTypBr      x)
-       , c (XVarBr      x)
-       , c (XTExpBr     x)
-       , c (XXBracket   x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XCmdTop  x
 type family XXCmdTop x
 
-type ForallXCmdTop (c :: * -> Constraint) (x :: *) =
-       ( c (XCmdTop  x)
-       , c (XXCmdTop x)
-       )
-
 -- -------------------------------------
 
 type family XMG           x b
 type family XXMatchGroup  x b
 
-type ForallXMatchGroup (c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XMG          x b)
-       , c (XXMatchGroup x b)
-       )
-
 -- -------------------------------------
 
 type family XCMatch  x b
 type family XXMatch  x b
 
-type ForallXMatch (c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XCMatch  x b)
-       , c (XXMatch  x b)
-       )
-
 -- -------------------------------------
 
 type family XCGRHSs  x b
 type family XXGRHSs  x b
 
-type ForallXGRHSs (c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XCGRHSs  x b)
-       , c (XXGRHSs  x b)
-       )
-
 -- -------------------------------------
 
 type family XCGRHS  x b
 type family XXGRHS  x b
 
-type ForallXGRHS (c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XCGRHS  x b)
-       , c (XXGRHS  x b)
-       )
-
 -- -------------------------------------
 
 type family XLastStmt        x x' b
@@ -791,18 +597,6 @@ type family XTransStmt       x x' b
 type family XRecStmt         x x' b
 type family XXStmtLR         x x' b
 
-type ForallXStmtLR (c :: * -> Constraint) (x :: *)  (x' :: *) (b :: *) =
-       ( c (XLastStmt         x x' b)
-       , c (XBindStmt         x x' b)
-       , c (XApplicativeStmt  x x' b)
-       , c (XBodyStmt         x x' b)
-       , c (XLetStmt          x x' b)
-       , c (XParStmt          x x' b)
-       , c (XTransStmt        x x' b)
-       , c (XRecStmt          x x' b)
-       , c (XXStmtLR          x x' b)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XCmdArrApp  x
@@ -817,42 +611,17 @@ type family XCmdDo      x
 type family XCmdWrap    x
 type family XXCmd       x
 
-type ForallXCmd (c :: * -> Constraint) (x :: *) =
-       ( c (XCmdArrApp  x)
-       , c (XCmdArrForm x)
-       , c (XCmdApp     x)
-       , c (XCmdLam     x)
-       , c (XCmdPar     x)
-       , c (XCmdCase    x)
-       , c (XCmdIf      x)
-       , c (XCmdLet     x)
-       , c (XCmdDo      x)
-       , c (XCmdWrap    x)
-       , c (XXCmd       x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XParStmtBlock  x x'
 type family XXParStmtBlock x x'
 
-type ForallXParStmtBlock (c :: * -> Constraint) (x :: *) (x' :: *) =
-       ( c (XParStmtBlock  x x')
-       , c (XXParStmtBlock x x')
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XApplicativeArgOne   x
 type family XApplicativeArgMany  x
 type family XXApplicativeArg     x
 
-type ForallXApplicativeArg (c :: * -> Constraint) (x :: *) =
-       ( c (XApplicativeArgOne   x)
-       , c (XApplicativeArgMany  x)
-       , c (XXApplicativeArg     x)
-       )
-
 -- =====================================================================
 -- Type families for the HsImpExp extension points
 
@@ -878,33 +647,9 @@ type family XHsFloatPrim x
 type family XHsDoublePrim x
 type family XXLit x
 
--- | Helper to apply a constraint to all extension points. It has one
--- entry per extension point type family.
-type ForallXHsLit (c :: * -> Constraint) (x :: *) =
-  ( c (XHsChar       x)
-  , c (XHsCharPrim   x)
-  , c (XHsDoublePrim x)
-  , c (XHsFloatPrim  x)
-  , c (XHsInt        x)
-  , c (XHsInt64Prim  x)
-  , c (XHsIntPrim    x)
-  , c (XHsInteger    x)
-  , c (XHsRat        x)
-  , c (XHsString     x)
-  , c (XHsStringPrim x)
-  , c (XHsWord64Prim x)
-  , c (XHsWordPrim   x)
-  , c (XXLit         x)
-  )
-
 type family XOverLit  x
 type family XXOverLit x
 
-type ForallXOverLit (c :: * -> Constraint) (x :: *) =
-       ( c (XOverLit  x)
-       , c (XXOverLit x)
-       )
-
 -- =====================================================================
 -- Type families for the HsPat extension points
 
@@ -927,58 +672,22 @@ type family XSigPat    x
 type family XCoPat     x
 type family XXPat      x
 
-
-type ForallXPat (c :: * -> Constraint) (x :: *) =
-       ( c (XWildPat   x)
-       , c (XVarPat    x)
-       , c (XLazyPat   x)
-       , c (XAsPat     x)
-       , c (XParPat    x)
-       , c (XBangPat   x)
-       , c (XListPat   x)
-       , c (XTuplePat  x)
-       , c (XSumPat    x)
-       , c (XViewPat   x)
-       , c (XSplicePat x)
-       , c (XLitPat    x)
-       , c (XNPat      x)
-       , c (XNPlusKPat x)
-       , c (XSigPat    x)
-       , c (XCoPat     x)
-       , c (XXPat      x)
-       )
-
 -- =====================================================================
 -- Type families for the HsTypes type families
 
 type family XHsQTvs       x
 type family XXLHsQTyVars  x
 
-type ForallXLHsQTyVars (c :: * -> Constraint) (x :: *) =
-       ( c (XHsQTvs       x)
-       , c (XXLHsQTyVars  x)
-       )
-
 -- -------------------------------------
 
 type family XHsIB              x b
 type family XXHsImplicitBndrs  x b
 
-type ForallXHsImplicitBndrs (c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XHsIB              x b)
-       , c (XXHsImplicitBndrs  x b)
-       )
-
 -- -------------------------------------
 
 type family XHsWC              x b
 type family XXHsWildCardBndrs  x b
 
-type ForallXHsWildCardBndrs(c :: * -> Constraint) (x :: *) (b :: *) =
-       ( c (XHsWC              x b)
-       , c (XXHsWildCardBndrs  x b)
-       )
-
 -- -------------------------------------
 
 type family XForAllTy        x
@@ -1005,78 +714,28 @@ type family XTyLit           x
 type family XWildCardTy      x
 type family XXType           x
 
--- | Helper to apply a constraint to all extension points. It has one
--- entry per extension point type family.
-type ForallXType (c :: * -> Constraint) (x :: *) =
-       ( c (XForAllTy        x)
-       , c (XQualTy          x)
-       , c (XTyVar           x)
-       , c (XAppTy           x)
-       , c (XAppKindTy       x)
-       , c (XFunTy           x)
-       , c (XListTy          x)
-       , c (XTupleTy         x)
-       , c (XSumTy           x)
-       , c (XOpTy            x)
-       , c (XParTy           x)
-       , c (XIParamTy        x)
-       , c (XStarTy          x)
-       , c (XKindSig         x)
-       , c (XSpliceTy        x)
-       , c (XDocTy           x)
-       , c (XBangTy          x)
-       , c (XRecTy           x)
-       , c (XExplicitListTy  x)
-       , c (XExplicitTupleTy x)
-       , c (XTyLit           x)
-       , c (XWildCardTy      x)
-       , c (XXType           x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XUserTyVar   x
 type family XKindedTyVar x
 type family XXTyVarBndr  x
 
-type ForallXTyVarBndr (c :: * -> Constraint) (x :: *) =
-       ( c (XUserTyVar      x)
-       , c (XKindedTyVar    x)
-       , c (XXTyVarBndr     x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XConDeclField  x
 type family XXConDeclField x
 
-type ForallXConDeclField (c :: * -> Constraint) (x :: *) =
-       ( c (XConDeclField  x)
-       , c (XXConDeclField x)
-       )
-
 -- ---------------------------------------------------------------------
 
 type family XCFieldOcc x
 type family XXFieldOcc x
 
-type ForallXFieldOcc (c :: * -> Constraint) (x :: *) =
-       ( c (XCFieldOcc x)
-       , c (XXFieldOcc x)
-       )
-
-
 -- =====================================================================
 -- Type families for the HsImpExp type families
 
 type family XCImportDecl       x
 type family XXImportDecl       x
 
-type ForallXImportDecl (c :: * -> Constraint) (x :: *) =
-       ( c (XCImportDecl x)
-       , c (XXImportDecl x)
-       )
-
 -- -------------------------------------
 
 type family XIEVar             x
@@ -1089,18 +748,6 @@ type family XIEDoc             x
 type family XIEDocNamed        x
 type family XXIE               x
 
-type ForallXIE (c :: * -> Constraint) (x :: *) =
-       ( c (XIEVar x)
-       , c (XIEThingAbs        x)
-       , c (XIEThingAll        x)
-       , c (XIEThingWith       x)
-       , c (XIEModuleContents  x)
-       , c (XIEGroup           x)
-       , c (XIEDoc             x)
-       , c (XIEDocNamed        x)
-       , c (XXIE               x)
-       )
-
 -- -------------------------------------
 
 
@@ -1108,77 +755,23 @@ type ForallXIE (c :: * -> Constraint) (x :: *) =
 -- End of Type family definitions
 -- =====================================================================
 
--- ----------------------------------------------------------------------
--- | Conversion of annotations from one type index to another. This is required
--- where the AST is converted from one pass to another, and the extension values
--- need to be brought along if possible. So for example a 'SourceText' is
--- converted via 'id', but needs a type signature to keep the type checker
--- happy.
-class Convertable a b  | a -> b where
-  convert :: a -> b
-
-instance Convertable a a where
-  convert = id
-
--- | A constraint capturing all the extension points that can be converted via
--- @instance Convertable a a@
-type ConvertIdX a b =
-  (XHsDoublePrim a ~ XHsDoublePrim b,
-   XHsFloatPrim a ~ XHsFloatPrim b,
-   XHsRat a ~ XHsRat b,
-   XHsInteger a ~ XHsInteger b,
-   XHsWord64Prim a ~ XHsWord64Prim b,
-   XHsInt64Prim a ~ XHsInt64Prim b,
-   XHsWordPrim a ~ XHsWordPrim b,
-   XHsIntPrim a ~ XHsIntPrim b,
-   XHsInt a ~ XHsInt b,
-   XHsStringPrim a ~ XHsStringPrim b,
-   XHsString a ~ XHsString b,
-   XHsCharPrim a ~ XHsCharPrim b,
-   XHsChar a ~ XHsChar b,
-   XXLit a ~ XXLit b)
-
--- ----------------------------------------------------------------------
-
--- Note [OutputableX]
--- ~~~~~~~~~~~~~~~~~~
---
--- is required because the type family resolution
--- process cannot determine that all cases are handled for a `GhcPass p`
--- case where the cases are listed separately.
---
--- So
---
---   type instance XXHsIPBinds    (GhcPass p) = NoExtCon
---
--- will correctly deduce Outputable for (GhcPass p), but
---
---   type instance XIPBinds       GhcPs = NoExt
---   type instance XIPBinds       GhcRn = NoExt
---   type instance XIPBinds       GhcTc = TcEvBinds
---
--- will not.
-
-
--- | Provide a summary constraint that gives all am Outputable constraint to
--- extension points needing one
-type OutputableX p = -- See Note [OutputableX]
-  ( Outputable (XIPBinds    p)
-  , Outputable (XViaStrategy p)
-  , Outputable (XViaStrategy GhcRn)
-  )
--- TODO: Should OutputableX be included in OutputableBndrId?
-
--- ----------------------------------------------------------------------
-
 -- |Constraint type to bundle up the requirement for 'OutputableBndr' on both
--- the @p@ and the 'NameOrRdrName' type for it
+-- the @id@ and the 'NoGhcTc' of it. See Note [NoGhcTc].
 type OutputableBndrId pass =
-  ( OutputableBndr (NameOrRdrName (IdP (GhcPass pass)))
-  , OutputableBndr (IdP (GhcPass pass))
-  , OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass))))
-  , OutputableBndr (IdP (NoGhcTc (GhcPass pass)))
-  , NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass))
-  , OutputableX (GhcPass pass)
-  , OutputableX (NoGhcTc (GhcPass pass))
+  ( OutputableBndr (IdGhcP pass)
+  , OutputableBndr (IdGhcP (NoGhcTcPass pass))
+  , IsPass pass
   )
+
+-- useful helper functions:
+pprIfPs :: forall p. IsPass p => (p ~ 'Parsed => SDoc) -> SDoc
+pprIfPs pp = case ghcPass @p of GhcPs -> pp
+                                _     -> empty
+
+pprIfRn :: forall p. IsPass p => (p ~ 'Renamed => SDoc) -> SDoc
+pprIfRn pp = case ghcPass @p of GhcRn -> pp
+                                _     -> empty
+
+pprIfTc :: forall p. IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc
+pprIfTc pp = case ghcPass @p of GhcTc -> pp
+                                _     -> empty