-- Easiest thing is to do it all at once, as if all the top-level

               -- decls were mutually recursive

        ; let top_env = SE { se_subst = Core.mkEmptySubst $

                           , se_module = this_mod

                           , se_rules  = rule_env

                           , se_dflags = dflags }

                       , [CoreBind] ) -- Specialised bindings

 spec_imports env callers dict_binds calls

   = do { let import_calls = dVarEnvElts calls

        ; (env, rules, spec_binds) <- go env import_calls

        ; return (env, rules, spec_binds) }

   where

     go :: SpecEnv -> [CallInfoSet] -> CoreM (SpecEnv, [CoreRule], [CoreBind])

     go env [] = return (env, [], [])

     go env (cis : other_calls)

       = do {

            ; (env, rules1, spec_binds1) <- spec_import env callers dict_binds cis

            ; (env, rules2, spec_binds2) <- go env other_calls

            ; return (env, rules1 ++ rules2, spec_binds1 ++ spec_binds2) }

                      , [CoreBind] )  -- Specialised bindings

 spec_import env callers dict_binds cis@(CIS fn _)

   | isIn "specImport" fn callers

        ; return (env, [], []) }

     -- No warning.  This actually happens all the time

     -- when specialising a recursive function, because

     -- call to the original function

   | null good_calls

        ; return (env, [], []) }

   | Just rhs <- canSpecImport dflags fn

        ; eps_rules <- getExternalRuleBase

        ; let rule_env = se_rules env `updExternalPackageRules` eps_rules

        ; (rules1, spec_pairs, MkUD { ud_binds = dict_binds1, ud_calls = new_calls })

             <- runSpecM $ specCalls True env (getRules rule_env fn) good_calls fn rhs

                          `bringFloatedDictsIntoScope` dict_binds1

        -- Now specialise any cascaded calls

        ; (env, rules2, spec_binds2)

             <- spec_imports new_env (fn:callers)

   | otherwise

   = do {

        ; tryWarnMissingSpecs dflags callers fn good_calls

        ; return (env, [], [])}