gHC_PRIM, gHC_PRIM_PANIC,

     gHC_TYPES, gHC_INTERNAL_DATA_DATA, gHC_MAGIC, gHC_MAGIC_DICT,

 gHC_PRIM           = mkGhcInternalModule (fsLit "GHC.Internal.Prim")   -- Primitive types and values

 gHC_PRIM_PANIC     = mkGhcInternalModule (fsLit "GHC.Internal.Prim.Panic")

 gHC_TYPES          = mkGhcInternalModule (fsLit "GHC.Internal.Types")

 gHC_MAGIC_DICT     = mkGhcInternalModule (fsLit "GHC.Internal.Magic.Dict")

 gHC_CSTRING        = mkGhcInternalModule (fsLit "GHC.Internal.CString")

 gHC_CLASSES        = mkGhcInternalModule (fsLit "GHC.Internal.Classes")

 gHC_PRIMOPWRAPPERS = mkGhcInternalModule (fsLit "GHC.Internal.PrimopWrappers")

 gHC_INTERNAL_TUPLE = mkGhcInternalModule (fsLit "GHC.Internal.Tuple")

 -- Implicit Parameters

 ipClassName :: Name

 ipClassName

 -- Overloaded record fields

 hasFieldClassName :: Name

         (if null rhs

             then []

             else [text "hidden reexport by" <+>

         (if f then [text "package flag"] else [])

         ))

     else

         Build-Depends: unix   >= 2.7 && < 2.9

     GHC-Options: -Wall

                  -Wno-name-shadowing

                  -Wnoncanonical-monad-instances

 - The extension :extension:`ExplicitNamespaces` now allows namespace-specified

   wildcards ``type ..`` and ``data ..`` in import and export lists.

 Compiler

 ~~~~~~~~

     copyFile, copyFileUntracked, createFileLink, fixFile,

     makeExecutable, moveFile, removeFile, createDirectory, copyDirectory,

     moveDirectory, removeDirectory, removeFile_, writeFileChangedBS,

     -- * Diagnostic info

     Colour (..), ANSIColour (..), putColoured, shouldUseColor,

     ponyPadding = "                                            "

     boxLines :: [String]

     boxLines = ["", "", ""] ++ (lines . renderBox $ ls)

   ( docspecRules

   ) where

 import Base

 import Context.Path

 import Settings.Builders.Common

 import Base

 import Settings.Builders.Common

 import System.Exit (exitFailure)

 lintRules :: Rules ()

     stage <- getStage

     hie_path <- getHieBuildPath

     mconcat [ arg "-Wall"

             , not useColor ? builder (Ghc CompileHs) ?

               -- N.B. Target.trackArgument ignores this argument from the

               -- input hash to avoid superfluous recompilation, avoiding

 import qualified Data.Set    as Set

 import Flavour

 import qualified Context.Type as C

 import Settings.Program

 import qualified Context.Type

         GHC.Internal.CString

         GHC.Internal.Classes

         GHC.Internal.Debug

         GHC.Internal.Magic

         GHC.Internal.Magic.Dict

 {-# LANGUAGE Trustworthy #-}

 {-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns,

              KindSignatures, DataKinds, ConstraintKinds,

 {-# LANGUAGE UndecidableSuperClasses #-}

   -- Because of the type-variable superclasses for tuples

 import GHC.Internal.Tuple

 import GHC.Internal.CString (unpackCString#)

 import GHC.Internal.Types

 infix  4  ==, /=, <, <=, >=, >

 infixr 3  &&

 default ()              -- Double isn't available yet

 {- $matching_overloaded_methods_in_rules

 Matching on class methods (e.g. @(==)@) in rewrite rules tends to be a bit

 import Text.Printf

 import System.Environment (getProgName, getArgs)

 import System.Exit

 type MessageHook = Msg -> IO Msg

 trace :: String -> IO ()

 serv :: Bool -> MessageHook -> Pipe -> (forall a .IO a -> IO a) -> IO ()

 serv verbose hook pipe restore = loop

 #define HP_CHK_P(bytes, fun, arg)               \

    HEAP_CHECK(bytes, GC_PRIM_P(fun,arg))

 // Load a field out of structure with relaxed ordering.

 #define RELAXED_LOAD_FIELD(fld, ptr) \

     REP_##fld![(ptr) + OFFSET_##fld]

   TICK_BUMP_BY(ALLOC_THK_gds,g);\

   TICK_BUMP_BY(ALLOC_THK_slp,s);\

   TICK_BUMP(ALLOC_RTS_ctr);\

   TICK_BUMP_BY(ALLOC_RTS_tot,n);

 #endif

 void

 accountAllocation(Capability *cap, W_ n)

 {

     CCS_ALLOC(cap->r.rCCCS,n);

     if (cap->r.rCurrentTSO != NULL) {

         // cap->r.rCurrentTSO->alloc_limit -= n*sizeof(W_)

 import asyncio

 from testglobals import getConfig, ghc_env, TestConfig, t, \

                         TestOptions, brokens, PerfMetric

 from my_typing import TestName

     for line in pkginfo.split('\n'):

         if line.startswith('library-dirs:'):

             path = line.rstrip()

             # Use string.replace instead of re.sub, because re.sub

             # interprets backslashes in the replacement string as

             # escape sequences.

 from testutil import strip_quotes, lndir, link_or_copy_file, passed, \

                      failBecause, testing_metrics, residency_testing_metrics, \

                      stable_perf_counters, \

 from term_color import Color, colored

 import testutil

 from cpu_features import have_cpu_feature

     if opts.expect not in ['pass', 'fail', 'missing-lib']:

         framework_fail(name, way, 'bad expected ' + opts.expect)

     if way in opts.fragile_ways:

         if_verbose(1, '*** fragile test %s resulted in %s' % (full_name, 'pass' if result.passed else 'fail'))

 # if found and instead have the testsuite decide on what to do

 # with the output.

 def override_options(pre_cmd):

         return pre_cmd.replace(' -s'     , '') \

                       .replace('--silent', '') \

                       .replace('--quiet' , '')

     # so we need to take care not to blow up with the wrong way

     # and report the actual reason for the failure.

     try:

     except:

       directory = ''

     full_name = '%s(%s)' % (name, way)

 def framework_warn(name: TestName, way: WayName, reason: str) -> None:

     opts = getTestOpts()

     full_name = name + '(' + way + ')'

     if_verbose(1, '*** framework warning for %s %s ' % (full_name, reason))

     t.framework_warnings.append(TestResult(directory, name, reason, way))

         with out1_fn.open('w', encoding='utf8', newline='') as out1:

             with out2_fn.open('w', encoding='utf8', newline='') as out2:

                 line = infile.readline()

                     out1.write(line)

                     line = infile.readline()

 tyCon_re = re.compile(r'TyCon\s*\d+\#\#\d?\d?\s*\d+\#\#\d?\d?\s*', flags=re.MULTILINE)

 def normalise_type_reps(s: str) -> str:

     """ Normalise out fingerprints from Typeable TyCon representations """

     return re.sub(tyCon_re, 'TyCon FINGERPRINT FINGERPRINT ', s)

         s = s.replace('ld: 0706-027 The -x flag is ignored.\n', '')

     # remove " error:" and lower-case " Warning:" to make patch for

     # trac issue #10021 smaller

     s = normalise_callstacks(s)

     s = normalise_type_reps(s)

     #   a target prefix (e.g. `aarch64-linux-gnu-ghc`)

     # * On Windows the executable name may mention the

     #   versioned name (e.g. `ghc-9.2.1`)

     # If somefile ends in ".exe" or ".exe:", zap ".exe" (for Windows)

     #    the colon is there because it appears in error messages; this

     s = re.sub(r'([^\s])\.jsexe', r'\1', s)

     # hpc executable is given ghc suffix

     # The inplace ghc's are called ghc-stage[123] to avoid filename

     # collisions, so we need to normalise that to just "ghc"

     # Remove platform prefix (e.g. javascript-unknown-ghcjs) for cross-compiled tools

     # (ghc, ghc-pkg, unlit, etc.)

     s = re.sub(r'\w+(-\w+)*-ghc', 'ghc', s)

     # Also filter out bullet characters.  This is because bullets are used to

     # separate error sections, and tests shouldn't be sensitive to how the

     # the division happens.

     s = s.replace(bullet, '')

     # Windows only, this is a bug in hsc2hs but it is preventing

     s = modify_lines(s, lambda l: re.sub(r'^(.+)warning: (.+): unsupported GNU_PROPERTY_TYPE (?:\(5\) )?type: 0xc000000(.*)$', '', l))

     s = re.sub(r'ld: warning: passed .* min versions \(.*\) for platform macOS. Using [\.0-9]+.','',s)

     # ignore superfluous dylibs passed to the linker.

     # ignore LLVM Version mismatch garbage; this will just break tests.

     # ignore warning about strip invalidating signatures

     # clang may warn about unused argument when used as assembler

     # Emscripten displays cache info and old emcc doesn't support EMCC_LOGGING=0

     # Old emcc warns when we export HEAP8 but new one requires it (see #26290)

     s = s.replace('warning: invalid item in EXPORTED_RUNTIME_METHODS: HEAP8\nwarning: invalid item in EXPORTED_RUNTIME_METHODS: HEAPU8\nemcc: warning: warnings in JS library compilation [-Wjs-compiler]\n','')

     # The next step assumes none of the fields have no spaces in, which is broke

     # when the src = <no location info>

     # Source locations from internal libraries, remove the source location

     # > libraries/ghc-internal/src/path/Foo.hs:204:1-18

     return s

 def normalise_slashes_( s: str ) -> str:

     return s

 def normalise_exe_( s: str ) -> str:

     return s

 def normalise_output( s: str ) -> str:

     # remove " error:" and lower-case " Warning:" to make patch for

     # trac issue #10021 smaller

     # Remove a .exe extension (for Windows)

     # and .wasm extension (for the Wasm backend)

     # and .jsexe extension (for the JS backend)

     s = normalise_type_reps(s)

     # ghci outputs are pretty unstable with -fexternal-dynamic-refs, which is

     # requires for -fPIC

     s = re.sub(r'ld: warning: passed .* min versions \(.*\) for platform macOS. Using [\.0-9]+.','',s)

     # ignore superfluous dylibs passed to the linker.

     # ignore LLVM Version mismatch garbage; this will just break tests.

     # ignore warning about strip invalidating signatures

     # clang may warn about unused argument when used as assembler

     # strip the cross prefix if any

     s = re.sub(r'\w+(-\w+)*-ghc', 'ghc', s)

     # Don't wrap commands to subprocess.call/Popen in quotes.

     return s.strip('\'"')

 def str_warn(s: str) -> str:

     return colored(Color.YELLOW, s)

     {-# MINIMAL fmap #-}

   type IO :: * -> *

   newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

   type IP :: Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

     {-# MINIMAL fmap #-}

   type IO :: * -> *

   newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

   type IP :: Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

     {-# MINIMAL fmap #-}

   type IO :: * -> *

   newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

   type IP :: Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

     {-# MINIMAL fmap #-}

   type IO :: * -> *

   newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

   type IP :: Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

     (==) :: a -> a -> GHC.Internal.Types.Bool

     (/=) :: a -> a -> GHC.Internal.Types.Bool

     {-# MINIMAL (==) | (/=) #-}

   type IP :: GHC.Internal.Types.Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

     (==) :: a -> a -> GHC.Internal.Types.Bool

     (/=) :: a -> a -> GHC.Internal.Types.Bool

     {-# MINIMAL (==) | (/=) #-}

   type IP :: GHC.Internal.Types.Symbol -> * -> Constraint

   class IP x a | x -> a where

     ip :: a

                     GHC.Internal.Types.Int

 5

 1

 test('T26451', normal, compile, [''])

 test('T26582', normal, compile, [''])

 test('T26746', normal, compile, [''])

     opt <- optional $ findProgram "opt" (optOpt opts) ["opt"]

     llvmAs <- optional $ findProgram "llvm assembler" (optLlvmAs opts) ["clang"]

     -- Darwin-specific utilities

     (otool, installNameTool) <-