+       ; (fun_out, uds_fun)   <- specExpr env fun_in

+       ; let uds_app  = uds_fun `thenUDs` uds_args

+             env_args = zapSubst env `bringFloatedDictsIntoScope` ud_binds uds_app

+                -- zapSubst: we have now fully applied the substitution

+                -- bringFloatedDictsIntoScope: some dicts may have floated out of

+                -- args_in; they should be in scope for fireRewriteRules (#21689)

+

+       -- Try firing rewrite rules

+       -- See Note [Fire rules in the specialiser]

+       ; let (fun_out', args_out') = fireRewriteRules env_args fun_out args_out

+

+       -- Make a call record, and return

+       ; return (fun_out' `mkApps` args_out', uds_app `thenUDs` uds_call) }

+fireRewriteRules :: SpecEnv   -- Substitution is already zapped

+                 -> OutExpr -> [OutExpr] -> (OutExpr, [OutExpr])

+        zapped_subst = se_subst env   -- Just needed for the InScopeSet

+        expr'        = simpleOptExprWith defaultSimpleOpts zapped_subst (mkApps expr rest_args)

+  = fireRewriteRules env fun' args'

+           -- Check for (a) usefulness and (b) not already covered

+           -- See (SC1) in Note [Specialisations already covered]

+           ; let all_rules = rules_acc ++ existing_rules

+                 -- all_rules: we look both in the rules_acc (generated by this invocation

+                 --   of specCalls), and in existing_rules (passed in to specCalls)

+                 already_covered = alreadyCovered env' all_rule_bndrs fn

+                                                  rule_lhs_args is_active all_rules

+

+{-         ; pprTrace "spec_call" (vcat

+                , text "useful:    "  <+> ppr useful

+                , text "already_covered:"  <+> ppr already_covered

+                , text "rhs_body"     <+> ppr rhs_body

+                , text "subst''" <+> ppr subst'' ]) $

+           ; if not useful          -- No useful specialisation

+                || already_covered  -- Useful, but done already

+{-         ; pprTrace "spec_call2" (vcat

+                 [ text "fun:" <+> ppr fn

+                 , text "rhs_body':" <+> ppr rhs_body' ]) $

+             return ()

+-}

+

+The easiest solution was to unify the multiplicities in tc_sub_type_deep,

+insisting on equality. This is only in the DeepSubsumption code anyway.

+           ; mkWpFun_FRR unify pos

+-- | Like 'mkWpFun', except that it performs the necessary

+-- representation-polymorphism checks on the argument type in the case that

+-- we introduce a lambda abstraction.

+  :: (TcType -> TcType -> TcM TcCoercionN) -- ^ how to unify

+  -> Position p

+mkWpFun_FRR unify pos act_af act_mult act_arg act_res exp_af exp_mult exp_arg exp_res arg_wrap res_wrap

+  = do { ((exp_arg_co, exp_arg_frr), (act_arg_co, _act_arg_frr)) <-

+            if needs_frr_checks

+              -- See Wrinkle [Representation-polymorphism checking during subtyping]

+            then do { exp_frr_wrap <- hasFixedRuntimeRep (frr_ctxt True ) exp_arg

+                    ; act_frr_wrap <- hasFixedRuntimeRep (frr_ctxt False) act_arg

+                    ; return (exp_frr_wrap, act_frr_wrap) }

+            else return ((mkNomReflCo exp_arg, exp_arg), (mkNomReflCo act_arg, act_arg))

+

+         -- Enforce equality of multiplicities (not the more natural sub-multiplicity).

+         -- See Note [Multiplicity in deep subsumption]

+       ; act_arg_mult_co <- unify act_mult exp_mult

+           -- NB: don't use tcEqMult: that would require the evidence for

+           -- equality to be Refl, but it might well not be (#26332).

+

+                 act_arg_mult_co

+            mkWpFun arg_wrap_frr res_wrap (Scaled exp_mult exp_arg_frr) exp_res

+            mkWpCastN act_arg_fun_co

+       }

+    needs_frr_checks :: Bool

+    needs_frr_checks =

+    frr_ctxt :: Bool -> FixedRuntimeRepContext

+    frr_ctxt is_exp_ty =

+      FRRDeepSubsumption

+        { frrDSExpected = is_exp_ty

+        , frrDSPosition = pos

+        }

+{-# LANGUAGE DeepSubsumption #-}

+{-# LANGUAGE LinearTypes #-}

+

+module T26332 where

+

+import Unsafe.Coerce

+

+toLinear

+  :: forall a b p q.

+     (a %p-> b) %1-> (a %q-> b)

+toLinear f = case unsafeEqualityProof @p @q of

+  UnsafeRefl -> f

+test('T26332', normal, compile, ['-O -dlinear-core-lint'])

+module M where

+

+import GHC.Exts      ( Any )

+import Unsafe.Coerce ( unsafeCoerce )

+

+data Sigma = MkT Any

+

+testSubList :: Maybe Bool -> Sigma -> Sigma

+testSubList (Just x) final = {-# SCC "y" #-} (

+   let x' = seq x ()

+   in case testSubList Nothing final of

+         MkT w -> {-# SCC "x" #-}

+                    (unsafeCoerce MkT (konst x' myHead (unsafeCoerce w))))

+testSubList Nothing final = final

+

+myHead :: [a] -> a

+myHead (x:_) = x

+

+konst :: () -> ([a] -> a) -> [a] -> a

+konst _ x = x

+{-# OPAQUE konst #-}

+test('T26056', [test_opts], compile, ['-O -prof'])

+// Prints the state of the signal handlers to stdout.

+// NOTE: We intentionally start at signal 1 (not 0). Signal number 0 is not a

+// real signal; passing 0 to sigismember/sigaction is undefined behaviour and

+// on Darwin was observed to yield memory corruption / junk bytes in output.

+int main(void)

+    for(i = 1; i < NSIG; ++i)

+    for(i = 1; i < NSIG; ++i)