+import GHC.Platform.ArchOS

+       ("target os string",            stringEncodeOS (platformOS (targetPlatform dflags))),

+       ("target arch string",          stringEncodeArch (platformArch (targetPlatform dflags))),

+       ("target word size in bits",    show (platformWordSizeInBits (targetPlatform dflags))),

+import GHC.Types.DefaultEnv ( ClassDefaults(..), DefaultEnv, mkDefaultEnv, DefaultProvenance(..) )

+                              , cd_provenance = DP_Imported this_mod

+import GHC.Types.DefaultEnv (ClassDefaults(ClassDefaults, cd_types, cd_provenance), DefaultProvenance (..))

+              2 (pp dup_things)

+           pp :: ClassDefaults -> SDoc

+           pp (ClassDefaults { cd_provenance = prov })

+             = case prov of

+                DP_Local { defaultDeclLoc = loc, defaultDeclH98 = isH98 }

+                  -> let

+                        what =

+                          if isH98

+                          then text "default declaration"

+                          else text "named default declaration"

+                     in text "conflicting" <+> what <+> text "at:" <+> ppr loc

+                _ -> empty -- doesn't happen, as local defaults override imported and built-in defaults

+defaultTypesAndImport ClassDefaults{cd_types, cd_provenance = DP_Imported cdm} =

+  TcRnMultipleDefaultDeclarations :: Class -> ClassDefaults -> TcRnMessage

+{-# LANGUAGE LambdaCase #-}

+module GHC.Tc.Gen.Default ( tcDefaultDecls, extendDefaultEnvWithLocalDefaults ) where

+import GHC.Data.Maybe ( firstJusts, maybeToList )

+import GHC.Types.DefaultEnv ( DefaultEnv, ClassDefaults (..), lookupDefaultEnv, insertDefaultEnv, DefaultProvenance (..) )

+import GHC.Unit.Types (ghcInternalUnit, moduleUnit)

+import Data.List.NonEmpty ( NonEmpty (..) )

+* This field is populated by `GHC.Tc.Gen.Default.tcDefaultDecls` which typechecks

+  See Note [Builtin class defaults] in GHC.Tc.Utils.Env

+* Class defaults are exported explicitly.

+  For example,

+        module M( ..., default C, ... )

+  exports the defaults for class C.

+

+  A module's exported defaults are computed by exports_from_avail,

+  tracked in tcg_default_exports, which are then transferred to mg_defaults,

+  md_defaults, and mi_defaults_.

+

+  Only defaults explicitly exported are actually exported.

+  (i.e. No defaults are exported in a module header like:

+          module M where ...)

+

+-- | Typecheck a collection of default declarations. These can be either:

+--

+--  - Haskell 98 default declarations, of the form @default (Float, Double)@

+--  - Named default declarations, of the form @default Cls(Int, Char)@.

+--    See Note [Named default declarations]

+tcDefaultDecls :: [LDefaultDecl GhcRn] -> TcM [LocatedA ClassDefaults]

+tcDefaultDecls decls =

+  do

+    tcg_env <- getGblEnv

+    let here = tcg_mod tcg_env

+        is_internal_unit = moduleUnit here == ghcInternalUnit

+    case (is_internal_unit, decls) of

+      -- No default declarations

+      (_, []) -> return []

+      -- As per Remark [default () in ghc-internal] in Note [Builtin class defaults],

+      -- some modules in ghc-internal include an empty `default ()` declaration, in order

+      -- to disable built-in defaults. This is no longer necessary (see `GHC.Tc.Utils.Env.tcGetDefaultTys`),

+      -- but we must still make sure not to error if we fail to look up e.g. the 'Num'

+      -- typeclass when typechecking such a default declaration. To do this, we wrap

+      -- calls of 'tcLookupClass' in 'tryTc'.

+      (True, [L _ (DefaultDecl _ Nothing [])]) -> do

+        h2010_dflt_clss <- foldMapM (fmap maybeToList . fmap fst . tryTc . tcLookupClass) =<< getH2010DefaultNames

+        case NE.nonEmpty h2010_dflt_clss of

+          Nothing -> return []

+          Just h2010_dflt_clss' -> toClassDefaults h2010_dflt_clss' decls

+      -- Otherwise we take apart the declaration into the class constructor and its default types.

+      _ -> do

+        h2010_dflt_clss <- getH2010DefaultClasses

+        toClassDefaults h2010_dflt_clss decls

+    getH2010DefaultClasses = mapM tcLookupClass =<< getH2010DefaultNames

+    getH2010DefaultNames

+      = do { ovl_str   <- xoptM LangExt.OverloadedStrings

+           ; let deflt_str = if ovl_str

+                              then [isStringClassName]

+                              else []

+           ; let deflt_interactive = if ext_deflt

+                                  then interactiveClassNames

+                                  else []

+           ; let extra_clss_names = deflt_str ++ deflt_interactive

+           ; return $ numClassName :| extra_clss_names

+    toClassDefaults :: NonEmpty Class -> [LDefaultDecl GhcRn] -> TcM [LocatedA ClassDefaults]

+    toClassDefaults h2010_dflt_clss dfs = do

+        dfs <- mapMaybeM (declarationParts h2010_dflt_clss) dfs

+        return $ concatMap (go False) dfs

+        go h98 = \case

+          (Nothing, rn_decl, tys) -> concatMap (go True) [(Just cls, rn_decl, tys) | cls <- NE.toList h2010_dflt_clss]

+          (Just cls, (L locn _), tys) -> [(L locn $ ClassDefaults cls tys (DP_Local (locA locn) h98) Nothing)]

+

+-- | Extend the default environment with the local default declarations

+-- and do the action in the extended environment.

+extendDefaultEnvWithLocalDefaults :: [LocatedA ClassDefaults] -> TcM a -> TcM a

+extendDefaultEnvWithLocalDefaults decls action = do

+  tcg_env <- getGblEnv

+  let default_env = tcg_default tcg_env

+  new_default_env <- insertDefaultDecls default_env decls

+  updGblEnv (\gbl -> gbl { tcg_default = new_default_env } ) $ action

+

+-- | Insert local default declarations into the default environment.

+--

+-- See 'insertDefaultDecl'.

+insertDefaultDecls :: DefaultEnv -> [LocatedA ClassDefaults] -> TcM DefaultEnv

+insertDefaultDecls = foldrM insertDefaultDecl

+-- | Insert a local default declaration into the default environment.

+--

+-- If the class already has a local default declaration in the DefaultEnv,

+-- report an error and return the original DefaultEnv. Otherwise, override

+-- any existing default declarations (e.g. imported default declarations).

+--

+-- See Note [Disambiguation of multiple default declarations] in GHC.Tc.Module

+insertDefaultDecl :: LocatedA ClassDefaults -> DefaultEnv -> TcM DefaultEnv

+insertDefaultDecl (L decl_loc new_cls_defaults ) default_env =

+  case lookupDefaultEnv default_env (className cls) of

+    Just cls_defaults

+      | DP_Local {} <- cd_provenance cls_defaults

+      -> do { setSrcSpan (locA decl_loc) (addErrTc $ TcRnMultipleDefaultDeclarations cls cls_defaults)

+            ; return default_env }

+    _ -> return $ insertDefaultEnv new_cls_defaults default_env

+      -- NB: this overrides imported and built-in default declarations

+      -- for this class, if there were any.

+  where

+    cls = cd_class new_cls_defaults

+

+-}

+The `cd_provenance` field of `ClassDefaults` tracks the module whence the default was

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+          defaults <- tcDefaultDecls default_decls

+          ; extendDefaultEnvWithLocalDefaults defaults $ do {

+import GHC.Types.DefaultEnv

+{- Note [Builtin class defaults]

+In the absence of user-defined `default` declarations, the set of class defaults in

+effect (i.e. the `DefaultEnv`) depends on whether the `ExtendedDefaultRules` and

+`OverloadedStrings` extensions are enabled. In their absence, the only rule in effect

+is `default Num (Integer, Double)`, as specified by the Haskell 2010 report.

+

+Remark [No built-in defaults in ghc-internal]

+

+  When typechecking the ghc-internal package, we **do not** include any built-in

+  defaults. This is because, in ghc-internal, types such as 'Num' or 'Integer' may

+  not even be available (they haven't been typechecked yet).

+

+Remark [default () in ghc-internal]

+

+  Historically, modules inside ghc-internal have used a single default declaration,

+  of the form `default ()`, to work around the problem described in

+  Remark [No built-in defaults in ghc-internal].

+

+  When we typecheck such a default declaration, we must also make sure not to fail

+  if e.g. 'Num' is not in scope. We thus have special treatment for this case,

+  in 'GHC.Tc.Gen.Default.tcDefaultDecls'.

+                                                     , cd_provenance = DP_Builtin

+          -- see Remark [No built-in defaults in ghc-internal]

+          -- in Note [Builtin class defaults] in GHC.Tc.Utils.Env

+                -- Supply the built-in defaults, but make the user-supplied defaults

+                -- override them.

+{-# LANGUAGE LambdaCase #-}

+   , DefaultProvenance (..)

+   , insertDefaultEnv

+   , isHaskell2010Default

+import GHC.Types.SrcLoc (SrcSpan)

+{- Note [DefaultProvenance]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Each `ClassDefault` is annotated with its `DefaultProvenance`, which

+says where the default came from.  Specifically

+* `DP_Local loc h98`: the default came from an explicit `default` declaration in the module

+   being compiled, at location `loc`, and the boolean `h98` indicates whether

+   it was from a Haskell 98 default declaration (e.g. `default (Int, Double)`).

+* `DP_Imported M`: the default was imported, it is explicitly exported by module `M`.

+* `DP_Builtin`:  the default was automatically provided by GHC.

+   see Note [Builtin class defaults] in GHC.Tc.Utils.Env

+

+These annotations are used to disambiguate multiple defaults for the same class.

+For example, consider the following modules:

+

+  module M( default C ) where { default C( ... ) }

+  module M2( default C) where { import M }

+  module N( default C () where { default C(... ) }

+

+  module A where { import M2 }

+  module B where { import M2; import N }

+  module A1 where { import N; default C ( ... ) }

+  module B2 where { default C ( ... ); default C ( ... ) }

+

+When compiling N, the default for C is annotated with DP_Local loc.

+When compiling M2, the default for C is annotated with DP_Local M.

+When compiling A, the default for C is annotated with DP_Imported M2.

+

+Cases we needed to disambiguate:

+  * Compiling B, two defaults for C: DP_Imported M2, DP_Imported N.

+  * Compiling A1, two defaults for C: DP_Imported N, DP_Local loc.

+  * Compiling B2, two defaults for C: DP_Local loc1, DP_Local loc2.

+

+For how we disambiguate these cases,

+See Note [Disambiguation of multiple default declarations] in GHC.Tc.Module.

+-}

+

+-- | The provenance of a collection of default types for a class.

+-- see Note [DefaultProvenance] for more details

+data DefaultProvenance

+  -- | A locally defined default declaration.

+  = DP_Local

+     { defaultDeclLoc :: SrcSpan -- ^ The 'SrcSpan' of the default declaration

+     , defaultDeclH98 :: Bool    -- ^ Is this a Haskell 98 default declaration?

+     }

+  -- | Built-in class defaults.

+  | DP_Builtin

+  -- | Imported class defaults.

+  | DP_Imported Module -- ^ The module from which the defaults were imported

+  deriving (Eq, Data)

+

+instance Outputable DefaultProvenance where

+  ppr (DP_Local loc h98) = ppr loc <> (if h98 then text " (H98)" else empty)

+  ppr DP_Builtin         = text "built-in"

+  ppr (DP_Imported mod)  = ppr mod

+

+isHaskell2010Default :: DefaultProvenance -> Bool

+isHaskell2010Default = \case

+  DP_Local { defaultDeclH98 = isH98 } -> isH98

+  DP_Builtin -> True

+  DP_Imported {} -> False

+

+                  , cd_provenance :: DefaultProvenance

+                    -- ^ Where the defaults came from

+insertDefaultEnv :: ClassDefaults -> DefaultEnv -> DefaultEnv

+insertDefaultEnv d env = extendNameEnv env (className $ cd_class d) d

+

+              -- the RTS' host is the compiler's target (the target should be

+              -- per stage ideally...)

+            , "-DHostPlatform="              ++ show targetPlatform

+            , "-DHostArch="                  ++ show targetArch

+            , "-DHostOS="                    ++ show targetOs

+            , "-DHostVendor="                ++ show targetVendor

+  * The following internal modules have been removed from `base`, as per [CLC #217](https://github.com/haskell/core-libraries-committee/issues/217):

+      * `GHC.TypeLits.Internal`

+      * `GHC.TypeNats.Internal`

+      * `GHC.ExecutionStack.Internal`.

+import Control.Monad

+  -- support for old GHCs (pre 9.13): infer target platform by querying the rts...

+  let query_rts = isJust (lookup "Target platform" fields)

+  when query_rts $ do

+    getGhcFieldOrFail fields "WORDSIZE" "Word size"

+    getGhcFieldOrFail fields "TARGETPLATFORM" "Target platform"

+    getGhcFieldOrFail fields "TargetOS_CPP" "Target OS"

+    getGhcFieldOrFail fields "TargetARCH_CPP" "Target architecture"

+

+  unless query_rts $ do

+    getGhcFieldOrFail fields "WORDSIZE" "target word size in bits"

+    getGhcFieldOrFail fields "TARGETPLATFORM" "target platform string"

+    getGhcFieldOrFail fields "TargetOS_CPP" "target os string"

+    getGhcFieldOrFail fields "TargetARCH_CPP" "target arch string"

+

+{-# LANGUAGE NamedDefaults #-}

+

+module Main where

+

+import T25912_helper

+

+-- now we declare the default instances

+-- for the classes C again to check that

+-- it won't hide the default instances for class B

+default C (String)

+

+main :: IO ()

+main = do

+  print b

+"String"

+{-# LANGUAGE NamedDefaults #-}

+

+module T25912_helper ( default C, C(c), default B, b ) where

+

+class C a where

+  c :: a

+instance C Int where

+  c = 1

+instance C String where

+  c = "String"

+default C (String)

+

+class B a where

+  b :: a

+instance B String where

+  b = "String"

+default B (String)

+{-# LANGUAGE NamedDefaults, OverloadedStrings #-}

+module NamedDefaultsNum where

+import Data.String

+default Num ()

+foo = "abc"

+{-# LANGUAGE ExtendedDefaultRules #-}

+{-# LANGUAGE NamedDefaults #-}

+module T25934 where

+default Num (Int)

+default Show (Int)

+test('T25912', [extra_files(['T25912_helper.hs'])], multimod_compile_and_run, ['T25912', ''])

+test('T25914', normal, compile, [''])

+test('T25934', normal, compile, [''])

+default-fail03.hs:4:1: error: [GHC-99565]