Note [Type and coercion lets]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 and similarly for coercions.

    TODO: fill this out

 (TCL1) In a type let (Let @a = TYPE ty in body), we do /not/ insist that

   the binder `a` has a TyVarUnfolding.  But if it does not, then `body`

        let @a = TYPE ty in body

   where `a` has no TyVarUnfolding, is well-typed iff

        (/\a. body) ty

   (which is always substituted) with the tyvar-replete-with-unfolding, rather

   than merely extending the in-scope set as we do for Ids.

 So: (TCL1) + (TCL2) =

   EITHER `a` has an unfolding at its binding site,

      and that unfolding is replicated at every occurrence site

   OR it doesn't and the occurrences don't either.

 Note [Core top-level string literals]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 As an exception to the usual rule that top-level binders must be lifted,

   for this purpose -- it contains only TyCoVars.  Instead we have a separate

   le_ids for the in-scope Id binders.

 Note [Bad unsafe coercion]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~

 For discussion see https://gitlab.haskell.org/ghc/ghc/wikis/bad-unsafe-coercions

 lintLetExpr tvs (Let (NonRec tv (Type rhs_ty)) body)

   | isTyVar tv

   =     -- See Note [Linting type lets]

   where

 lintLetExpr tvs (Let (NonRec bndr rhs) body)

   | isId bndr

        , lf_check_linearity :: Bool    -- ^ See Note [Linting linearity]

        , lf_check_fixed_rep :: Bool    -- ^ See Note [Checking for representation polymorphism]

        , lf_check_rubbish_lits :: Bool -- ^ See Note [Checking for rubbish literals]

     }

 -- See Note [Checking StaticPtrs]

 getLintFlags = LintM $ \ env errs -> fromBoxedLResult (Just (le_flags env), errs)

 updLintFlags :: (LintFlags -> LintFlags) -> LintM a -> LintM a

 checkL :: Bool -> SDoc -> LintM ()

 checkL True  _   = return ()

                  Just unf_ty -> setTyVarUnfolding tcv2 (substTy subst unf_ty)

                  Nothing     -> tcv2

 getInVarEnv :: LintM (VarEnv (InId, OutVar))

 getInVarEnv = LintM (\env errs -> fromBoxedLResult (Just (le_in_vars env), errs))

 sameUnfolding :: InVar   -- Binder

               -> InVar    -- Occurrence

               -> LintM Bool

 -- An unfolding in the occurrence is optional for Ids, but compulsory for type-let-boud

 -- TyVars.  Somewhat lazily, we only check the latter.

 -- We also just compare them as InTypes (as we do the type of the variable);

   = go emptyVarSet [] bndrs

   where

     wrap_bind :: Expr b -> (b,Expr b) -> Expr b

     go :: TyVarSet     -- Earlier TyVar bndrs that have TyVarUnfoldings

        -> [(b,Expr b)] -- Accumulated impedence-matching bindings (reversed)

        -> CoreArg -> UniqSM (Floats, CpeArg)

 cpeArg env dmd arg

   = do { (floats1, arg1) <- cpeRhsE env arg     -- arg1 can be a lambda

              lev    = typeLevity arg_ty

              dec    = wantFloatLocal NonRecursive dmd lev floats1 arg1

        ; (floats2, arg2) <- executeFloatDecision env dec floats1 arg1

                , lf_check_inline_loop_breakers = check_lbs

                , lf_check_static_ptrs          = check_static_ptrs

                , lf_check_linearity            = check_linearity

   where

     -- See Note [Checking for global Ids]

     check_globals = case pass of

                       CorePrep -> True

                       _        -> False

 initLintConfig :: DynFlags -> [Var] -> LintConfig

 initLintConfig dflags vars =LintConfig

   { l_diagOpts = initDiagOpts dflags

                              , lf_report_unsat_syns = True

                              , lf_check_fixed_rep = True

                              , lf_check_rubbish_lits = True

                              }

 wrapBinds ((new,old):prs) e = wrapBind new old (wrapBinds prs e)

 wrapBind :: Var -> Var -> CoreExpr -> CoreExpr

 wrapBind new old body   -- NB: this function must deal with term

   | new==old    = body  -- variables, type variables or coercion variables

   | otherwise   = Let (NonRec new (varToCoreExpr old)) body