Magnus pushed to branch wip/mangoiv/backport-unused-type at Glasgow Haskell Compiler / GHC
Commits:
-
03caad93
by mangoiv at 2026-06-18T13:21:53+02:00
15 changed files:
- compiler/GHC/Builtin/Names.hs
- compiler/GHC/Builtin/Types.hs
- compiler/GHC/HsToCore/Expr.hs
- compiler/GHC/Iface/Type.hs
- compiler/GHC/Tc/Types.hs
- compiler/GHC/Tc/Utils/Monad.hs
- compiler/GHC/Tc/Utils/TcType.hs
- compiler/GHC/Tc/Zonk/Type.hs
- testsuite/tests/perf/compiler/T11068.stdout
- testsuite/tests/pmcheck/should_compile/T12957.stderr
- testsuite/tests/profiling/should_run/staticcallstack002.stdout
- testsuite/tests/simplCore/should_compile/Makefile
- testsuite/tests/simplCore/should_compile/T13156.stdout
- + testsuite/tests/simplCore/should_compile/T26615.stderr
- testsuite/tests/typecheck/should_fail/T13292.stderr
Changes:
| ... | ... | @@ -2007,8 +2007,8 @@ unsatisfiableClassNameKey = mkPreludeTyConUnique 170 |
| 2007 | 2007 | anyTyConKey :: Unique
|
| 2008 | 2008 | anyTyConKey = mkPreludeTyConUnique 171
|
| 2009 | 2009 | |
| 2010 | -zonkAnyTyConKey :: Unique
|
|
| 2011 | -zonkAnyTyConKey = mkPreludeTyConUnique 172
|
|
| 2010 | +unusedTypeTyConKey :: Unique
|
|
| 2011 | +unusedTypeTyConKey = mkPreludeTyConUnique 172
|
|
| 2012 | 2012 | |
| 2013 | 2013 | -- Custom user type-errors
|
| 2014 | 2014 | errorMessageTypeErrorFamKey :: Unique
|
| ... | ... | @@ -92,7 +92,7 @@ module GHC.Builtin.Types ( |
| 92 | 92 | cTupleSelId, cTupleSelIdName,
|
| 93 | 93 | |
| 94 | 94 | -- * Any
|
| 95 | - anyTyCon, anyTy, anyTypeOfKind, zonkAnyTyCon,
|
|
| 95 | + anyTyCon, anyTy, anyTypeOfKind, unusedTypeTyCon,
|
|
| 96 | 96 | |
| 97 | 97 | -- * Recovery TyCon
|
| 98 | 98 | makeRecoveryTyCon,
|
| ... | ... | @@ -310,7 +310,7 @@ wiredInTyCons = map (dataConTyCon . snd) boxingDataCons |
| 310 | 310 | , soloTyCon
|
| 311 | 311 | |
| 312 | 312 | , anyTyCon
|
| 313 | - , zonkAnyTyCon
|
|
| 313 | + , unusedTypeTyCon
|
|
| 314 | 314 | , boolTyCon
|
| 315 | 315 | , charTyCon
|
| 316 | 316 | , stringTyCon
|
| ... | ... | @@ -421,13 +421,13 @@ doubleDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#") |
| 421 | 421 | {-
|
| 422 | 422 | Note [Any types]
|
| 423 | 423 | ~~~~~~~~~~~~~~~~
|
| 424 | -The type constructors `Any` and `ZonkAny` are closed type families declared thus:
|
|
| 424 | +The type constructors `Any` and `UnusedType` are closed type families declared thus:
|
|
| 425 | 425 | |
| 426 | - type family Any :: forall k. k where { }
|
|
| 427 | - type family ZonkAny :: forall k. Nat -> k where { }
|
|
| 426 | + type family Any :: forall k. k where { }
|
|
| 427 | + type family UnusedType :: forall k. Nat -> Symbol -> k where { }
|
|
| 428 | 428 | |
| 429 | 429 | They are used when we want a type of a particular kind, but we don't really care
|
| 430 | -what that type is. The leading example is this: `ZonkAny` is used to instantiate
|
|
| 430 | +what that type is. The leading example is this: `UnusedType` is used to instantiate
|
|
| 431 | 431 | un-constrained type variables after type checking. For example, consider the
|
| 432 | 432 | term (length [] :: Int), where
|
| 433 | 433 | |
| ... | ... | @@ -440,26 +440,26 @@ The typechecker will end up with |
| 440 | 440 | length @alpha ([] @alpha)
|
| 441 | 441 | |
| 442 | 442 | where `alpha` is an un-constrained unification variable. The "zonking" process zaps
|
| 443 | -that unconstrained `alpha` to an arbitrary type (ZonkAny @Type 3), where the `3` is
|
|
| 444 | -arbitrary (see wrinkle (Any5) below). This is done in `GHC.Tc.Zonk.Type.commitFlexi`.
|
|
| 445 | -So we end up with
|
|
| 443 | +that unconstrained `alpha` to an arbitrary type (UnusedType @Type 3 "a"), where the `3` is
|
|
| 444 | +arbitrary (see wrinkle (Any5) below). and `a` is the original name, if we have one.
|
|
| 445 | +This is done in `GHC.Tc.Zonk.Type.commitFlexi`. So we end up with
|
|
| 446 | 446 | |
| 447 | - length @(ZonkAny @Type 3) ([] @(ZonkAny @Type 3))
|
|
| 447 | + length @(UnusedType @Type 3 "a") ([] @(UnusedType @Type 3 "a"))
|
|
| 448 | 448 | |
| 449 | -`Any` and `ZonkAny` differ only in the presence of the `Nat` argument; see
|
|
| 450 | -wrinkle (Any4).
|
|
| 449 | +`Any` and `UnusedType` differ only in the presence of the `Nat` and the `Symbol` arguments;
|
|
| 450 | +see wrinkle (Any4).
|
|
| 451 | 451 | |
| 452 | 452 | Wrinkles:
|
| 453 | 453 | |
| 454 | -(Any1) `Any` and `ZonkAny` are kind polymorphic since in some program we may
|
|
| 455 | - need to use `ZonkAny` to fill in a type variable of some kind other than *
|
|
| 454 | +(Any1) `Any` and `UnusedType` are kind polymorphic since in some program we may
|
|
| 455 | + need to use `UnusedType` to fill in a type variable of some kind other than *
|
|
| 456 | 456 | (see #959 for examples).
|
| 457 | 457 | |
| 458 | 458 | (Any2) They are /closed/ type families, with no instances. For example, suppose that
|
| 459 | 459 | with alpha :: '(k1, k2) we add a given coercion
|
| 460 | 460 | g :: alpha ~ (Fst alpha, Snd alpha)
|
| 461 | - and we zonked alpha = ZonkAny @(k1,k2) n. Then, if `ZonkAny` was a /data/ type,
|
|
| 462 | - we'd get inconsistency because we'd have a Given equality with `ZonkAny` on one
|
|
| 461 | + and we zonked alpha = UnusedType @(k1,k2) n. Then, if `UnusedType` was a /data/ type,
|
|
| 462 | + we'd get inconsistency because we'd have a Given equality with `UnusedType` on one
|
|
| 463 | 463 | side and '(,) on the other. See also #9097 and #9636.
|
| 464 | 464 | |
| 465 | 465 | See #25244 for a suggestion that we instead use an /open/ type family for which
|
| ... | ... | @@ -469,7 +469,7 @@ Wrinkles: |
| 469 | 469 | the code generator, because the code gen may /enter/ a data value
|
| 470 | 470 | but never enters a function value.
|
| 471 | 471 | |
| 472 | -(Any4) `ZonkAny` takes a `Nat` argument so that we can readily make up /distinct/
|
|
| 472 | +(Any4) `UnusedType` takes a `Nat` argument so that we can readily make up /distinct/
|
|
| 473 | 473 | types (#24817). Consider
|
| 474 | 474 | |
| 475 | 475 | data SBool a where { STrue :: SBool True; SFalse :: SBool False }
|
| ... | ... | @@ -484,17 +484,29 @@ Wrinkles: |
| 484 | 484 | Now, what are `alpha` and `beta`? If we zonk both of them to the same type
|
| 485 | 485 | `Any @Type`, the pattern-match checker will (wrongly) report that the first
|
| 486 | 486 | branch is inaccessible. So we zonk them to two /different/ types:
|
| 487 | - alpha := ZonkAny @Type 4 and beta := ZonkAny @Type k 5
|
|
| 487 | + alpha := UnusedType @Type 4 "a" and beta := UnusedType @Type k 5 "b"
|
|
| 488 | 488 | (The actual numbers are arbitrary; they just need to differ.)
|
| 489 | 489 | |
| 490 | 490 | The unique-name generation comes from field `tcg_zany_n` of `TcGblEnv`; and
|
| 491 | - `GHC.Tc.Zonk.Type.commitFlexi` calls `GHC.Tc.Utils.Monad.newZonkAnyType` to
|
|
| 491 | + `GHC.Tc.Zonk.Type.commitFlexi` calls `GHC.Tc.Utils.Monad.newUnusedTypeType` to
|
|
| 492 | 492 | make up a fresh type.
|
| 493 | 493 | |
| 494 | 494 | If this example seems unconvincing (e.g. in this case foo must be bottom)
|
| 495 | 495 | see #24817 for larger but more compelling examples.
|
| 496 | 496 | |
| 497 | -(Any5) `Any` and `ZonkAny` are wired-in so we can easily refer to it where we
|
|
| 497 | + `UnusedType` takes a `Symbol` argument so we can neatly display the type to the user.
|
|
| 498 | + While `UnusedType` ought to be an implementation detail, we sometimes leak it to the
|
|
| 499 | + user, especially in consumers of the GHC api like haskell-language-server.
|
|
| 500 | + The user does not know what an `UnusedType` is and just expects a meta variable.
|
|
| 501 | + However, since the process of zonking should remove all meta variables, we just try to
|
|
| 502 | + reconstruct it when pretty printing, e.g.
|
|
| 503 | + `UnusedType 3 "foo" :: Type` becomes `foo_3`
|
|
| 504 | + |
|
| 505 | + Historical note: `UnusedType` was called `ZonkAny` in older versions of the compiler
|
|
| 506 | + but since this is a leaky abstractions (see above) we give it this improved name
|
|
| 507 | + and handle it specially in the pretty printer to avoid confusion of the user.
|
|
| 508 | + |
|
| 509 | +(Any5) `Any` and `UnusedType` are wired-in so we can easily refer to it where we
|
|
| 498 | 510 | don't have a name environment (e.g. see Rules.matchRule for one example)
|
| 499 | 511 | |
| 500 | 512 | (Any6) `Any` is defined in library module ghc-prim:GHC.Types, and exported so that
|
| ... | ... | @@ -502,7 +514,7 @@ Wrinkles: |
| 502 | 514 | wired-in type:
|
| 503 | 515 | - has a fixed unique, anyTyConKey,
|
| 504 | 516 | - lives in the global name cache
|
| 505 | - Currently `ZonkAny` is not available to users; but it could easily be.
|
|
| 517 | + Currently `UnusedType` is not available to users; but it could easily be.
|
|
| 506 | 518 | |
| 507 | 519 | (Any7) Properties of `Any`:
|
| 508 | 520 | * When `Any` is instantiated at a lifted type it is inhabited by at least one value,
|
| ... | ... | @@ -521,6 +533,17 @@ Wrinkles: |
| 521 | 533 | |
| 522 | 534 | See examples in ghc-prim:GHC.Types
|
| 523 | 535 | |
| 536 | +(Any8) Warning about unused bindings of type `Any` and `UnusedType` are suppressed,
|
|
| 537 | + following the same rationale of supressing warning about the unit type.
|
|
| 538 | + |
|
| 539 | + For example, consider (#25895):
|
|
| 540 | + |
|
| 541 | + do { forever (return ()); blah }
|
|
| 542 | + |
|
| 543 | + where forever :: forall a b. IO a -> IO b
|
|
| 544 | + Nothing constrains `b`, so it will be instantiates with `Any` or `UnusedType`.
|
|
| 545 | + But we certainly don't want to complain about a discarded do-binding.
|
|
| 546 | + |
|
| 524 | 547 | The Any tycon used to be quite magic, but we have since been able to
|
| 525 | 548 | implement it merely with an empty kind polymorphic type family. See #10886 for a
|
| 526 | 549 | bit of history.
|
| ... | ... | @@ -547,23 +570,25 @@ anyTy = mkTyConTy anyTyCon |
| 547 | 570 | anyTypeOfKind :: Kind -> Type
|
| 548 | 571 | anyTypeOfKind kind = mkTyConApp anyTyCon [kind]
|
| 549 | 572 | |
| 550 | -zonkAnyTyConName :: Name
|
|
| 551 | -zonkAnyTyConName =
|
|
| 552 | - mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "ZonkAny") zonkAnyTyConKey zonkAnyTyCon
|
|
| 573 | +unusedTypeTyConName :: Name
|
|
| 574 | +unusedTypeTyConName =
|
|
| 575 | + mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "UnusedType") unusedTypeTyConKey unusedTypeTyCon
|
|
| 553 | 576 | |
| 554 | -zonkAnyTyCon :: TyCon
|
|
| 555 | --- ZonkAnyTyCon :: forall k. Nat -> k
|
|
| 577 | +unusedTypeTyCon :: TyCon
|
|
| 578 | +-- unusedTypeTyCon :: forall k. Nat -> Symbol -> k
|
|
| 556 | 579 | -- See Note [Any types]
|
| 557 | -zonkAnyTyCon = mkFamilyTyCon zonkAnyTyConName
|
|
| 558 | - [ mkNamedTyConBinder Specified kv
|
|
| 559 | - , mkAnonTyConBinder nat_kv ]
|
|
| 560 | - (mkTyVarTy kv)
|
|
| 580 | +unusedTypeTyCon = mkFamilyTyCon unusedTypeTyConName bndrs res_kind
|
|
| 561 | 581 | Nothing
|
| 562 | 582 | (ClosedSynFamilyTyCon Nothing)
|
| 563 | 583 | Nothing
|
| 564 | 584 | NotInjective
|
| 565 | 585 | where
|
| 566 | - [kv,nat_kv] = mkTemplateKindVars [liftedTypeKind, naturalTy]
|
|
| 586 | + [kv,nat_kv,sym_kv] = mkTemplateKindVars [liftedTypeKind, naturalTy, typeSymbolKind]
|
|
| 587 | + bndrs = [ mkNamedTyConBinder Specified kv
|
|
| 588 | + , mkAnonTyConBinder nat_kv
|
|
| 589 | + , mkAnonTyConBinder sym_kv ]
|
|
| 590 | + res_kind = mkTyVarTy kv
|
|
| 591 | + kind = mkTyConKind bndrs res_kind
|
|
| 567 | 592 | |
| 568 | 593 | -- | Make a fake, recovery 'TyCon' from an existing one.
|
| 569 | 594 | -- Used when recovering from errors in type declarations
|
| ... | ... | @@ -985,9 +985,13 @@ warnDiscardedDoBindings rhs rhs_ty |
| 985 | 985 | ; when (warn_unused || warn_wrong) $
|
| 986 | 986 | do { fam_inst_envs <- dsGetFamInstEnvs
|
| 987 | 987 | ; let norm_elt_ty = topNormaliseType fam_inst_envs elt_ty
|
| 988 | - |
|
| 989 | - -- Warn about discarding non-() things in 'monadic' binding
|
|
| 990 | - ; if warn_unused && not (isUnitTy norm_elt_ty)
|
|
| 988 | + supressible_ty =
|
|
| 989 | + isUnitTy norm_elt_ty || isAnyTy norm_elt_ty || isUnusedTypeTy norm_elt_ty
|
|
| 990 | + -- Warn about discarding things in 'monadic' binding,
|
|
| 991 | + -- however few types are excluded:
|
|
| 992 | + -- * Unit type `()`
|
|
| 993 | + -- * `UnusedType` or `Any` type see (Any8) of Note [Any types]
|
|
| 994 | + ; if warn_unused && not supressible_ty
|
|
| 991 | 995 | then diagnosticDs (DsUnusedDoBind rhs elt_ty)
|
| 992 | 996 | else
|
| 993 | 997 |
| ... | ... | @@ -7,7 +7,7 @@ This module defines interface types and binders |
| 7 | 7 | -}
|
| 8 | 8 | |
| 9 | 9 | |
| 10 | -{-# LANGUAGE MultiWayIf #-}
|
|
| 10 | +{-# LANGUAGE MultiWayIf, OverloadedRecordDot #-}
|
|
| 11 | 11 | {-# LANGUAGE LambdaCase #-}
|
| 12 | 12 | module GHC.Iface.Type (
|
| 13 | 13 | IfExtName,
|
| ... | ... | @@ -1664,6 +1664,7 @@ pprTyTcApp ctxt_prec tc tys = |
| 1664 | 1664 | sdocOption sdocPrintExplicitKinds $ \print_kinds ->
|
| 1665 | 1665 | sdocOption sdocPrintTypeAbbreviations $ \print_type_abbreviations ->
|
| 1666 | 1666 | getPprDebug $ \debug ->
|
| 1667 | + getPprStyle $ \style ->
|
|
| 1667 | 1668 | |
| 1668 | 1669 | if | ifaceTyConName tc `hasKey` ipClassKey
|
| 1669 | 1670 | , IA_Arg (IfaceLitTy (IfaceStrTyLit n))
|
| ... | ... | @@ -1715,6 +1716,12 @@ pprTyTcApp ctxt_prec tc tys = |
| 1715 | 1716 | | Just doc <- ppr_equality ctxt_prec tc (appArgsIfaceTypes tys)
|
| 1716 | 1717 | -> doc
|
| 1717 | 1718 | |
| 1719 | + | ifaceTyConName tc `hasKey` unusedTypeTyConKey
|
|
| 1720 | + , (arg_k : IfaceLitTy (IfaceNumTyLit arg_n) : IfaceLitTy (IfaceStrTyLit arg_nm) : _) <- appArgsIfaceTypes tys
|
|
| 1721 | + -- if arg_k is a kind with more than 0 arguments, then _ might not be [] here
|
|
| 1722 | + , userStyle style
|
|
| 1723 | + -> ppr_iface_unused_ty_tycon ctxt_prec arg_k arg_n arg_nm
|
|
| 1724 | + |
|
| 1718 | 1725 | | otherwise
|
| 1719 | 1726 | -> ppr_iface_tc_app ppr_app_arg ctxt_prec tc $
|
| 1720 | 1727 | appArgsIfaceTypesForAllTyFlags $ stripInvisArgs (PrintExplicitKinds print_kinds) tys
|
| ... | ... | @@ -1727,6 +1734,15 @@ ppr_kind_type ctxt_prec = sdocOption sdocStarIsType $ \case |
| 1727 | 1734 | True -> maybeParen ctxt_prec starPrec $
|
| 1728 | 1735 | unicodeSyntax (char '★') (char '*')
|
| 1729 | 1736 | |
| 1737 | +ppr_iface_unused_ty_tycon :: PprPrec -> IfaceType -> Integer -> LexicalFastString -> SDoc
|
|
| 1738 | +ppr_iface_unused_ty_tycon ctxt_prec arg_k arg_n arg_nm
|
|
| 1739 | + = sdocOption sdocPrintExplicitKinds $ \print_kinds ->
|
|
| 1740 | + sdocOption sdocPrintExplicitRuntimeReps $ \print_reps ->
|
|
| 1741 | + if print_kinds || print_reps
|
|
| 1742 | + then maybeParen ctxt_prec sigPrec $ prettyMeta <+> text "::" <+> pprIfaceType arg_k
|
|
| 1743 | + else prettyMeta
|
|
| 1744 | + where prettyMeta = ppr arg_nm <> ppr arg_n
|
|
| 1745 | + |
|
| 1730 | 1746 | -- | Pretty-print a type-level equality.
|
| 1731 | 1747 | -- Returns (Just doc) if the argument is a /saturated/ application
|
| 1732 | 1748 | -- of eqTyCon (~)
|
| ... | ... | @@ -2113,7 +2129,8 @@ instance Binary IfaceTyConSort where |
| 2113 | 2129 | 0 -> return IfaceNormalTyCon
|
| 2114 | 2130 | 1 -> IfaceTupleTyCon <$> get bh <*> get bh
|
| 2115 | 2131 | 2 -> IfaceSumTyCon <$> get bh
|
| 2116 | - _ -> return IfaceEqualityTyCon
|
|
| 2132 | + 3 -> return IfaceEqualityTyCon
|
|
| 2133 | + _ -> panic "get IfaceTyConSort"
|
|
| 2117 | 2134 | |
| 2118 | 2135 | instance Binary IfaceTyConInfo where
|
| 2119 | 2136 | put_ bh (IfaceTyConInfo i s) = put_ bh i >> put_ bh s
|
| ... | ... | @@ -569,7 +569,7 @@ data TcGblEnv |
| 569 | 569 | -- ^ Allows us to choose unique DFun names.
|
| 570 | 570 | |
| 571 | 571 | tcg_zany_n :: TcRef Integer,
|
| 572 | - -- ^ A source of unique identities for ZonkAny instances
|
|
| 572 | + -- ^ A source of unique identities for UnusedType instances
|
|
| 573 | 573 | -- See Note [Any types] in GHC.Builtin.Types, wrinkle (Any4)
|
| 574 | 574 | |
| 575 | 575 | tcg_merged :: [(Module, Fingerprint)],
|
| ... | ... | @@ -142,7 +142,7 @@ module GHC.Tc.Utils.Monad( |
| 142 | 142 | getCCIndexM, getCCIndexTcM,
|
| 143 | 143 | |
| 144 | 144 | -- * Zonking
|
| 145 | - liftZonkM, newZonkAnyType,
|
|
| 145 | + liftZonkM, newUnusedType,
|
|
| 146 | 146 | |
| 147 | 147 | -- * Complete matches
|
| 148 | 148 | localAndImportedCompleteMatches, getCompleteMatchesTcM,
|
| ... | ... | @@ -156,7 +156,7 @@ import GHC.Prelude |
| 156 | 156 | |
| 157 | 157 | |
| 158 | 158 | import GHC.Builtin.Names
|
| 159 | -import GHC.Builtin.Types( zonkAnyTyCon )
|
|
| 159 | +import GHC.Builtin.Types( unusedTypeTyCon )
|
|
| 160 | 160 | |
| 161 | 161 | import GHC.Tc.Errors.Types
|
| 162 | 162 | import GHC.Tc.Types -- Re-export all
|
| ... | ... | @@ -180,7 +180,7 @@ import GHC.Core.UsageEnv |
| 180 | 180 | import GHC.Core.Multiplicity
|
| 181 | 181 | import GHC.Core.InstEnv
|
| 182 | 182 | import GHC.Core.FamInstEnv
|
| 183 | -import GHC.Core.Type( mkNumLitTy )
|
|
| 183 | +import GHC.Core.Type( mkNumLitTy, mkStrLitTy )
|
|
| 184 | 184 | |
| 185 | 185 | import GHC.Driver.Env
|
| 186 | 186 | import GHC.Driver.Session
|
| ... | ... | @@ -1792,17 +1792,17 @@ chooseUniqueOccTc fn = |
| 1792 | 1792 | ; writeTcRef dfun_n_var (extendOccSet set occ)
|
| 1793 | 1793 | ; return occ }
|
| 1794 | 1794 | |
| 1795 | -newZonkAnyType :: Kind -> TcM Type
|
|
| 1796 | --- Return a type (ZonkAny @k n), where n is fresh
|
|
| 1797 | --- Recall ZonkAny :: forall k. Natural -> k
|
|
| 1795 | +newUnusedType :: Name -> Kind -> TcM Type
|
|
| 1796 | +-- Return a type (UnusedType @k n sym), where n is fresh
|
|
| 1797 | +-- Recall UnusedType :: forall k. Natural -> Symbol -> k
|
|
| 1798 | 1798 | -- See Note [Any types] in GHC.Builtin.Types, wrinkle (Any4)
|
| 1799 | -newZonkAnyType kind
|
|
| 1799 | +newUnusedType name kind
|
|
| 1800 | 1800 | = do { env <- getGblEnv
|
| 1801 | 1801 | ; let zany_n_var = tcg_zany_n env
|
| 1802 | 1802 | ; i <- readTcRef zany_n_var
|
| 1803 | 1803 | ; let !i2 = i+1
|
| 1804 | 1804 | ; writeTcRef zany_n_var i2
|
| 1805 | - ; return (mkTyConApp zonkAnyTyCon [kind, mkNumLitTy i]) }
|
|
| 1805 | + ; return (mkTyConApp unusedTypeTyCon [kind, mkNumLitTy i, mkStrLitTy $ getOccFS name ]) }
|
|
| 1806 | 1806 | |
| 1807 | 1807 | getConstraintVar :: TcM (TcRef WantedConstraints)
|
| 1808 | 1808 | getConstraintVar = do { env <- getLclEnv; return (tcl_lie env) }
|
| ... | ... | @@ -88,7 +88,7 @@ module GHC.Tc.Utils.TcType ( |
| 88 | 88 | isSigmaTy, isRhoTy, isRhoExpTy, isOverloadedTy,
|
| 89 | 89 | isFloatingPrimTy, isDoubleTy, isFloatTy, isIntTy, isWordTy, isStringTy,
|
| 90 | 90 | isIntegerTy, isNaturalTy,
|
| 91 | - isBoolTy, isUnitTy, isCharTy,
|
|
| 91 | + isBoolTy, isUnitTy, isAnyTy, isUnusedTypeTy, isCharTy,
|
|
| 92 | 92 | isTauTy, isTauTyCon, tcIsTyVarTy,
|
| 93 | 93 | isPredTy, isTyVarClassPred,
|
| 94 | 94 | checkValidClsArgs, hasTyVarHead,
|
| ... | ... | @@ -2005,7 +2005,7 @@ isFloatTy, isDoubleTy, |
| 2005 | 2005 | isFloatPrimTy, isDoublePrimTy,
|
| 2006 | 2006 | isIntegerTy, isNaturalTy,
|
| 2007 | 2007 | isIntTy, isWordTy, isBoolTy,
|
| 2008 | - isUnitTy, isCharTy :: Type -> Bool
|
|
| 2008 | + isUnitTy, isAnyTy, isUnusedTypeTy, isCharTy :: Type -> Bool
|
|
| 2009 | 2009 | isFloatTy = is_tc floatTyConKey
|
| 2010 | 2010 | isDoubleTy = is_tc doubleTyConKey
|
| 2011 | 2011 | isFloatPrimTy = is_tc floatPrimTyConKey
|
| ... | ... | @@ -2016,6 +2016,8 @@ isIntTy = is_tc intTyConKey |
| 2016 | 2016 | isWordTy = is_tc wordTyConKey
|
| 2017 | 2017 | isBoolTy = is_tc boolTyConKey
|
| 2018 | 2018 | isUnitTy = is_tc unitTyConKey
|
| 2019 | +isAnyTy = is_tc anyTyConKey
|
|
| 2020 | +isUnusedTypeTy = is_tc unusedTypeTyConKey
|
|
| 2019 | 2021 | isCharTy = is_tc charTyConKey
|
| 2020 | 2022 | |
| 2021 | 2023 | -- | Check whether the type is of the form @Any :: k@,
|
| 1 | +{-# LANGUAGE OverloadedRecordDot #-}
|
|
| 1 | 2 | {-# LANGUAGE GADTs #-}
|
| 2 | 3 | |
| 3 | 4 | {-
|
| ... | ... | @@ -54,7 +55,7 @@ import GHC.Tc.Types.TcRef |
| 54 | 55 | import GHC.Tc.TyCl.Build ( TcMethInfo, MethInfo )
|
| 55 | 56 | import GHC.Tc.Utils.Env ( tcLookupGlobalOnly )
|
| 56 | 57 | import GHC.Tc.Utils.TcType
|
| 57 | -import GHC.Tc.Utils.Monad ( newZonkAnyType, setSrcSpanA, liftZonkM, traceTc, addErr )
|
|
| 58 | +import GHC.Tc.Utils.Monad ( newUnusedType, setSrcSpanA, liftZonkM, traceTc, addErr )
|
|
| 58 | 59 | import GHC.Tc.Types.Constraint
|
| 59 | 60 | import GHC.Tc.Types.Evidence
|
| 60 | 61 | import GHC.Tc.Errors.Types
|
| ... | ... | @@ -471,7 +472,7 @@ commitFlexi tv zonked_kind |
| 471 | 472 | | otherwise
|
| 472 | 473 | -> do { traceTc "Defaulting flexi tyvar to ZonkAny:" (pprTyVar tv)
|
| 473 | 474 | -- See Note [Any types] in GHC.Builtin.Types, esp wrinkle (Any4)
|
| 474 | - ; newZonkAnyType zonked_kind }
|
|
| 475 | + ; newUnusedType name zonked_kind }
|
|
| 475 | 476 | |
| 476 | 477 | RuntimeUnkFlexi
|
| 477 | 478 | -> do { traceTc "Defaulting flexi tyvar to RuntimeUnk:" (pprTyVar tv)
|
| ... | ... | @@ -23,137 +23,137 @@ |
| 23 | 23 | `cast` (GHC.Internal.Generics.N:M1
|
| 24 | 24 | `cast` (GHC.Internal.Generics.N:M1
|
| 25 | 25 | = GHC.Internal.Generics.L1
|
| 26 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 26 | + ((GHC.Internal.Generics.U1
|
|
| 27 | 27 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 28 | 28 | = GHC.Internal.Generics.L1
|
| 29 | 29 | = GHC.Internal.Generics.L1
|
| 30 | 30 | = GHC.Internal.Generics.L1
|
| 31 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 31 | + ((GHC.Internal.Generics.U1
|
|
| 32 | 32 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 33 | 33 | = GHC.Internal.Generics.R1
|
| 34 | 34 | = GHC.Internal.Generics.L1
|
| 35 | 35 | = GHC.Internal.Generics.L1
|
| 36 | 36 | = GHC.Internal.Generics.R1
|
| 37 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 37 | + ((GHC.Internal.Generics.U1
|
|
| 38 | 38 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 39 | 39 | = GHC.Internal.Generics.R1
|
| 40 | 40 | = GHC.Internal.Generics.L1
|
| 41 | 41 | = GHC.Internal.Generics.L1
|
| 42 | 42 | = GHC.Internal.Generics.L1
|
| 43 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 43 | + ((GHC.Internal.Generics.U1
|
|
| 44 | 44 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 45 | 45 | = GHC.Internal.Generics.R1
|
| 46 | 46 | = GHC.Internal.Generics.L1
|
| 47 | 47 | = GHC.Internal.Generics.L1
|
| 48 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 48 | + ((GHC.Internal.Generics.U1
|
|
| 49 | 49 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 50 | 50 | = GHC.Internal.Generics.R1
|
| 51 | 51 | = GHC.Internal.Generics.R1
|
| 52 | 52 | = GHC.Internal.Generics.L1
|
| 53 | 53 | = GHC.Internal.Generics.R1
|
| 54 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 54 | + ((GHC.Internal.Generics.U1
|
|
| 55 | 55 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 56 | 56 | = GHC.Internal.Generics.R1
|
| 57 | 57 | = GHC.Internal.Generics.R1
|
| 58 | 58 | = GHC.Internal.Generics.L1
|
| 59 | 59 | = GHC.Internal.Generics.L1
|
| 60 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 60 | + ((GHC.Internal.Generics.U1
|
|
| 61 | 61 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 62 | 62 | = GHC.Internal.Generics.L1
|
| 63 | 63 | = GHC.Internal.Generics.R1
|
| 64 | 64 | = GHC.Internal.Generics.L1
|
| 65 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 65 | + ((GHC.Internal.Generics.U1
|
|
| 66 | 66 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 67 | 67 | = GHC.Internal.Generics.R1
|
| 68 | 68 | = GHC.Internal.Generics.L1
|
| 69 | 69 | = GHC.Internal.Generics.R1
|
| 70 | 70 | = GHC.Internal.Generics.R1
|
| 71 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 71 | + ((GHC.Internal.Generics.U1
|
|
| 72 | 72 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 73 | 73 | = GHC.Internal.Generics.R1
|
| 74 | 74 | = GHC.Internal.Generics.L1
|
| 75 | 75 | = GHC.Internal.Generics.R1
|
| 76 | 76 | = GHC.Internal.Generics.L1
|
| 77 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 77 | + ((GHC.Internal.Generics.U1
|
|
| 78 | 78 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 79 | 79 | = GHC.Internal.Generics.R1
|
| 80 | 80 | = GHC.Internal.Generics.R1
|
| 81 | 81 | = GHC.Internal.Generics.L1
|
| 82 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 82 | + ((GHC.Internal.Generics.U1
|
|
| 83 | 83 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 84 | 84 | = GHC.Internal.Generics.R1
|
| 85 | 85 | = GHC.Internal.Generics.R1
|
| 86 | 86 | = GHC.Internal.Generics.R1
|
| 87 | 87 | = GHC.Internal.Generics.R1
|
| 88 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 88 | + ((GHC.Internal.Generics.U1
|
|
| 89 | 89 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 90 | 90 | = GHC.Internal.Generics.R1
|
| 91 | 91 | = GHC.Internal.Generics.R1
|
| 92 | 92 | = GHC.Internal.Generics.R1
|
| 93 | 93 | = GHC.Internal.Generics.L1
|
| 94 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 94 | + ((GHC.Internal.Generics.U1
|
|
| 95 | 95 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 96 | 96 | = GHC.Internal.Generics.L1
|
| 97 | 97 | = GHC.Internal.Generics.L1
|
| 98 | 98 | = GHC.Internal.Generics.L1
|
| 99 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 99 | + ((GHC.Internal.Generics.U1
|
|
| 100 | 100 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 101 | 101 | = GHC.Internal.Generics.R1
|
| 102 | 102 | = GHC.Internal.Generics.L1
|
| 103 | 103 | = GHC.Internal.Generics.L1
|
| 104 | 104 | = GHC.Internal.Generics.R1
|
| 105 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 105 | + ((GHC.Internal.Generics.U1
|
|
| 106 | 106 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 107 | 107 | = GHC.Internal.Generics.R1
|
| 108 | 108 | = GHC.Internal.Generics.L1
|
| 109 | 109 | = GHC.Internal.Generics.L1
|
| 110 | 110 | = GHC.Internal.Generics.L1
|
| 111 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 111 | + ((GHC.Internal.Generics.U1
|
|
| 112 | 112 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 113 | 113 | = GHC.Internal.Generics.R1
|
| 114 | 114 | = GHC.Internal.Generics.L1
|
| 115 | 115 | = GHC.Internal.Generics.L1
|
| 116 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 116 | + ((GHC.Internal.Generics.U1
|
|
| 117 | 117 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 118 | 118 | = GHC.Internal.Generics.R1
|
| 119 | 119 | = GHC.Internal.Generics.R1
|
| 120 | 120 | = GHC.Internal.Generics.L1
|
| 121 | 121 | = GHC.Internal.Generics.R1
|
| 122 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 122 | + ((GHC.Internal.Generics.U1
|
|
| 123 | 123 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 124 | 124 | = GHC.Internal.Generics.R1
|
| 125 | 125 | = GHC.Internal.Generics.R1
|
| 126 | 126 | = GHC.Internal.Generics.L1
|
| 127 | 127 | = GHC.Internal.Generics.L1
|
| 128 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 128 | + ((GHC.Internal.Generics.U1
|
|
| 129 | 129 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 130 | 130 | = GHC.Internal.Generics.L1
|
| 131 | 131 | = GHC.Internal.Generics.R1
|
| 132 | 132 | = GHC.Internal.Generics.L1
|
| 133 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 133 | + ((GHC.Internal.Generics.U1
|
|
| 134 | 134 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 135 | 135 | = GHC.Internal.Generics.R1
|
| 136 | 136 | = GHC.Internal.Generics.L1
|
| 137 | 137 | = GHC.Internal.Generics.R1
|
| 138 | 138 | = GHC.Internal.Generics.R1
|
| 139 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 139 | + ((GHC.Internal.Generics.U1
|
|
| 140 | 140 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 141 | 141 | = GHC.Internal.Generics.R1
|
| 142 | 142 | = GHC.Internal.Generics.L1
|
| 143 | 143 | = GHC.Internal.Generics.R1
|
| 144 | 144 | = GHC.Internal.Generics.L1
|
| 145 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 145 | + ((GHC.Internal.Generics.U1
|
|
| 146 | 146 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 147 | 147 | = GHC.Internal.Generics.R1
|
| 148 | 148 | = GHC.Internal.Generics.R1
|
| 149 | 149 | = GHC.Internal.Generics.L1
|
| 150 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 150 | + ((GHC.Internal.Generics.U1
|
|
| 151 | 151 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 152 | 152 | = GHC.Internal.Generics.R1
|
| 153 | 153 | = GHC.Internal.Generics.R1
|
| 154 | 154 | = GHC.Internal.Generics.R1
|
| 155 | 155 | = GHC.Internal.Generics.R1
|
| 156 | - ((GHC.Internal.Generics.U1 @(*) @(GHC.Types.ZonkAny 0))
|
|
| 156 | + ((GHC.Internal.Generics.U1
|
|
| 157 | 157 | `cast` (Sym (GHC.Internal.Generics.N:M1
|
| 158 | 158 | = GHC.Internal.Generics.R1
|
| 159 | 159 | = GHC.Internal.Generics.R1
|
| 1 | 1 | T12957.hs:4:5: warning: [GHC-62161] [-Wincomplete-patterns (in -Wextra)]
|
| 2 | 2 | Pattern match(es) are non-exhaustive
|
| 3 | - In a case alternative:
|
|
| 4 | - Patterns of type ‘[GHC.Types.ZonkAny 0]’ not matched: []
|
|
| 3 | + In a case alternative: Patterns of type ‘[a0]’ not matched: []
|
|
| 5 | 4 | |
| 6 | 5 | T12957.hs:4:16: warning: [GHC-53633] [-Woverlapping-patterns (in -Wdefault)]
|
| 7 | 6 | Pattern match is redundant
|
| 1 | -Just (InfoProv {ipName = "sat_s1Rh_info", ipDesc = THUNK, ipTyDesc = "ZonkAny 0", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "10:23-39"})
|
|
| 2 | -Just (InfoProv {ipName = "sat_s1RB_info", ipDesc = THUNK, ipTyDesc = "ZonkAny 1", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "11:23-42"})
|
|
| 3 | -Just (InfoProv {ipName = "sat_s1RV_info", ipDesc = THUNK, ipTyDesc = "ZonkAny 2", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "12:23-46"})
|
|
| 4 | -Just (InfoProv {ipName = "sat_s1Sf_info", ipDesc = THUNK, ipTyDesc = "ZonkAny 3", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "13:23-44"}) |
|
| 1 | +Just (InfoProv {ipName = "main_sat_t2fs_info", ipDesc = THUNK, ipTyDesc = "UnusedType 0 \"a\"", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "10:23-39"})
|
|
| 2 | +Just (InfoProv {ipName = "main_sat_t2fJ_info", ipDesc = THUNK, ipTyDesc = "UnusedType 1 \"a\"", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "11:23-42"})
|
|
| 3 | +Just (InfoProv {ipName = "main_sat_t2g0_info", ipDesc = THUNK, ipTyDesc = "UnusedType 2 \"a\"", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "12:23-46"})
|
|
| 4 | +Just (InfoProv {ipName = "main_sat_t2gh_info", ipDesc = THUNK, ipTyDesc = "UnusedType 3 \"a\"", ipLabel = "main", ipUnitId = "main", ipMod = "Main", ipSrcFile = "staticcallstack002.hs", ipSrcSpan = "13:23-44"}) |
| ... | ... | @@ -178,7 +178,7 @@ T13155: |
| 178 | 178 | |
| 179 | 179 | T13156:
|
| 180 | 180 | $(RM) -f T13156.hi T13156.o
|
| 181 | - '$(TEST_HC)' $(TEST_HC_OPTS) -c T13156.hs -O -ddump-prep -dsuppress-uniques | grep "case.*Any"
|
|
| 181 | + '$(TEST_HC)' $(TEST_HC_OPTS) -c T13156.hs -O -ddump-prep -dsuppress-uniques | grep "case.*UnusedType"
|
|
| 182 | 182 | # There should be a single 'case r @ GHC.Types.Any'
|
| 183 | 183 | |
| 184 | 184 | .PHONY: T4138
|
| 1 | - case r @(GHC.Types.ZonkAny 0) of { __DEFAULT ->
|
|
| 2 | - case r @(GHC.Types.ZonkAny 1) of { __DEFAULT -> r @a } |
|
| 1 | + case r @(GHC.Internal.Types.UnusedType 0 "a") of { __DEFAULT ->
|
|
| 2 | + case r @(GHC.Internal.Types.UnusedType 1 "a") of { __DEFAULT -> |
| 1 | +[1 of 2] Compiling T26615a ( T26615a.hs, T26615a.o )
|
|
| 2 | + |
|
| 3 | +==================== Tidy Core ====================
|
|
| 4 | +Result size of Tidy Core
|
|
| 5 | + = {terms: 1,209, types: 1,155, coercions: 18, joins: 17/29}
|
|
| 6 | + |
|
| 7 | +-- RHS size: {terms: 6, types: 8, coercions: 0, joins: 0/0}
|
|
| 8 | +unArray :: forall a. Array a -> SmallArray# a
|
|
| 9 | +[GblId[[RecSel]],
|
|
| 10 | + Arity=1,
|
|
| 11 | + Str=<1!P(1L)>,
|
|
| 12 | + Unf=Unf{Src=<vanilla>, TopLvl=True,
|
|
| 13 | + Value=True, ConLike=True, WorkFree=True, Expandable=True,
|
|
| 14 | + Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)}]
|
|
| 15 | +unArray = \ (@a) (ds :: Array a) -> case ds of { Array ds1 -> ds1 }
|
|
| 16 | + |
|
| 17 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 18 | +$trModule1 :: Addr#
|
|
| 19 | +[GblId, Unf=OtherCon []]
|
|
| 20 | +$trModule1 = "main"#
|
|
| 21 | + |
|
| 22 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 23 | +$trModule2 :: GHC.Internal.Types.TrName
|
|
| 24 | +[GblId, Unf=OtherCon []]
|
|
| 25 | +$trModule2 = GHC.Internal.Types.TrNameS $trModule1
|
|
| 26 | + |
|
| 27 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 28 | +$trModule3 :: Addr#
|
|
| 29 | +[GblId, Unf=OtherCon []]
|
|
| 30 | +$trModule3 = "T26615a"#
|
|
| 31 | + |
|
| 32 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 33 | +$trModule4 :: GHC.Internal.Types.TrName
|
|
| 34 | +[GblId, Unf=OtherCon []]
|
|
| 35 | +$trModule4 = GHC.Internal.Types.TrNameS $trModule3
|
|
| 36 | + |
|
| 37 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 38 | +T26615a.$trModule [InlPrag=[~]] :: GHC.Internal.Types.Module
|
|
| 39 | +[GblId, Unf=OtherCon []]
|
|
| 40 | +T26615a.$trModule = GHC.Internal.Types.Module $trModule2 $trModule4
|
|
| 41 | + |
|
| 42 | +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
|
|
| 43 | +$krep :: GHC.Internal.Types.KindRep
|
|
| 44 | +[GblId, Unf=OtherCon []]
|
|
| 45 | +$krep
|
|
| 46 | + = GHC.Internal.Types.KindRepTyConApp
|
|
| 47 | + GHC.Internal.Types.$tc'Lifted
|
|
| 48 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 49 | + |
|
| 50 | +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
|
|
| 51 | +$krep1 :: GHC.Internal.Types.KindRep
|
|
| 52 | +[GblId, Unf=OtherCon []]
|
|
| 53 | +$krep1
|
|
| 54 | + = GHC.Internal.Types.KindRepTyConApp
|
|
| 55 | + GHC.Internal.Types.$tcWord
|
|
| 56 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 57 | + |
|
| 58 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 59 | +$krep2 :: GHC.Internal.Types.KindRep
|
|
| 60 | +[GblId, Unf=OtherCon []]
|
|
| 61 | +$krep2 = GHC.Internal.Types.KindRepVar 1#
|
|
| 62 | + |
|
| 63 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 64 | +$krep3 :: GHC.Internal.Types.KindRep
|
|
| 65 | +[GblId, Unf=OtherCon []]
|
|
| 66 | +$krep3 = GHC.Internal.Types.KindRepVar 0#
|
|
| 67 | + |
|
| 68 | +-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
|
|
| 69 | +$krep4 :: [GHC.Internal.Types.KindRep]
|
|
| 70 | +[GblId, Unf=OtherCon []]
|
|
| 71 | +$krep4
|
|
| 72 | + = GHC.Internal.Types.:
|
|
| 73 | + @GHC.Internal.Types.KindRep
|
|
| 74 | + $krep3
|
|
| 75 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 76 | + |
|
| 77 | +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
|
|
| 78 | +$krep5 :: [GHC.Internal.Types.KindRep]
|
|
| 79 | +[GblId, Unf=OtherCon []]
|
|
| 80 | +$krep5
|
|
| 81 | + = GHC.Internal.Types.: @GHC.Internal.Types.KindRep $krep $krep4
|
|
| 82 | + |
|
| 83 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 84 | +$krep6 :: GHC.Internal.Types.KindRep
|
|
| 85 | +[GblId, Unf=OtherCon []]
|
|
| 86 | +$krep6
|
|
| 87 | + = GHC.Internal.Types.KindRepTyConApp
|
|
| 88 | + GHC.Internal.Types.$tcSmallArray# $krep5
|
|
| 89 | + |
|
| 90 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 91 | +$tcLeaf1 :: Addr#
|
|
| 92 | +[GblId, Unf=OtherCon []]
|
|
| 93 | +$tcLeaf1 = "Leaf"#
|
|
| 94 | + |
|
| 95 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 96 | +$tcLeaf2 :: GHC.Internal.Types.TrName
|
|
| 97 | +[GblId, Unf=OtherCon []]
|
|
| 98 | +$tcLeaf2 = GHC.Internal.Types.TrNameS $tcLeaf1
|
|
| 99 | + |
|
| 100 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 101 | +T26615a.$tcLeaf [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 102 | +[GblId, Unf=OtherCon []]
|
|
| 103 | +T26615a.$tcLeaf
|
|
| 104 | + = GHC.Internal.Types.TyCon
|
|
| 105 | + 13798714324392902582#Word64
|
|
| 106 | + 3237499036029031497#Word64
|
|
| 107 | + T26615a.$trModule
|
|
| 108 | + $tcLeaf2
|
|
| 109 | + 0#
|
|
| 110 | + GHC.Internal.Types.krep$*->*->*
|
|
| 111 | + |
|
| 112 | +-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
|
|
| 113 | +$krep7 :: [GHC.Internal.Types.KindRep]
|
|
| 114 | +[GblId, Unf=OtherCon []]
|
|
| 115 | +$krep7
|
|
| 116 | + = GHC.Internal.Types.:
|
|
| 117 | + @GHC.Internal.Types.KindRep
|
|
| 118 | + $krep2
|
|
| 119 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 120 | + |
|
| 121 | +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
|
|
| 122 | +$krep8 :: [GHC.Internal.Types.KindRep]
|
|
| 123 | +[GblId, Unf=OtherCon []]
|
|
| 124 | +$krep8
|
|
| 125 | + = GHC.Internal.Types.: @GHC.Internal.Types.KindRep $krep3 $krep7
|
|
| 126 | + |
|
| 127 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 128 | +$krep9 :: GHC.Internal.Types.KindRep
|
|
| 129 | +[GblId, Unf=OtherCon []]
|
|
| 130 | +$krep9 = GHC.Internal.Types.KindRepTyConApp T26615a.$tcLeaf $krep8
|
|
| 131 | + |
|
| 132 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 133 | +$krep10 :: GHC.Internal.Types.KindRep
|
|
| 134 | +[GblId, Unf=OtherCon []]
|
|
| 135 | +$krep10 = GHC.Internal.Types.KindRepFun $krep2 $krep9
|
|
| 136 | + |
|
| 137 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 138 | +$krep11 :: GHC.Internal.Types.KindRep
|
|
| 139 | +[GblId, Unf=OtherCon []]
|
|
| 140 | +$krep11 = GHC.Internal.Types.KindRepFun $krep3 $krep10
|
|
| 141 | + |
|
| 142 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 143 | +$tc'L1 :: Addr#
|
|
| 144 | +[GblId, Unf=OtherCon []]
|
|
| 145 | +$tc'L1 = "'L"#
|
|
| 146 | + |
|
| 147 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 148 | +$tc'L2 :: GHC.Internal.Types.TrName
|
|
| 149 | +[GblId, Unf=OtherCon []]
|
|
| 150 | +$tc'L2 = GHC.Internal.Types.TrNameS $tc'L1
|
|
| 151 | + |
|
| 152 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 153 | +T26615a.$tc'L [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 154 | +[GblId, Unf=OtherCon []]
|
|
| 155 | +T26615a.$tc'L
|
|
| 156 | + = GHC.Internal.Types.TyCon
|
|
| 157 | + 8570419491837374712#Word64
|
|
| 158 | + 2090006989092642392#Word64
|
|
| 159 | + T26615a.$trModule
|
|
| 160 | + $tc'L2
|
|
| 161 | + 2#
|
|
| 162 | + $krep11
|
|
| 163 | + |
|
| 164 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 165 | +$tcArray1 :: Addr#
|
|
| 166 | +[GblId, Unf=OtherCon []]
|
|
| 167 | +$tcArray1 = "Array"#
|
|
| 168 | + |
|
| 169 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 170 | +$tcArray2 :: GHC.Internal.Types.TrName
|
|
| 171 | +[GblId, Unf=OtherCon []]
|
|
| 172 | +$tcArray2 = GHC.Internal.Types.TrNameS $tcArray1
|
|
| 173 | + |
|
| 174 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 175 | +T26615a.$tcArray [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 176 | +[GblId, Unf=OtherCon []]
|
|
| 177 | +T26615a.$tcArray
|
|
| 178 | + = GHC.Internal.Types.TyCon
|
|
| 179 | + 10495761415291712389#Word64
|
|
| 180 | + 7580086293698619153#Word64
|
|
| 181 | + T26615a.$trModule
|
|
| 182 | + $tcArray2
|
|
| 183 | + 0#
|
|
| 184 | + GHC.Internal.Types.krep$*Arr*
|
|
| 185 | + |
|
| 186 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 187 | +$krep12 :: GHC.Internal.Types.KindRep
|
|
| 188 | +[GblId, Unf=OtherCon []]
|
|
| 189 | +$krep12
|
|
| 190 | + = GHC.Internal.Types.KindRepTyConApp T26615a.$tcArray $krep4
|
|
| 191 | + |
|
| 192 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 193 | +$krep13 :: GHC.Internal.Types.KindRep
|
|
| 194 | +[GblId, Unf=OtherCon []]
|
|
| 195 | +$krep13 = GHC.Internal.Types.KindRepFun $krep6 $krep12
|
|
| 196 | + |
|
| 197 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 198 | +$tc'Array1 :: Addr#
|
|
| 199 | +[GblId, Unf=OtherCon []]
|
|
| 200 | +$tc'Array1 = "'Array"#
|
|
| 201 | + |
|
| 202 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 203 | +$tc'Array2 :: GHC.Internal.Types.TrName
|
|
| 204 | +[GblId, Unf=OtherCon []]
|
|
| 205 | +$tc'Array2 = GHC.Internal.Types.TrNameS $tc'Array1
|
|
| 206 | + |
|
| 207 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 208 | +T26615a.$tc'Array [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 209 | +[GblId, Unf=OtherCon []]
|
|
| 210 | +T26615a.$tc'Array
|
|
| 211 | + = GHC.Internal.Types.TyCon
|
|
| 212 | + 12424115309881832159#Word64
|
|
| 213 | + 15542868641947707803#Word64
|
|
| 214 | + T26615a.$trModule
|
|
| 215 | + $tc'Array2
|
|
| 216 | + 1#
|
|
| 217 | + $krep13
|
|
| 218 | + |
|
| 219 | +-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
|
|
| 220 | +$krep14 :: [GHC.Internal.Types.KindRep]
|
|
| 221 | +[GblId, Unf=OtherCon []]
|
|
| 222 | +$krep14
|
|
| 223 | + = GHC.Internal.Types.:
|
|
| 224 | + @GHC.Internal.Types.KindRep
|
|
| 225 | + $krep9
|
|
| 226 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 227 | + |
|
| 228 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 229 | +$krep15 :: GHC.Internal.Types.KindRep
|
|
| 230 | +[GblId, Unf=OtherCon []]
|
|
| 231 | +$krep15
|
|
| 232 | + = GHC.Internal.Types.KindRepTyConApp T26615a.$tcArray $krep14
|
|
| 233 | + |
|
| 234 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 235 | +$tcHashMap1 :: Addr#
|
|
| 236 | +[GblId, Unf=OtherCon []]
|
|
| 237 | +$tcHashMap1 = "HashMap"#
|
|
| 238 | + |
|
| 239 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 240 | +$tcHashMap2 :: GHC.Internal.Types.TrName
|
|
| 241 | +[GblId, Unf=OtherCon []]
|
|
| 242 | +$tcHashMap2 = GHC.Internal.Types.TrNameS $tcHashMap1
|
|
| 243 | + |
|
| 244 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 245 | +T26615a.$tcHashMap [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 246 | +[GblId, Unf=OtherCon []]
|
|
| 247 | +T26615a.$tcHashMap
|
|
| 248 | + = GHC.Internal.Types.TyCon
|
|
| 249 | + 2021755758654901686#Word64
|
|
| 250 | + 8209241086311595496#Word64
|
|
| 251 | + T26615a.$trModule
|
|
| 252 | + $tcHashMap2
|
|
| 253 | + 0#
|
|
| 254 | + GHC.Internal.Types.krep$*->*->*
|
|
| 255 | + |
|
| 256 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 257 | +$krep16 :: GHC.Internal.Types.KindRep
|
|
| 258 | +[GblId, Unf=OtherCon []]
|
|
| 259 | +$krep16
|
|
| 260 | + = GHC.Internal.Types.KindRepTyConApp T26615a.$tcHashMap $krep8
|
|
| 261 | + |
|
| 262 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 263 | +$tc'Empty1 :: Addr#
|
|
| 264 | +[GblId, Unf=OtherCon []]
|
|
| 265 | +$tc'Empty1 = "'Empty"#
|
|
| 266 | + |
|
| 267 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 268 | +$tc'Empty2 :: GHC.Internal.Types.TrName
|
|
| 269 | +[GblId, Unf=OtherCon []]
|
|
| 270 | +$tc'Empty2 = GHC.Internal.Types.TrNameS $tc'Empty1
|
|
| 271 | + |
|
| 272 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 273 | +T26615a.$tc'Empty [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 274 | +[GblId, Unf=OtherCon []]
|
|
| 275 | +T26615a.$tc'Empty
|
|
| 276 | + = GHC.Internal.Types.TyCon
|
|
| 277 | + 2520556399233147460#Word64
|
|
| 278 | + 17224648764450205443#Word64
|
|
| 279 | + T26615a.$trModule
|
|
| 280 | + $tc'Empty2
|
|
| 281 | + 2#
|
|
| 282 | + $krep16
|
|
| 283 | + |
|
| 284 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 285 | +$krep17 :: GHC.Internal.Types.KindRep
|
|
| 286 | +[GblId, Unf=OtherCon []]
|
|
| 287 | +$krep17 = GHC.Internal.Types.KindRepFun $krep9 $krep16
|
|
| 288 | + |
|
| 289 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 290 | +$krep18 :: GHC.Internal.Types.KindRep
|
|
| 291 | +[GblId, Unf=OtherCon []]
|
|
| 292 | +$krep18 = GHC.Internal.Types.KindRepFun $krep1 $krep17
|
|
| 293 | + |
|
| 294 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 295 | +$tc'Leaf1 :: Addr#
|
|
| 296 | +[GblId, Unf=OtherCon []]
|
|
| 297 | +$tc'Leaf1 = "'Leaf"#
|
|
| 298 | + |
|
| 299 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 300 | +$tc'Leaf2 :: GHC.Internal.Types.TrName
|
|
| 301 | +[GblId, Unf=OtherCon []]
|
|
| 302 | +$tc'Leaf2 = GHC.Internal.Types.TrNameS $tc'Leaf1
|
|
| 303 | + |
|
| 304 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 305 | +T26615a.$tc'Leaf [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 306 | +[GblId, Unf=OtherCon []]
|
|
| 307 | +T26615a.$tc'Leaf
|
|
| 308 | + = GHC.Internal.Types.TyCon
|
|
| 309 | + 5773656560257991946#Word64
|
|
| 310 | + 17028074687139582545#Word64
|
|
| 311 | + T26615a.$trModule
|
|
| 312 | + $tc'Leaf2
|
|
| 313 | + 2#
|
|
| 314 | + $krep18
|
|
| 315 | + |
|
| 316 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 317 | +$krep19 :: GHC.Internal.Types.KindRep
|
|
| 318 | +[GblId, Unf=OtherCon []]
|
|
| 319 | +$krep19 = GHC.Internal.Types.KindRepFun $krep15 $krep16
|
|
| 320 | + |
|
| 321 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 322 | +$krep20 :: GHC.Internal.Types.KindRep
|
|
| 323 | +[GblId, Unf=OtherCon []]
|
|
| 324 | +$krep20 = GHC.Internal.Types.KindRepFun $krep1 $krep19
|
|
| 325 | + |
|
| 326 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 327 | +$tc'Collision1 :: Addr#
|
|
| 328 | +[GblId, Unf=OtherCon []]
|
|
| 329 | +$tc'Collision1 = "'Collision"#
|
|
| 330 | + |
|
| 331 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 332 | +$tc'Collision2 :: GHC.Internal.Types.TrName
|
|
| 333 | +[GblId, Unf=OtherCon []]
|
|
| 334 | +$tc'Collision2 = GHC.Internal.Types.TrNameS $tc'Collision1
|
|
| 335 | + |
|
| 336 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 337 | +T26615a.$tc'Collision [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 338 | +[GblId, Unf=OtherCon []]
|
|
| 339 | +T26615a.$tc'Collision
|
|
| 340 | + = GHC.Internal.Types.TyCon
|
|
| 341 | + 18175105753528304021#Word64
|
|
| 342 | + 13986842878006680511#Word64
|
|
| 343 | + T26615a.$trModule
|
|
| 344 | + $tc'Collision2
|
|
| 345 | + 2#
|
|
| 346 | + $krep20
|
|
| 347 | + |
|
| 348 | +-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
|
|
| 349 | +$krep21 :: [GHC.Internal.Types.KindRep]
|
|
| 350 | +[GblId, Unf=OtherCon []]
|
|
| 351 | +$krep21
|
|
| 352 | + = GHC.Internal.Types.:
|
|
| 353 | + @GHC.Internal.Types.KindRep
|
|
| 354 | + $krep16
|
|
| 355 | + (GHC.Internal.Types.[] @GHC.Internal.Types.KindRep)
|
|
| 356 | + |
|
| 357 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 358 | +$krep22 :: GHC.Internal.Types.KindRep
|
|
| 359 | +[GblId, Unf=OtherCon []]
|
|
| 360 | +$krep22
|
|
| 361 | + = GHC.Internal.Types.KindRepTyConApp T26615a.$tcArray $krep21
|
|
| 362 | + |
|
| 363 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 364 | +$krep23 :: GHC.Internal.Types.KindRep
|
|
| 365 | +[GblId, Unf=OtherCon []]
|
|
| 366 | +$krep23 = GHC.Internal.Types.KindRepFun $krep22 $krep16
|
|
| 367 | + |
|
| 368 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 369 | +$tc'Full1 :: Addr#
|
|
| 370 | +[GblId, Unf=OtherCon []]
|
|
| 371 | +$tc'Full1 = "'Full"#
|
|
| 372 | + |
|
| 373 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 374 | +$tc'Full2 :: GHC.Internal.Types.TrName
|
|
| 375 | +[GblId, Unf=OtherCon []]
|
|
| 376 | +$tc'Full2 = GHC.Internal.Types.TrNameS $tc'Full1
|
|
| 377 | + |
|
| 378 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 379 | +T26615a.$tc'Full [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 380 | +[GblId, Unf=OtherCon []]
|
|
| 381 | +T26615a.$tc'Full
|
|
| 382 | + = GHC.Internal.Types.TyCon
|
|
| 383 | + 12008762105994325570#Word64
|
|
| 384 | + 13514145886440831186#Word64
|
|
| 385 | + T26615a.$trModule
|
|
| 386 | + $tc'Full2
|
|
| 387 | + 2#
|
|
| 388 | + $krep23
|
|
| 389 | + |
|
| 390 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 391 | +$krep24 :: GHC.Internal.Types.KindRep
|
|
| 392 | +[GblId, Unf=OtherCon []]
|
|
| 393 | +$krep24 = GHC.Internal.Types.KindRepFun $krep1 $krep23
|
|
| 394 | + |
|
| 395 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 396 | +$tc'BitmapIndexed1 :: Addr#
|
|
| 397 | +[GblId, Unf=OtherCon []]
|
|
| 398 | +$tc'BitmapIndexed1 = "'BitmapIndexed"#
|
|
| 399 | + |
|
| 400 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 401 | +$tc'BitmapIndexed2 :: GHC.Internal.Types.TrName
|
|
| 402 | +[GblId, Unf=OtherCon []]
|
|
| 403 | +$tc'BitmapIndexed2 = GHC.Internal.Types.TrNameS $tc'BitmapIndexed1
|
|
| 404 | + |
|
| 405 | +-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
|
|
| 406 | +T26615a.$tc'BitmapIndexed [InlPrag=[~]] :: GHC.Internal.Types.TyCon
|
|
| 407 | +[GblId, Unf=OtherCon []]
|
|
| 408 | +T26615a.$tc'BitmapIndexed
|
|
| 409 | + = GHC.Internal.Types.TyCon
|
|
| 410 | + 15226751910432948177#Word64
|
|
| 411 | + 957331387129868915#Word64
|
|
| 412 | + T26615a.$trModule
|
|
| 413 | + $tc'BitmapIndexed2
|
|
| 414 | + 2#
|
|
| 415 | + $krep24
|
|
| 416 | + |
|
| 417 | +-- RHS size: {terms: 98, types: 109, coercions: 0, joins: 3/4}
|
|
| 418 | +T26615a.$wdisjointCollisions [InlPrag=INLINABLE[2]]
|
|
| 419 | + :: forall k a b.
|
|
| 420 | + Eq k =>
|
|
| 421 | + Word#
|
|
| 422 | + -> Array (Leaf k a) -> Word# -> SmallArray# (Leaf k b) -> Bool
|
|
| 423 | +[GblId[StrictWorker([~, ~, !])],
|
|
| 424 | + Arity=5,
|
|
| 425 | + Str=<LP(SC(S,C(1,L)),A)><L><1L><L><L>,
|
|
| 426 | + Unf=Unf{Src=StableUser, TopLvl=True,
|
|
| 427 | + Value=True, ConLike=True, WorkFree=True, Expandable=True,
|
|
| 428 | + Guidance=IF_ARGS [90 0 20 0 0] 406 10
|
|
| 429 | + Tmpl= \ (@k)
|
|
| 430 | + (@a)
|
|
| 431 | + (@b)
|
|
| 432 | + ($dEq :: Eq k)
|
|
| 433 | + (ww [Occ=Once1] :: Word#)
|
|
| 434 | + (aryA [Occ=Once1!] :: Array (Leaf k a))
|
|
| 435 | + (ww1 [Occ=Once1] :: Word#)
|
|
| 436 | + (ww2 :: SmallArray# (Leaf k b)) ->
|
|
| 437 | + case aryA of aryA1 [Occ=Once1] { Array ipv [Occ=Once1] ->
|
|
| 438 | + let {
|
|
| 439 | + aryB [Occ=OnceL1] :: Array (Leaf k b)
|
|
| 440 | + [LclId, Unf=OtherCon []]
|
|
| 441 | + aryB = T26615a.Array @(Leaf k b) ww2 } in
|
|
| 442 | + case GHC.Internal.Classes.eqWord
|
|
| 443 | + (GHC.Internal.Types.W# ww) (GHC.Internal.Types.W# ww1)
|
|
| 444 | + of {
|
|
| 445 | + False -> GHC.Internal.Types.True;
|
|
| 446 | + True ->
|
|
| 447 | + joinrec {
|
|
| 448 | + foldr_ [Occ=LoopBreakerT[4]]
|
|
| 449 | + :: Array (Leaf k a) -> Int -> Int -> Bool -> Bool
|
|
| 450 | + [LclId[JoinId(4)(Nothing)],
|
|
| 451 | + Arity=4,
|
|
| 452 | + Str=<L><L><L><L>,
|
|
| 453 | + Unf=OtherCon []]
|
|
| 454 | + foldr_ (ary [Occ=Once1!] :: Array (Leaf k a))
|
|
| 455 | + (n :: Int)
|
|
| 456 | + (i :: Int)
|
|
| 457 | + (z [Occ=Once2] :: Bool)
|
|
| 458 | + = case GHC.Internal.Classes.geInt i n of {
|
|
| 459 | + False ->
|
|
| 460 | + case i of { I# i# ->
|
|
| 461 | + case ary of wild3 [Occ=Once1] { Array ds [Occ=Once1] ->
|
|
| 462 | + case indexSmallArray# @Lifted @(Leaf k a) ds i# of
|
|
| 463 | + { (# ipv1 [Occ=Once1!] #) ->
|
|
| 464 | + case ipv1 of { L kA [Occ=Once1] _ [Occ=Dead] ->
|
|
| 465 | + join {
|
|
| 466 | + $j [Occ=OnceL1T[0]] :: Bool
|
|
| 467 | + [LclId[JoinId(0)(Nothing)]]
|
|
| 468 | + $j = jump foldr_ wild3 n (GHC.Internal.Types.I# (+# i# 1#)) z } in
|
|
| 469 | + joinrec {
|
|
| 470 | + lookupInArrayCont_ [Occ=LoopBreakerT[5]]
|
|
| 471 | + :: Eq k => k -> Array (Leaf k b) -> Int -> Int -> Bool
|
|
| 472 | + [LclId[JoinId(5)(Nothing)],
|
|
| 473 | + Arity=5,
|
|
| 474 | + Str=<L><L><L><L><L>,
|
|
| 475 | + Unf=OtherCon []]
|
|
| 476 | + lookupInArrayCont_ ($dEq1 [Occ=Dead] :: Eq k)
|
|
| 477 | + (k1 [Occ=Once1] :: k)
|
|
| 478 | + (ary1 [Occ=Once1!] :: Array (Leaf k b))
|
|
| 479 | + (i1 [Occ=Once1!] :: Int)
|
|
| 480 | + (n1 [Occ=Once1!] :: Int)
|
|
| 481 | + = case k1 of k2 { __DEFAULT ->
|
|
| 482 | + case ary1 of ary2 [Occ=Once1] { Array ipv2 [Occ=Once1] ->
|
|
| 483 | + case i1 of i2 [Occ=Once1] { I# ipv3 ->
|
|
| 484 | + case n1 of n2 { I# _ [Occ=Dead] ->
|
|
| 485 | + case GHC.Internal.Classes.geInt i2 n2 of {
|
|
| 486 | + False ->
|
|
| 487 | + case indexSmallArray# @Lifted @(Leaf k b) ipv2 ipv3 of
|
|
| 488 | + { (# ipv5 [Occ=Once1!] #) ->
|
|
| 489 | + case ipv5 of { L kx [Occ=Once1] _ [Occ=Dead] ->
|
|
| 490 | + case == @k $dEq k2 kx of {
|
|
| 491 | + False ->
|
|
| 492 | + jump lookupInArrayCont_
|
|
| 493 | + $dEq k2 ary2 (GHC.Internal.Types.I# (+# ipv3 1#)) n2;
|
|
| 494 | + True -> GHC.Internal.Types.False
|
|
| 495 | + }
|
|
| 496 | + }
|
|
| 497 | + };
|
|
| 498 | + True -> jump $j
|
|
| 499 | + }
|
|
| 500 | + }
|
|
| 501 | + }
|
|
| 502 | + }
|
|
| 503 | + }; } in
|
|
| 504 | + jump lookupInArrayCont_
|
|
| 505 | + $dEq
|
|
| 506 | + kA
|
|
| 507 | + aryB
|
|
| 508 | + (GHC.Internal.Types.I# 0#)
|
|
| 509 | + (GHC.Internal.Types.I# (sizeofSmallArray# @Lifted @(Leaf k b) ww2))
|
|
| 510 | + }
|
|
| 511 | + }
|
|
| 512 | + }
|
|
| 513 | + };
|
|
| 514 | + True -> z
|
|
| 515 | + }; } in
|
|
| 516 | + jump foldr_
|
|
| 517 | + aryA1
|
|
| 518 | + (GHC.Internal.Types.I# (sizeofSmallArray# @Lifted @(Leaf k a) ipv))
|
|
| 519 | + (GHC.Internal.Types.I# 0#)
|
|
| 520 | + GHC.Internal.Types.True
|
|
| 521 | + }
|
|
| 522 | + }}]
|
|
| 523 | +T26615a.$wdisjointCollisions
|
|
| 524 | + = \ (@k)
|
|
| 525 | + (@a)
|
|
| 526 | + (@b)
|
|
| 527 | + ($dEq :: Eq k)
|
|
| 528 | + (ww :: Word#)
|
|
| 529 | + (aryA :: Array (Leaf k a))
|
|
| 530 | + (ww1 :: Word#)
|
|
| 531 | + (ww2 :: SmallArray# (Leaf k b)) ->
|
|
| 532 | + case aryA of { Array ipv ->
|
|
| 533 | + case eqWord# ww ww1 of {
|
|
| 534 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 535 | + 1# ->
|
|
| 536 | + let {
|
|
| 537 | + lvl2 :: Int#
|
|
| 538 | + [LclId]
|
|
| 539 | + lvl2 = sizeofSmallArray# @Lifted @(Leaf k b) ww2 } in
|
|
| 540 | + joinrec {
|
|
| 541 | + $s$wfoldr_ [InlPrag=[2],
|
|
| 542 | + Occ=LoopBreaker,
|
|
| 543 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 544 | + :: SmallArray# (Leaf k a) -> Int# -> Int# -> Bool -> Bool
|
|
| 545 | + [LclId[JoinId(4)(Nothing)],
|
|
| 546 | + Arity=4,
|
|
| 547 | + Str=<L><L><L><L>,
|
|
| 548 | + Unf=OtherCon []]
|
|
| 549 | + $s$wfoldr_ (sc :: SmallArray# (Leaf k a))
|
|
| 550 | + (sc1 :: Int#)
|
|
| 551 | + (sc2 :: Int#)
|
|
| 552 | + (sc3 :: Bool)
|
|
| 553 | + = case >=# sc2 sc1 of {
|
|
| 554 | + __DEFAULT ->
|
|
| 555 | + case indexSmallArray# @Lifted @(Leaf k a) sc sc2 of { (# ipv1 #) ->
|
|
| 556 | + case ipv1 of { L kA ds1 ->
|
|
| 557 | + join {
|
|
| 558 | + $j :: Bool
|
|
| 559 | + [LclId[JoinId(0)(Nothing)]]
|
|
| 560 | + $j = jump $s$wfoldr_ sc sc1 (+# sc2 1#) sc3 } in
|
|
| 561 | + joinrec {
|
|
| 562 | + $wlookupInArrayCont_ [InlPrag=[2],
|
|
| 563 | + Occ=LoopBreaker,
|
|
| 564 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 565 | + :: k -> SmallArray# (Leaf k b) -> Int# -> Int# -> Bool
|
|
| 566 | + [LclId[JoinId(4)(Just [!])],
|
|
| 567 | + Arity=4,
|
|
| 568 | + Str=<1L><L><L><L>,
|
|
| 569 | + Unf=OtherCon []]
|
|
| 570 | + $wlookupInArrayCont_ (k1 :: k)
|
|
| 571 | + (ww3 :: SmallArray# (Leaf k b))
|
|
| 572 | + (ww4 :: Int#)
|
|
| 573 | + (ww5 :: Int#)
|
|
| 574 | + = case k1 of k2 { __DEFAULT ->
|
|
| 575 | + case >=# ww4 ww5 of {
|
|
| 576 | + __DEFAULT ->
|
|
| 577 | + case indexSmallArray# @Lifted @(Leaf k b) ww3 ww4 of
|
|
| 578 | + { (# ipv2 #) ->
|
|
| 579 | + case ipv2 of { L kx v ->
|
|
| 580 | + case == @k $dEq k2 kx of {
|
|
| 581 | + False -> jump $wlookupInArrayCont_ k2 ww3 (+# ww4 1#) ww5;
|
|
| 582 | + True -> GHC.Internal.Types.False
|
|
| 583 | + }
|
|
| 584 | + }
|
|
| 585 | + };
|
|
| 586 | + 1# -> jump $j
|
|
| 587 | + }
|
|
| 588 | + }; } in
|
|
| 589 | + jump $wlookupInArrayCont_ kA ww2 0# lvl2
|
|
| 590 | + }
|
|
| 591 | + };
|
|
| 592 | + 1# -> sc3
|
|
| 593 | + }; } in
|
|
| 594 | + jump $s$wfoldr_
|
|
| 595 | + ipv
|
|
| 596 | + (sizeofSmallArray# @Lifted @(Leaf k a) ipv)
|
|
| 597 | + 0#
|
|
| 598 | + GHC.Internal.Types.True
|
|
| 599 | + }
|
|
| 600 | + }
|
|
| 601 | + |
|
| 602 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 603 | +lvl :: Addr#
|
|
| 604 | +[GblId, Unf=OtherCon []]
|
|
| 605 | +lvl = "T26615a.hs:(26,1)-(65,59)|function disjointSubtrees"#
|
|
| 606 | + |
|
| 607 | +-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
|
|
| 608 | +lvl1 :: ()
|
|
| 609 | +[GblId, Str=b, Cpr=b]
|
|
| 610 | +lvl1
|
|
| 611 | + = GHC.Internal.Control.Exception.Base.patError @LiftedRep @() lvl
|
|
| 612 | + |
|
| 613 | +Rec {
|
|
| 614 | +-- RHS size: {terms: 133, types: 126, coercions: 0, joins: 1/2}
|
|
| 615 | +T26615a.disjointSubtrees_$s$wdisjointSubtrees [InlPrag=INLINABLE[2],
|
|
| 616 | + Occ=LoopBreaker]
|
|
| 617 | + :: forall k a b.
|
|
| 618 | + Eq k =>
|
|
| 619 | + Int# -> Word# -> SmallArray# (Leaf k a) -> HashMap k b -> Bool
|
|
| 620 | +[GblId[StrictWorker([~, ~, ~, ~, !])],
|
|
| 621 | + Arity=5,
|
|
| 622 | + Str=<LP(SC(S,C(1,L)),A)><L><L><L><1L>,
|
|
| 623 | + Unf=OtherCon []]
|
|
| 624 | +T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 625 | + = \ (@k)
|
|
| 626 | + (@a)
|
|
| 627 | + (@b)
|
|
| 628 | + (sc :: Eq k)
|
|
| 629 | + (sc1 :: Int#)
|
|
| 630 | + (sc2 :: Word#)
|
|
| 631 | + (sc3 :: SmallArray# (Leaf k a))
|
|
| 632 | + (_b :: HashMap k b) ->
|
|
| 633 | + case _b of {
|
|
| 634 | + Empty -> GHC.Internal.Types.True;
|
|
| 635 | + Leaf bx ds ->
|
|
| 636 | + case ds of { L kB ds1 ->
|
|
| 637 | + case kB of k0 { __DEFAULT ->
|
|
| 638 | + case eqWord# bx sc2 of {
|
|
| 639 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 640 | + 1# ->
|
|
| 641 | + joinrec {
|
|
| 642 | + $wlookupInArrayCont_ [InlPrag=[2],
|
|
| 643 | + Occ=LoopBreaker,
|
|
| 644 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 645 | + :: k -> SmallArray# (Leaf k a) -> Int# -> Int# -> Bool
|
|
| 646 | + [LclId[JoinId(4)(Just [!])],
|
|
| 647 | + Arity=4,
|
|
| 648 | + Str=<1L><L><L><L>,
|
|
| 649 | + Unf=OtherCon []]
|
|
| 650 | + $wlookupInArrayCont_ (k1 :: k)
|
|
| 651 | + (ww :: SmallArray# (Leaf k a))
|
|
| 652 | + (ww1 :: Int#)
|
|
| 653 | + (ww2 :: Int#)
|
|
| 654 | + = case k1 of k2 { __DEFAULT ->
|
|
| 655 | + case >=# ww1 ww2 of {
|
|
| 656 | + __DEFAULT ->
|
|
| 657 | + case indexSmallArray# @Lifted @(Leaf k a) ww ww1 of { (# ipv #) ->
|
|
| 658 | + case ipv of { L kx v ->
|
|
| 659 | + case == @k sc k2 kx of {
|
|
| 660 | + False -> jump $wlookupInArrayCont_ k2 ww (+# ww1 1#) ww2;
|
|
| 661 | + True -> GHC.Internal.Types.False
|
|
| 662 | + }
|
|
| 663 | + }
|
|
| 664 | + };
|
|
| 665 | + 1# -> GHC.Internal.Types.True
|
|
| 666 | + }
|
|
| 667 | + }; } in
|
|
| 668 | + jump $wlookupInArrayCont_
|
|
| 669 | + k0 sc3 0# (sizeofSmallArray# @Lifted @(Leaf k a) sc3)
|
|
| 670 | + }
|
|
| 671 | + }
|
|
| 672 | + };
|
|
| 673 | + Collision bx bx1 ->
|
|
| 674 | + T26615a.$wdisjointCollisions
|
|
| 675 | + @k @a @b sc sc2 (T26615a.Array @(Leaf k a) sc3) bx bx1;
|
|
| 676 | + BitmapIndexed bx bx1 ->
|
|
| 677 | + let {
|
|
| 678 | + m :: Word#
|
|
| 679 | + [LclId]
|
|
| 680 | + m = uncheckedShiftL#
|
|
| 681 | + 1## (word2Int# (and# (uncheckedShiftRL# sc2 sc1) 31##)) } in
|
|
| 682 | + case and# m bx of {
|
|
| 683 | + __DEFAULT ->
|
|
| 684 | + case indexSmallArray#
|
|
| 685 | + @Lifted
|
|
| 686 | + @(HashMap k b)
|
|
| 687 | + bx1
|
|
| 688 | + (word2Int# (popCnt# (and# bx (minusWord# m 1##))))
|
|
| 689 | + of
|
|
| 690 | + { (# ipv #) ->
|
|
| 691 | + T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 692 | + @k @a @b sc (+# sc1 5#) sc2 sc3 ipv
|
|
| 693 | + };
|
|
| 694 | + 0## -> GHC.Internal.Types.True
|
|
| 695 | + };
|
|
| 696 | + Full bx ->
|
|
| 697 | + case indexSmallArray#
|
|
| 698 | + @Lifted
|
|
| 699 | + @(HashMap k b)
|
|
| 700 | + bx
|
|
| 701 | + (word2Int# (and# (uncheckedShiftRL# sc2 sc1) 31##))
|
|
| 702 | + of
|
|
| 703 | + { (# ipv #) ->
|
|
| 704 | + T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 705 | + @k @a @b sc (+# sc1 5#) sc2 sc3 ipv
|
|
| 706 | + }
|
|
| 707 | + }
|
|
| 708 | +end Rec }
|
|
| 709 | + |
|
| 710 | +Rec {
|
|
| 711 | +-- RHS size: {terms: 705, types: 748, coercions: 18, joins: 13/23}
|
|
| 712 | +T26615a.$wdisjointSubtrees [InlPrag=INLINABLE[2], Occ=LoopBreaker]
|
|
| 713 | + :: forall k a b. Eq k => Int# -> HashMap k a -> HashMap k b -> Bool
|
|
| 714 | +[GblId[StrictWorker([~, ~, !])],
|
|
| 715 | + Arity=4,
|
|
| 716 | + Str=<LP(LC(L,C(1,L)),LC(S,C(1,L)))><L><SL><L>,
|
|
| 717 | + Unf=Unf{Src=StableUser, TopLvl=True,
|
|
| 718 | + Value=True, ConLike=True, WorkFree=True, Expandable=True,
|
|
| 719 | + Guidance=NEVER
|
|
| 720 | + Tmpl= \ (@k)
|
|
| 721 | + (@a)
|
|
| 722 | + (@b)
|
|
| 723 | + ($dEq :: Eq k)
|
|
| 724 | + (ww :: Int#)
|
|
| 725 | + (ds :: HashMap k a)
|
|
| 726 | + (_b :: HashMap k b) ->
|
|
| 727 | + join {
|
|
| 728 | + fail [Occ=Once3!T[1]] :: (# #) -> Bool
|
|
| 729 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 730 | + fail (ds1 [Occ=Dead, OS=OneShot] :: (# #))
|
|
| 731 | + = case _b of wild [Occ=Once1] {
|
|
| 732 | + __DEFAULT ->
|
|
| 733 | + case GHC.Internal.Control.Exception.Base.patError
|
|
| 734 | + @LiftedRep
|
|
| 735 | + @()
|
|
| 736 | + "T26615a.hs:(26,1)-(65,59)|function disjointSubtrees"#
|
|
| 737 | + of {};
|
|
| 738 | + Empty -> GHC.Internal.Types.True;
|
|
| 739 | + Leaf bx [Occ=Once1] ds2 [Occ=Once1!] ->
|
|
| 740 | + case ds2 of { L kB [Occ=Once1] _ [Occ=Dead] ->
|
|
| 741 | + case kB of k0 [Occ=Once1] { __DEFAULT ->
|
|
| 742 | + joinrec {
|
|
| 743 | + lookupCont_ [Occ=LoopBreakerT[5]]
|
|
| 744 | + :: Eq k => Word -> k -> Int -> HashMap k a -> Bool
|
|
| 745 | + [LclId[JoinId(5)(Nothing)],
|
|
| 746 | + Arity=5,
|
|
| 747 | + Str=<L><L><L><L><L>,
|
|
| 748 | + Unf=OtherCon []]
|
|
| 749 | + lookupCont_ ($dEq1 [Occ=Dead] :: Eq k)
|
|
| 750 | + (ds4 [Occ=Once1!] :: Word)
|
|
| 751 | + (ds5 [Occ=Once1] :: k)
|
|
| 752 | + (ds6 [Occ=Once1!] :: Int)
|
|
| 753 | + (ds7 [Occ=Once1!] :: HashMap k a)
|
|
| 754 | + = case ds4 of ds8 [Occ=Once4] { W# ipv [Occ=Once2] ->
|
|
| 755 | + case ds5 of ds9 [Occ=Once4] { __DEFAULT ->
|
|
| 756 | + case ds6 of { I# ipv1 ->
|
|
| 757 | + case ds7 of {
|
|
| 758 | + Empty -> GHC.Internal.Types.True;
|
|
| 759 | + Leaf bx1 [Occ=Once1] ds11 [Occ=Once1!] ->
|
|
| 760 | + case ds11 of { L kx [Occ=Once1] _ [Occ=Dead] ->
|
|
| 761 | + case GHC.Internal.Classes.eqWord
|
|
| 762 | + ds8 (GHC.Internal.Types.W# bx1)
|
|
| 763 | + of {
|
|
| 764 | + False -> GHC.Internal.Types.True;
|
|
| 765 | + True ->
|
|
| 766 | + case == @k $dEq ds9 kx of {
|
|
| 767 | + False -> GHC.Internal.Types.True;
|
|
| 768 | + True -> GHC.Internal.Types.False
|
|
| 769 | + }
|
|
| 770 | + }
|
|
| 771 | + };
|
|
| 772 | + Collision bx1 [Occ=Once1] bx2 ->
|
|
| 773 | + case GHC.Internal.Classes.eqWord
|
|
| 774 | + ds8 (GHC.Internal.Types.W# bx1)
|
|
| 775 | + of {
|
|
| 776 | + False -> GHC.Internal.Types.True;
|
|
| 777 | + True ->
|
|
| 778 | + joinrec {
|
|
| 779 | + lookupInArrayCont_ [Occ=LoopBreakerT[5]]
|
|
| 780 | + :: Eq k => k -> Array (Leaf k a) -> Int -> Int -> Bool
|
|
| 781 | + [LclId[JoinId(5)(Nothing)],
|
|
| 782 | + Arity=5,
|
|
| 783 | + Str=<L><L><L><L><L>,
|
|
| 784 | + Unf=OtherCon []]
|
|
| 785 | + lookupInArrayCont_ ($dEq2 [Occ=Dead] :: Eq k)
|
|
| 786 | + (k1 [Occ=Once1] :: k)
|
|
| 787 | + (ary [Occ=Once1!] :: Array (Leaf k a))
|
|
| 788 | + (i [Occ=Once1!] :: Int)
|
|
| 789 | + (n [Occ=Once1!] :: Int)
|
|
| 790 | + = case k1 of k2 { __DEFAULT ->
|
|
| 791 | + case ary of ary1 [Occ=Once1]
|
|
| 792 | + { Array ipv2 [Occ=Once1] ->
|
|
| 793 | + case i of i1 [Occ=Once1] { I# ipv3 ->
|
|
| 794 | + case n of n1 { I# _ [Occ=Dead] ->
|
|
| 795 | + case GHC.Internal.Classes.geInt i1 n1 of {
|
|
| 796 | + False ->
|
|
| 797 | + case indexSmallArray#
|
|
| 798 | + @Lifted @(Leaf k a) ipv2 ipv3
|
|
| 799 | + of
|
|
| 800 | + { (# ipv5 [Occ=Once1!] #) ->
|
|
| 801 | + case ipv5 of { L kx [Occ=Once1] _ [Occ=Dead] ->
|
|
| 802 | + case == @k $dEq k2 kx of {
|
|
| 803 | + False ->
|
|
| 804 | + jump lookupInArrayCont_
|
|
| 805 | + $dEq
|
|
| 806 | + k2
|
|
| 807 | + ary1
|
|
| 808 | + (GHC.Internal.Types.I# (+# ipv3 1#))
|
|
| 809 | + n1;
|
|
| 810 | + True -> GHC.Internal.Types.False
|
|
| 811 | + }
|
|
| 812 | + }
|
|
| 813 | + };
|
|
| 814 | + True -> GHC.Internal.Types.True
|
|
| 815 | + }
|
|
| 816 | + }
|
|
| 817 | + }
|
|
| 818 | + }
|
|
| 819 | + }; } in
|
|
| 820 | + jump lookupInArrayCont_
|
|
| 821 | + $dEq
|
|
| 822 | + ds9
|
|
| 823 | + (T26615a.Array @(Leaf k a) bx2)
|
|
| 824 | + (GHC.Internal.Types.I# 0#)
|
|
| 825 | + (GHC.Internal.Types.I#
|
|
| 826 | + (sizeofSmallArray# @Lifted @(Leaf k a) bx2))
|
|
| 827 | + };
|
|
| 828 | + BitmapIndexed bx1 bx2 [Occ=Once1] ->
|
|
| 829 | + let {
|
|
| 830 | + m :: Word#
|
|
| 831 | + [LclId]
|
|
| 832 | + m = uncheckedShiftL#
|
|
| 833 | + 1##
|
|
| 834 | + (word2Int#
|
|
| 835 | + (and# (uncheckedShiftRL# ipv ipv1) 31##)) } in
|
|
| 836 | + case GHC.Internal.Classes.eqWord
|
|
| 837 | + (GHC.Internal.Types.W# (and# bx1 m))
|
|
| 838 | + (GHC.Internal.Types.W# 0##)
|
|
| 839 | + of {
|
|
| 840 | + False ->
|
|
| 841 | + case indexSmallArray#
|
|
| 842 | + @Lifted
|
|
| 843 | + @(HashMap k a)
|
|
| 844 | + bx2
|
|
| 845 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 846 | + of
|
|
| 847 | + { (# ipv2 [Occ=Once1] #) ->
|
|
| 848 | + jump lookupCont_
|
|
| 849 | + $dEq ds8 ds9 (GHC.Internal.Types.I# (+# ipv1 5#)) ipv2
|
|
| 850 | + };
|
|
| 851 | + True -> GHC.Internal.Types.True
|
|
| 852 | + };
|
|
| 853 | + Full bx1 [Occ=Once1] ->
|
|
| 854 | + case indexSmallArray#
|
|
| 855 | + @Lifted
|
|
| 856 | + @(HashMap k a)
|
|
| 857 | + bx1
|
|
| 858 | + (word2Int# (and# (uncheckedShiftRL# ipv ipv1) 31##))
|
|
| 859 | + of
|
|
| 860 | + { (# ipv2 [Occ=Once1] #) ->
|
|
| 861 | + jump lookupCont_
|
|
| 862 | + $dEq ds8 ds9 (GHC.Internal.Types.I# (+# ipv1 5#)) ipv2
|
|
| 863 | + }
|
|
| 864 | + }
|
|
| 865 | + }
|
|
| 866 | + }
|
|
| 867 | + }; } in
|
|
| 868 | + jump lookupCont_
|
|
| 869 | + $dEq (GHC.Internal.Types.W# bx) k0 (GHC.Internal.Types.I# ww) ds
|
|
| 870 | + }
|
|
| 871 | + };
|
|
| 872 | + Collision _ [Occ=Dead] _ [Occ=Dead] ->
|
|
| 873 | + T26615a.$wdisjointSubtrees @k @b @a $dEq ww wild ds
|
|
| 874 | + } } in
|
|
| 875 | + case ds of wild [Occ=Once2] {
|
|
| 876 | + Empty -> GHC.Internal.Types.True;
|
|
| 877 | + Leaf bx [Occ=Once2] ds1 [Occ=Once1!] ->
|
|
| 878 | + case ds1 of { L kA [Occ=Once2] _ [Occ=Dead] ->
|
|
| 879 | + case _b of wild2 [Occ=Once1] {
|
|
| 880 | + __DEFAULT ->
|
|
| 881 | + case kA of k0 [Occ=Once1] { __DEFAULT ->
|
|
| 882 | + joinrec {
|
|
| 883 | + lookupCont_ [Occ=LoopBreakerT[5]]
|
|
| 884 | + :: Eq k => Word -> k -> Int -> HashMap k b -> Bool
|
|
| 885 | + [LclId[JoinId(5)(Nothing)],
|
|
| 886 | + Arity=5,
|
|
| 887 | + Str=<L><L><L><L><L>,
|
|
| 888 | + Unf=OtherCon []]
|
|
| 889 | + lookupCont_ ($dEq1 [Occ=Dead] :: Eq k)
|
|
| 890 | + (ds3 [Occ=Once1!] :: Word)
|
|
| 891 | + (ds4 [Occ=Once1] :: k)
|
|
| 892 | + (ds5 [Occ=Once1!] :: Int)
|
|
| 893 | + (ds6 [Occ=Once1!] :: HashMap k b)
|
|
| 894 | + = case ds3 of ds7 [Occ=Once4] { W# ipv [Occ=Once2] ->
|
|
| 895 | + case ds4 of ds8 [Occ=Once4] { __DEFAULT ->
|
|
| 896 | + case ds5 of { I# ipv1 ->
|
|
| 897 | + case ds6 of {
|
|
| 898 | + Empty -> GHC.Internal.Types.True;
|
|
| 899 | + Leaf bx1 [Occ=Once1] ds10 [Occ=Once1!] ->
|
|
| 900 | + case ds10 of { L kx [Occ=Once1] _ [Occ=Dead] ->
|
|
| 901 | + case GHC.Internal.Classes.eqWord ds7 (GHC.Internal.Types.W# bx1)
|
|
| 902 | + of {
|
|
| 903 | + False -> GHC.Internal.Types.True;
|
|
| 904 | + True ->
|
|
| 905 | + case == @k $dEq ds8 kx of {
|
|
| 906 | + False -> GHC.Internal.Types.True;
|
|
| 907 | + True -> GHC.Internal.Types.False
|
|
| 908 | + }
|
|
| 909 | + }
|
|
| 910 | + };
|
|
| 911 | + Collision bx1 [Occ=Once1] bx2 ->
|
|
| 912 | + case GHC.Internal.Classes.eqWord ds7 (GHC.Internal.Types.W# bx1)
|
|
| 913 | + of {
|
|
| 914 | + False -> GHC.Internal.Types.True;
|
|
| 915 | + True ->
|
|
| 916 | + joinrec {
|
|
| 917 | + lookupInArrayCont_ [Occ=LoopBreakerT[5]]
|
|
| 918 | + :: Eq k => k -> Array (Leaf k b) -> Int -> Int -> Bool
|
|
| 919 | + [LclId[JoinId(5)(Nothing)],
|
|
| 920 | + Arity=5,
|
|
| 921 | + Str=<L><L><L><L><L>,
|
|
| 922 | + Unf=OtherCon []]
|
|
| 923 | + lookupInArrayCont_ ($dEq2 [Occ=Dead] :: Eq k)
|
|
| 924 | + (k1 [Occ=Once1] :: k)
|
|
| 925 | + (ary [Occ=Once1!] :: Array (Leaf k b))
|
|
| 926 | + (i [Occ=Once1!] :: Int)
|
|
| 927 | + (n [Occ=Once1!] :: Int)
|
|
| 928 | + = case k1 of k2 { __DEFAULT ->
|
|
| 929 | + case ary of ary1 [Occ=Once1]
|
|
| 930 | + { Array ipv2 [Occ=Once1] ->
|
|
| 931 | + case i of i1 [Occ=Once1] { I# ipv3 ->
|
|
| 932 | + case n of n1 { I# _ [Occ=Dead] ->
|
|
| 933 | + case GHC.Internal.Classes.geInt i1 n1 of {
|
|
| 934 | + False ->
|
|
| 935 | + case indexSmallArray# @Lifted @(Leaf k b) ipv2 ipv3
|
|
| 936 | + of
|
|
| 937 | + { (# ipv5 [Occ=Once1!] #) ->
|
|
| 938 | + case ipv5 of { L kx [Occ=Once1] _ [Occ=Dead] ->
|
|
| 939 | + case == @k $dEq k2 kx of {
|
|
| 940 | + False ->
|
|
| 941 | + jump lookupInArrayCont_
|
|
| 942 | + $dEq
|
|
| 943 | + k2
|
|
| 944 | + ary1
|
|
| 945 | + (GHC.Internal.Types.I# (+# ipv3 1#))
|
|
| 946 | + n1;
|
|
| 947 | + True -> GHC.Internal.Types.False
|
|
| 948 | + }
|
|
| 949 | + }
|
|
| 950 | + };
|
|
| 951 | + True -> GHC.Internal.Types.True
|
|
| 952 | + }
|
|
| 953 | + }
|
|
| 954 | + }
|
|
| 955 | + }
|
|
| 956 | + }; } in
|
|
| 957 | + jump lookupInArrayCont_
|
|
| 958 | + $dEq
|
|
| 959 | + ds8
|
|
| 960 | + (T26615a.Array @(Leaf k b) bx2)
|
|
| 961 | + (GHC.Internal.Types.I# 0#)
|
|
| 962 | + (GHC.Internal.Types.I#
|
|
| 963 | + (sizeofSmallArray# @Lifted @(Leaf k b) bx2))
|
|
| 964 | + };
|
|
| 965 | + BitmapIndexed bx1 bx2 [Occ=Once1] ->
|
|
| 966 | + let {
|
|
| 967 | + m :: Word#
|
|
| 968 | + [LclId]
|
|
| 969 | + m = uncheckedShiftL#
|
|
| 970 | + 1##
|
|
| 971 | + (word2Int# (and# (uncheckedShiftRL# ipv ipv1) 31##)) } in
|
|
| 972 | + case GHC.Internal.Classes.eqWord
|
|
| 973 | + (GHC.Internal.Types.W# (and# bx1 m))
|
|
| 974 | + (GHC.Internal.Types.W# 0##)
|
|
| 975 | + of {
|
|
| 976 | + False ->
|
|
| 977 | + case indexSmallArray#
|
|
| 978 | + @Lifted
|
|
| 979 | + @(HashMap k b)
|
|
| 980 | + bx2
|
|
| 981 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 982 | + of
|
|
| 983 | + { (# ipv2 [Occ=Once1] #) ->
|
|
| 984 | + jump lookupCont_
|
|
| 985 | + $dEq ds7 ds8 (GHC.Internal.Types.I# (+# ipv1 5#)) ipv2
|
|
| 986 | + };
|
|
| 987 | + True -> GHC.Internal.Types.True
|
|
| 988 | + };
|
|
| 989 | + Full bx1 [Occ=Once1] ->
|
|
| 990 | + case indexSmallArray#
|
|
| 991 | + @Lifted
|
|
| 992 | + @(HashMap k b)
|
|
| 993 | + bx1
|
|
| 994 | + (word2Int# (and# (uncheckedShiftRL# ipv ipv1) 31##))
|
|
| 995 | + of
|
|
| 996 | + { (# ipv2 [Occ=Once1] #) ->
|
|
| 997 | + jump lookupCont_
|
|
| 998 | + $dEq ds7 ds8 (GHC.Internal.Types.I# (+# ipv1 5#)) ipv2
|
|
| 999 | + }
|
|
| 1000 | + }
|
|
| 1001 | + }
|
|
| 1002 | + }
|
|
| 1003 | + }; } in
|
|
| 1004 | + jump lookupCont_
|
|
| 1005 | + $dEq (GHC.Internal.Types.W# bx) k0 (GHC.Internal.Types.I# ww) wild2
|
|
| 1006 | + };
|
|
| 1007 | + Leaf bx1 [Occ=Once1] ds3 [Occ=Once1!] ->
|
|
| 1008 | + case ds3 of { L kB [Occ=Once1] _ [Occ=Dead] ->
|
|
| 1009 | + case GHC.Internal.Classes.neWord
|
|
| 1010 | + (GHC.Internal.Types.W# bx) (GHC.Internal.Types.W# bx1)
|
|
| 1011 | + of {
|
|
| 1012 | + False -> /= @k $dEq kA kB;
|
|
| 1013 | + True -> GHC.Internal.Types.True
|
|
| 1014 | + }
|
|
| 1015 | + }
|
|
| 1016 | + }
|
|
| 1017 | + };
|
|
| 1018 | + Collision bx [Occ=Once3] bx1 [Occ=Once1] ->
|
|
| 1019 | + case _b of {
|
|
| 1020 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1021 | + Collision bx2 [Occ=Once1] bx3 [Occ=Once1] ->
|
|
| 1022 | + T26615a.$wdisjointCollisions
|
|
| 1023 | + @k @a @b $dEq bx (T26615a.Array @(Leaf k a) bx1) bx2 bx3;
|
|
| 1024 | + BitmapIndexed bx2 bx3 [Occ=Once1] ->
|
|
| 1025 | + let {
|
|
| 1026 | + m :: Word#
|
|
| 1027 | + [LclId]
|
|
| 1028 | + m = uncheckedShiftL#
|
|
| 1029 | + 1## (word2Int# (and# (uncheckedShiftRL# bx ww) 31##)) } in
|
|
| 1030 | + case GHC.Internal.Classes.eqWord
|
|
| 1031 | + (GHC.Internal.Types.W# (and# m bx2)) (GHC.Internal.Types.W# 0##)
|
|
| 1032 | + of {
|
|
| 1033 | + False ->
|
|
| 1034 | + case indexSmallArray#
|
|
| 1035 | + @Lifted
|
|
| 1036 | + @(HashMap k b)
|
|
| 1037 | + bx3
|
|
| 1038 | + (word2Int# (popCnt# (and# bx2 (minusWord# m 1##))))
|
|
| 1039 | + of
|
|
| 1040 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1041 | + T26615a.$wdisjointSubtrees @k @a @b $dEq (+# ww 5#) wild ipv
|
|
| 1042 | + };
|
|
| 1043 | + True -> GHC.Internal.Types.True
|
|
| 1044 | + };
|
|
| 1045 | + Full bx2 [Occ=Once1] ->
|
|
| 1046 | + case indexSmallArray#
|
|
| 1047 | + @Lifted
|
|
| 1048 | + @(HashMap k b)
|
|
| 1049 | + bx2
|
|
| 1050 | + (word2Int# (and# (uncheckedShiftRL# bx ww) 31##))
|
|
| 1051 | + of
|
|
| 1052 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1053 | + T26615a.$wdisjointSubtrees @k @a @b $dEq (+# ww 5#) wild ipv
|
|
| 1054 | + }
|
|
| 1055 | + };
|
|
| 1056 | + BitmapIndexed bx bx1 ->
|
|
| 1057 | + case _b of {
|
|
| 1058 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1059 | + BitmapIndexed bx2 bx3 ->
|
|
| 1060 | + case GHC.Internal.Classes.eqWord
|
|
| 1061 | + (GHC.Internal.Types.W# (and# bx bx2)) (GHC.Internal.Types.W# 0##)
|
|
| 1062 | + of {
|
|
| 1063 | + False ->
|
|
| 1064 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 1065 | + @(*)
|
|
| 1066 | + @(SmallArray# (HashMap k a)
|
|
| 1067 | + -> SmallArray# (HashMap k b) -> Int#)
|
|
| 1068 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 1069 | + -> GHC.Internal.Types.UnusedType 1 "b" -> Int#)
|
|
| 1070 | + of
|
|
| 1071 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 1072 | + case reallyUnsafePtrEquality#
|
|
| 1073 | + @Lifted
|
|
| 1074 | + @Lifted
|
|
| 1075 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 1076 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 1077 | + (bx1
|
|
| 1078 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 1079 | + :: SmallArray# (HashMap k a)
|
|
| 1080 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 1081 | + (bx3
|
|
| 1082 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 1083 | + :: SmallArray# (HashMap k b)
|
|
| 1084 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 1085 | + of {
|
|
| 1086 | + __DEFAULT ->
|
|
| 1087 | + joinrec {
|
|
| 1088 | + go [Occ=LoopBreakerT[1]] :: Word -> Bool
|
|
| 1089 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 1090 | + go (ds1 [Occ=Once1!] :: Word)
|
|
| 1091 | + = case ds1 of { W# ds2 [Occ=Once1!] ->
|
|
| 1092 | + case ds2 of ds3 {
|
|
| 1093 | + __DEFAULT ->
|
|
| 1094 | + let {
|
|
| 1095 | + m :: Word#
|
|
| 1096 | + [LclId]
|
|
| 1097 | + m = and#
|
|
| 1098 | + ds3 (int2Word# (negateInt# (word2Int# ds3))) } in
|
|
| 1099 | + case indexSmallArray#
|
|
| 1100 | + @Lifted
|
|
| 1101 | + @(HashMap k a)
|
|
| 1102 | + bx1
|
|
| 1103 | + (word2Int# (popCnt# (and# bx (minusWord# m 1##))))
|
|
| 1104 | + of
|
|
| 1105 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1106 | + case indexSmallArray#
|
|
| 1107 | + @Lifted
|
|
| 1108 | + @(HashMap k b)
|
|
| 1109 | + bx3
|
|
| 1110 | + (word2Int#
|
|
| 1111 | + (popCnt# (and# bx2 (minusWord# m 1##))))
|
|
| 1112 | + of
|
|
| 1113 | + { (# ipv1 [Occ=Once1] #) ->
|
|
| 1114 | + case T26615a.$wdisjointSubtrees
|
|
| 1115 | + @k @a @b $dEq (+# ww 5#) ipv ipv1
|
|
| 1116 | + of {
|
|
| 1117 | + False -> GHC.Internal.Types.False;
|
|
| 1118 | + True ->
|
|
| 1119 | + jump go (GHC.Internal.Types.W# (and# ds3 (not# m)))
|
|
| 1120 | + }
|
|
| 1121 | + }
|
|
| 1122 | + };
|
|
| 1123 | + 0## -> GHC.Internal.Types.True
|
|
| 1124 | + }
|
|
| 1125 | + }; } in
|
|
| 1126 | + jump go (GHC.Internal.Types.W# (and# bx bx2));
|
|
| 1127 | + 1# -> GHC.Internal.Types.False
|
|
| 1128 | + }
|
|
| 1129 | + };
|
|
| 1130 | + True -> GHC.Internal.Types.True
|
|
| 1131 | + };
|
|
| 1132 | + Full bx2 [Occ=OnceL1] ->
|
|
| 1133 | + joinrec {
|
|
| 1134 | + go [Occ=LoopBreakerT[1]] :: Word -> Bool
|
|
| 1135 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 1136 | + go (ds1 [Occ=Once1!] :: Word)
|
|
| 1137 | + = case ds1 of { W# ds2 [Occ=Once1!] ->
|
|
| 1138 | + case ds2 of ds3 {
|
|
| 1139 | + __DEFAULT ->
|
|
| 1140 | + let {
|
|
| 1141 | + m :: Word#
|
|
| 1142 | + [LclId]
|
|
| 1143 | + m = and# ds3 (int2Word# (negateInt# (word2Int# ds3))) } in
|
|
| 1144 | + case indexSmallArray#
|
|
| 1145 | + @Lifted
|
|
| 1146 | + @(HashMap k a)
|
|
| 1147 | + bx1
|
|
| 1148 | + (word2Int# (popCnt# (and# bx (minusWord# m 1##))))
|
|
| 1149 | + of
|
|
| 1150 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1151 | + case indexSmallArray#
|
|
| 1152 | + @Lifted
|
|
| 1153 | + @(HashMap k b)
|
|
| 1154 | + bx2
|
|
| 1155 | + (word2Int#
|
|
| 1156 | + (popCnt# (and# 4294967295## (minusWord# m 1##))))
|
|
| 1157 | + of
|
|
| 1158 | + { (# ipv1 [Occ=Once1] #) ->
|
|
| 1159 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq (+# ww 5#) ipv ipv1
|
|
| 1160 | + of {
|
|
| 1161 | + False -> GHC.Internal.Types.False;
|
|
| 1162 | + True -> jump go (GHC.Internal.Types.W# (and# ds3 (not# m)))
|
|
| 1163 | + }
|
|
| 1164 | + }
|
|
| 1165 | + };
|
|
| 1166 | + 0## -> GHC.Internal.Types.True
|
|
| 1167 | + }
|
|
| 1168 | + }; } in
|
|
| 1169 | + jump go (GHC.Internal.Types.W# (and# bx 4294967295##))
|
|
| 1170 | + };
|
|
| 1171 | + Full bx ->
|
|
| 1172 | + case _b of {
|
|
| 1173 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1174 | + BitmapIndexed bx1 bx2 [Occ=OnceL1] ->
|
|
| 1175 | + joinrec {
|
|
| 1176 | + go [Occ=LoopBreakerT[1]] :: Word -> Bool
|
|
| 1177 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 1178 | + go (ds1 [Occ=Once1!] :: Word)
|
|
| 1179 | + = case ds1 of { W# ds2 [Occ=Once1!] ->
|
|
| 1180 | + case ds2 of ds3 {
|
|
| 1181 | + __DEFAULT ->
|
|
| 1182 | + let {
|
|
| 1183 | + m :: Word#
|
|
| 1184 | + [LclId]
|
|
| 1185 | + m = and# ds3 (int2Word# (negateInt# (word2Int# ds3))) } in
|
|
| 1186 | + case indexSmallArray#
|
|
| 1187 | + @Lifted
|
|
| 1188 | + @(HashMap k a)
|
|
| 1189 | + bx
|
|
| 1190 | + (word2Int#
|
|
| 1191 | + (popCnt# (and# 4294967295## (minusWord# m 1##))))
|
|
| 1192 | + of
|
|
| 1193 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1194 | + case indexSmallArray#
|
|
| 1195 | + @Lifted
|
|
| 1196 | + @(HashMap k b)
|
|
| 1197 | + bx2
|
|
| 1198 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 1199 | + of
|
|
| 1200 | + { (# ipv1 [Occ=Once1] #) ->
|
|
| 1201 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq (+# ww 5#) ipv ipv1
|
|
| 1202 | + of {
|
|
| 1203 | + False -> GHC.Internal.Types.False;
|
|
| 1204 | + True -> jump go (GHC.Internal.Types.W# (and# ds3 (not# m)))
|
|
| 1205 | + }
|
|
| 1206 | + }
|
|
| 1207 | + };
|
|
| 1208 | + 0## -> GHC.Internal.Types.True
|
|
| 1209 | + }
|
|
| 1210 | + }; } in
|
|
| 1211 | + jump go (GHC.Internal.Types.W# (and# 4294967295## bx1));
|
|
| 1212 | + Full bx1 ->
|
|
| 1213 | + joinrec {
|
|
| 1214 | + go [Occ=LoopBreakerT[1]] :: Int -> Bool
|
|
| 1215 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 1216 | + go (i :: Int)
|
|
| 1217 | + = case GHC.Internal.Classes.ltInt i (GHC.Internal.Types.I# 0#) of {
|
|
| 1218 | + False ->
|
|
| 1219 | + case i of { I# i# ->
|
|
| 1220 | + case indexSmallArray# @Lifted @(HashMap k a) bx i# of
|
|
| 1221 | + { (# ipv [Occ=Once1] #) ->
|
|
| 1222 | + case indexSmallArray# @Lifted @(HashMap k b) bx1 i# of
|
|
| 1223 | + { (# ipv1 [Occ=Once1] #) ->
|
|
| 1224 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq (+# ww 5#) ipv ipv1
|
|
| 1225 | + of {
|
|
| 1226 | + False -> GHC.Internal.Types.False;
|
|
| 1227 | + True -> jump go (GHC.Internal.Types.I# (-# i# 1#))
|
|
| 1228 | + }
|
|
| 1229 | + }
|
|
| 1230 | + }
|
|
| 1231 | + };
|
|
| 1232 | + True -> GHC.Internal.Types.True
|
|
| 1233 | + }; } in
|
|
| 1234 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 1235 | + @(*)
|
|
| 1236 | + @(SmallArray# (HashMap k a) -> SmallArray# (HashMap k b) -> Int#)
|
|
| 1237 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 1238 | + -> GHC.Internal.Types.UnusedType 1 "b" -> Int#)
|
|
| 1239 | + of
|
|
| 1240 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 1241 | + case reallyUnsafePtrEquality#
|
|
| 1242 | + @Lifted
|
|
| 1243 | + @Lifted
|
|
| 1244 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 1245 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 1246 | + (bx
|
|
| 1247 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 1248 | + :: SmallArray# (HashMap k a)
|
|
| 1249 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 1250 | + (bx1
|
|
| 1251 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 1252 | + :: SmallArray# (HashMap k b)
|
|
| 1253 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 1254 | + of {
|
|
| 1255 | + __DEFAULT -> jump go (GHC.Internal.Types.I# 31#);
|
|
| 1256 | + 1# -> GHC.Internal.Types.False
|
|
| 1257 | + }
|
|
| 1258 | + }
|
|
| 1259 | + }
|
|
| 1260 | + }}]
|
|
| 1261 | +T26615a.$wdisjointSubtrees
|
|
| 1262 | + = \ (@k)
|
|
| 1263 | + (@a)
|
|
| 1264 | + (@b)
|
|
| 1265 | + ($dEq :: Eq k)
|
|
| 1266 | + (ww :: Int#)
|
|
| 1267 | + (ds :: HashMap k a)
|
|
| 1268 | + (_b :: HashMap k b) ->
|
|
| 1269 | + join {
|
|
| 1270 | + fail [Dmd=MC(1,L)] :: (# #) -> Bool
|
|
| 1271 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<A>, Unf=OtherCon []]
|
|
| 1272 | + fail (ds1 [Occ=Dead, OS=OneShot] :: (# #))
|
|
| 1273 | + = case _b of {
|
|
| 1274 | + __DEFAULT -> case lvl1 of {};
|
|
| 1275 | + Empty -> GHC.Internal.Types.True;
|
|
| 1276 | + Leaf bx ds2 ->
|
|
| 1277 | + case ds2 of { L kB ds3 ->
|
|
| 1278 | + case kB of k0 { __DEFAULT ->
|
|
| 1279 | + join {
|
|
| 1280 | + exit [Dmd=LC(S,C(1,C(1,C(1,L))))]
|
|
| 1281 | + :: Word# -> k -> Word# -> Leaf k a -> Bool
|
|
| 1282 | + [LclId[JoinId(4)(Just [~, ~, ~, !])],
|
|
| 1283 | + Arity=4,
|
|
| 1284 | + Str=<L><L><L><1P(L,A)>]
|
|
| 1285 | + exit (ww1 [OS=OneShot] :: Word#)
|
|
| 1286 | + (ds4 [OS=OneShot] :: k)
|
|
| 1287 | + (bx1 [OS=OneShot] :: Word#)
|
|
| 1288 | + (ds5 [OS=OneShot] :: Leaf k a)
|
|
| 1289 | + = case ds5 of { L kx x ->
|
|
| 1290 | + case eqWord# ww1 bx1 of {
|
|
| 1291 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1292 | + 1# ->
|
|
| 1293 | + case == @k $dEq ds4 kx of {
|
|
| 1294 | + False -> GHC.Internal.Types.True;
|
|
| 1295 | + True -> GHC.Internal.Types.False
|
|
| 1296 | + }
|
|
| 1297 | + }
|
|
| 1298 | + } } in
|
|
| 1299 | + join {
|
|
| 1300 | + exit1 [Dmd=LC(S,C(1,C(1,C(1,L))))]
|
|
| 1301 | + :: Word# -> k -> Word# -> SmallArray# (Leaf k a) -> Bool
|
|
| 1302 | + [LclId[JoinId(4)(Nothing)], Arity=4, Str=<L><ML><L><L>]
|
|
| 1303 | + exit1 (ww1 [OS=OneShot] :: Word#)
|
|
| 1304 | + (ds4 [OS=OneShot] :: k)
|
|
| 1305 | + (bx1 [OS=OneShot] :: Word#)
|
|
| 1306 | + (bx2 [OS=OneShot] :: SmallArray# (Leaf k a))
|
|
| 1307 | + = case eqWord# ww1 bx1 of {
|
|
| 1308 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1309 | + 1# ->
|
|
| 1310 | + joinrec {
|
|
| 1311 | + $wlookupInArrayCont_ [InlPrag=[2],
|
|
| 1312 | + Occ=LoopBreaker,
|
|
| 1313 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 1314 | + :: k -> SmallArray# (Leaf k a) -> Int# -> Int# -> Bool
|
|
| 1315 | + [LclId[JoinId(4)(Just [!])],
|
|
| 1316 | + Arity=4,
|
|
| 1317 | + Str=<1L><L><L><L>,
|
|
| 1318 | + Unf=OtherCon []]
|
|
| 1319 | + $wlookupInArrayCont_ (k1 :: k)
|
|
| 1320 | + (ww2 :: SmallArray# (Leaf k a))
|
|
| 1321 | + (ww3 :: Int#)
|
|
| 1322 | + (ww4 :: Int#)
|
|
| 1323 | + = case k1 of k2 { __DEFAULT ->
|
|
| 1324 | + case >=# ww3 ww4 of {
|
|
| 1325 | + __DEFAULT ->
|
|
| 1326 | + case indexSmallArray# @Lifted @(Leaf k a) ww2 ww3 of
|
|
| 1327 | + { (# ipv #) ->
|
|
| 1328 | + case ipv of { L kx v ->
|
|
| 1329 | + case == @k $dEq k2 kx of {
|
|
| 1330 | + False -> jump $wlookupInArrayCont_ k2 ww2 (+# ww3 1#) ww4;
|
|
| 1331 | + True -> GHC.Internal.Types.False
|
|
| 1332 | + }
|
|
| 1333 | + }
|
|
| 1334 | + };
|
|
| 1335 | + 1# -> GHC.Internal.Types.True
|
|
| 1336 | + }
|
|
| 1337 | + }; } in
|
|
| 1338 | + jump $wlookupInArrayCont_
|
|
| 1339 | + ds4 bx2 0# (sizeofSmallArray# @Lifted @(Leaf k a) bx2)
|
|
| 1340 | + } } in
|
|
| 1341 | + joinrec {
|
|
| 1342 | + $wlookupCont_ [InlPrag=[2],
|
|
| 1343 | + Occ=LoopBreaker,
|
|
| 1344 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 1345 | + :: Word# -> k -> Int# -> HashMap k a -> Bool
|
|
| 1346 | + [LclId[JoinId(4)(Just [~, !, ~, !])],
|
|
| 1347 | + Arity=4,
|
|
| 1348 | + Str=<L><1L><L><1L>,
|
|
| 1349 | + Unf=OtherCon []]
|
|
| 1350 | + $wlookupCont_ (ww1 :: Word#)
|
|
| 1351 | + (ds4 :: k)
|
|
| 1352 | + (ww2 :: Int#)
|
|
| 1353 | + (ds5 :: HashMap k a)
|
|
| 1354 | + = case ds4 of ds6 { __DEFAULT ->
|
|
| 1355 | + case ds5 of {
|
|
| 1356 | + Empty -> GHC.Internal.Types.True;
|
|
| 1357 | + Leaf bx1 ds7 -> jump exit ww1 ds6 bx1 ds7;
|
|
| 1358 | + Collision bx1 bx2 -> jump exit1 ww1 ds6 bx1 bx2;
|
|
| 1359 | + BitmapIndexed bx1 bx2 ->
|
|
| 1360 | + let {
|
|
| 1361 | + m :: Word#
|
|
| 1362 | + [LclId]
|
|
| 1363 | + m = uncheckedShiftL#
|
|
| 1364 | + 1## (word2Int# (and# (uncheckedShiftRL# ww1 ww2) 31##)) } in
|
|
| 1365 | + case and# bx1 m of {
|
|
| 1366 | + __DEFAULT ->
|
|
| 1367 | + case indexSmallArray#
|
|
| 1368 | + @Lifted
|
|
| 1369 | + @(HashMap k a)
|
|
| 1370 | + bx2
|
|
| 1371 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 1372 | + of
|
|
| 1373 | + { (# ipv #) ->
|
|
| 1374 | + jump $wlookupCont_ ww1 ds6 (+# ww2 5#) ipv
|
|
| 1375 | + };
|
|
| 1376 | + 0## -> GHC.Internal.Types.True
|
|
| 1377 | + };
|
|
| 1378 | + Full bx1 ->
|
|
| 1379 | + case indexSmallArray#
|
|
| 1380 | + @Lifted
|
|
| 1381 | + @(HashMap k a)
|
|
| 1382 | + bx1
|
|
| 1383 | + (word2Int# (and# (uncheckedShiftRL# ww1 ww2) 31##))
|
|
| 1384 | + of
|
|
| 1385 | + { (# ipv #) ->
|
|
| 1386 | + jump $wlookupCont_ ww1 ds6 (+# ww2 5#) ipv
|
|
| 1387 | + }
|
|
| 1388 | + }
|
|
| 1389 | + }; } in
|
|
| 1390 | + jump $wlookupCont_ bx k0 ww ds
|
|
| 1391 | + }
|
|
| 1392 | + };
|
|
| 1393 | + Collision bx bx1 ->
|
|
| 1394 | + T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 1395 | + @k @b @a $dEq ww bx bx1 ds
|
|
| 1396 | + } } in
|
|
| 1397 | + case ds of {
|
|
| 1398 | + Empty -> GHC.Internal.Types.True;
|
|
| 1399 | + Leaf bx ds1 ->
|
|
| 1400 | + case ds1 of { L kA ds2 ->
|
|
| 1401 | + case _b of wild2 {
|
|
| 1402 | + __DEFAULT ->
|
|
| 1403 | + case kA of k0 { __DEFAULT ->
|
|
| 1404 | + join {
|
|
| 1405 | + exit [Dmd=LC(S,C(1,C(1,C(1,L))))]
|
|
| 1406 | + :: Word# -> k -> Word# -> Leaf k b -> Bool
|
|
| 1407 | + [LclId[JoinId(4)(Just [~, ~, ~, !])],
|
|
| 1408 | + Arity=4,
|
|
| 1409 | + Str=<L><L><L><1P(L,A)>]
|
|
| 1410 | + exit (ww1 [OS=OneShot] :: Word#)
|
|
| 1411 | + (ds3 [OS=OneShot] :: k)
|
|
| 1412 | + (bx1 [OS=OneShot] :: Word#)
|
|
| 1413 | + (ds4 [OS=OneShot] :: Leaf k b)
|
|
| 1414 | + = case ds4 of { L kx x ->
|
|
| 1415 | + case eqWord# ww1 bx1 of {
|
|
| 1416 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1417 | + 1# ->
|
|
| 1418 | + case == @k $dEq ds3 kx of {
|
|
| 1419 | + False -> GHC.Internal.Types.True;
|
|
| 1420 | + True -> GHC.Internal.Types.False
|
|
| 1421 | + }
|
|
| 1422 | + }
|
|
| 1423 | + } } in
|
|
| 1424 | + join {
|
|
| 1425 | + exit1 [Dmd=LC(S,C(1,C(1,C(1,L))))]
|
|
| 1426 | + :: Word# -> k -> Word# -> SmallArray# (Leaf k b) -> Bool
|
|
| 1427 | + [LclId[JoinId(4)(Nothing)], Arity=4, Str=<L><ML><L><L>]
|
|
| 1428 | + exit1 (ww1 [OS=OneShot] :: Word#)
|
|
| 1429 | + (ds3 [OS=OneShot] :: k)
|
|
| 1430 | + (bx1 [OS=OneShot] :: Word#)
|
|
| 1431 | + (bx2 [OS=OneShot] :: SmallArray# (Leaf k b))
|
|
| 1432 | + = case eqWord# ww1 bx1 of {
|
|
| 1433 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1434 | + 1# ->
|
|
| 1435 | + joinrec {
|
|
| 1436 | + $wlookupInArrayCont_ [InlPrag=[2],
|
|
| 1437 | + Occ=LoopBreaker,
|
|
| 1438 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 1439 | + :: k -> SmallArray# (Leaf k b) -> Int# -> Int# -> Bool
|
|
| 1440 | + [LclId[JoinId(4)(Just [!])],
|
|
| 1441 | + Arity=4,
|
|
| 1442 | + Str=<1L><L><L><L>,
|
|
| 1443 | + Unf=OtherCon []]
|
|
| 1444 | + $wlookupInArrayCont_ (k1 :: k)
|
|
| 1445 | + (ww2 :: SmallArray# (Leaf k b))
|
|
| 1446 | + (ww3 :: Int#)
|
|
| 1447 | + (ww4 :: Int#)
|
|
| 1448 | + = case k1 of k2 { __DEFAULT ->
|
|
| 1449 | + case >=# ww3 ww4 of {
|
|
| 1450 | + __DEFAULT ->
|
|
| 1451 | + case indexSmallArray# @Lifted @(Leaf k b) ww2 ww3 of
|
|
| 1452 | + { (# ipv #) ->
|
|
| 1453 | + case ipv of { L kx v ->
|
|
| 1454 | + case == @k $dEq k2 kx of {
|
|
| 1455 | + False -> jump $wlookupInArrayCont_ k2 ww2 (+# ww3 1#) ww4;
|
|
| 1456 | + True -> GHC.Internal.Types.False
|
|
| 1457 | + }
|
|
| 1458 | + }
|
|
| 1459 | + };
|
|
| 1460 | + 1# -> GHC.Internal.Types.True
|
|
| 1461 | + }
|
|
| 1462 | + }; } in
|
|
| 1463 | + jump $wlookupInArrayCont_
|
|
| 1464 | + ds3 bx2 0# (sizeofSmallArray# @Lifted @(Leaf k b) bx2)
|
|
| 1465 | + } } in
|
|
| 1466 | + joinrec {
|
|
| 1467 | + $wlookupCont_ [InlPrag=[2],
|
|
| 1468 | + Occ=LoopBreaker,
|
|
| 1469 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 1470 | + :: Word# -> k -> Int# -> HashMap k b -> Bool
|
|
| 1471 | + [LclId[JoinId(4)(Just [~, !, ~, !])],
|
|
| 1472 | + Arity=4,
|
|
| 1473 | + Str=<L><1L><L><1L>,
|
|
| 1474 | + Unf=OtherCon []]
|
|
| 1475 | + $wlookupCont_ (ww1 :: Word#)
|
|
| 1476 | + (ds3 :: k)
|
|
| 1477 | + (ww2 :: Int#)
|
|
| 1478 | + (ds4 :: HashMap k b)
|
|
| 1479 | + = case ds3 of ds5 { __DEFAULT ->
|
|
| 1480 | + case ds4 of {
|
|
| 1481 | + Empty -> GHC.Internal.Types.True;
|
|
| 1482 | + Leaf bx1 ds6 -> jump exit ww1 ds5 bx1 ds6;
|
|
| 1483 | + Collision bx1 bx2 -> jump exit1 ww1 ds5 bx1 bx2;
|
|
| 1484 | + BitmapIndexed bx1 bx2 ->
|
|
| 1485 | + let {
|
|
| 1486 | + m :: Word#
|
|
| 1487 | + [LclId]
|
|
| 1488 | + m = uncheckedShiftL#
|
|
| 1489 | + 1## (word2Int# (and# (uncheckedShiftRL# ww1 ww2) 31##)) } in
|
|
| 1490 | + case and# bx1 m of {
|
|
| 1491 | + __DEFAULT ->
|
|
| 1492 | + case indexSmallArray#
|
|
| 1493 | + @Lifted
|
|
| 1494 | + @(HashMap k b)
|
|
| 1495 | + bx2
|
|
| 1496 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 1497 | + of
|
|
| 1498 | + { (# ipv #) ->
|
|
| 1499 | + jump $wlookupCont_ ww1 ds5 (+# ww2 5#) ipv
|
|
| 1500 | + };
|
|
| 1501 | + 0## -> GHC.Internal.Types.True
|
|
| 1502 | + };
|
|
| 1503 | + Full bx1 ->
|
|
| 1504 | + case indexSmallArray#
|
|
| 1505 | + @Lifted
|
|
| 1506 | + @(HashMap k b)
|
|
| 1507 | + bx1
|
|
| 1508 | + (word2Int# (and# (uncheckedShiftRL# ww1 ww2) 31##))
|
|
| 1509 | + of
|
|
| 1510 | + { (# ipv #) ->
|
|
| 1511 | + jump $wlookupCont_ ww1 ds5 (+# ww2 5#) ipv
|
|
| 1512 | + }
|
|
| 1513 | + }
|
|
| 1514 | + }; } in
|
|
| 1515 | + jump $wlookupCont_ bx k0 ww wild2
|
|
| 1516 | + };
|
|
| 1517 | + Leaf bx1 ds3 ->
|
|
| 1518 | + case ds3 of { L kB ds4 ->
|
|
| 1519 | + case neWord# bx bx1 of {
|
|
| 1520 | + __DEFAULT -> /= @k $dEq kA kB;
|
|
| 1521 | + 1# -> GHC.Internal.Types.True
|
|
| 1522 | + }
|
|
| 1523 | + }
|
|
| 1524 | + }
|
|
| 1525 | + };
|
|
| 1526 | + Collision bx bx1 ->
|
|
| 1527 | + case _b of {
|
|
| 1528 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1529 | + Collision bx2 bx3 ->
|
|
| 1530 | + T26615a.$wdisjointCollisions
|
|
| 1531 | + @k @a @b $dEq bx (T26615a.Array @(Leaf k a) bx1) bx2 bx3;
|
|
| 1532 | + BitmapIndexed bx2 bx3 ->
|
|
| 1533 | + let {
|
|
| 1534 | + m :: Word#
|
|
| 1535 | + [LclId]
|
|
| 1536 | + m = uncheckedShiftL#
|
|
| 1537 | + 1## (word2Int# (and# (uncheckedShiftRL# bx ww) 31##)) } in
|
|
| 1538 | + case and# m bx2 of {
|
|
| 1539 | + __DEFAULT ->
|
|
| 1540 | + case indexSmallArray#
|
|
| 1541 | + @Lifted
|
|
| 1542 | + @(HashMap k b)
|
|
| 1543 | + bx3
|
|
| 1544 | + (word2Int# (popCnt# (and# bx2 (minusWord# m 1##))))
|
|
| 1545 | + of
|
|
| 1546 | + { (# ipv #) ->
|
|
| 1547 | + T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 1548 | + @k @a @b $dEq (+# ww 5#) bx bx1 ipv
|
|
| 1549 | + };
|
|
| 1550 | + 0## -> GHC.Internal.Types.True
|
|
| 1551 | + };
|
|
| 1552 | + Full bx2 ->
|
|
| 1553 | + case indexSmallArray#
|
|
| 1554 | + @Lifted
|
|
| 1555 | + @(HashMap k b)
|
|
| 1556 | + bx2
|
|
| 1557 | + (word2Int# (and# (uncheckedShiftRL# bx ww) 31##))
|
|
| 1558 | + of
|
|
| 1559 | + { (# ipv #) ->
|
|
| 1560 | + T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 1561 | + @k @a @b $dEq (+# ww 5#) bx bx1 ipv
|
|
| 1562 | + }
|
|
| 1563 | + };
|
|
| 1564 | + BitmapIndexed bx bx1 ->
|
|
| 1565 | + case _b of {
|
|
| 1566 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1567 | + BitmapIndexed bx2 bx3 ->
|
|
| 1568 | + case and# bx bx2 of wild2 {
|
|
| 1569 | + __DEFAULT ->
|
|
| 1570 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 1571 | + @(*)
|
|
| 1572 | + @(SmallArray# (HashMap k a) -> SmallArray# (HashMap k b) -> Int#)
|
|
| 1573 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 1574 | + -> GHC.Internal.Types.UnusedType 1 "b" -> Int#)
|
|
| 1575 | + of
|
|
| 1576 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 1577 | + case reallyUnsafePtrEquality#
|
|
| 1578 | + @Lifted
|
|
| 1579 | + @Lifted
|
|
| 1580 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 1581 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 1582 | + (bx1
|
|
| 1583 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 1584 | + :: SmallArray# (HashMap k a)
|
|
| 1585 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 1586 | + (bx3
|
|
| 1587 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 1588 | + :: SmallArray# (HashMap k b)
|
|
| 1589 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 1590 | + of {
|
|
| 1591 | + __DEFAULT ->
|
|
| 1592 | + let {
|
|
| 1593 | + lvl2 :: Int#
|
|
| 1594 | + [LclId]
|
|
| 1595 | + lvl2 = +# ww 5# } in
|
|
| 1596 | + joinrec {
|
|
| 1597 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)] :: Word# -> Bool
|
|
| 1598 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 1599 | + $wgo (ww1 :: Word#)
|
|
| 1600 | + = case ww1 of ds1 {
|
|
| 1601 | + __DEFAULT ->
|
|
| 1602 | + let {
|
|
| 1603 | + m :: Word#
|
|
| 1604 | + [LclId]
|
|
| 1605 | + m = and# ds1 (int2Word# (negateInt# (word2Int# ds1))) } in
|
|
| 1606 | + case indexSmallArray#
|
|
| 1607 | + @Lifted
|
|
| 1608 | + @(HashMap k a)
|
|
| 1609 | + bx1
|
|
| 1610 | + (word2Int# (popCnt# (and# bx (minusWord# m 1##))))
|
|
| 1611 | + of
|
|
| 1612 | + { (# ipv #) ->
|
|
| 1613 | + case indexSmallArray#
|
|
| 1614 | + @Lifted
|
|
| 1615 | + @(HashMap k b)
|
|
| 1616 | + bx3
|
|
| 1617 | + (word2Int# (popCnt# (and# bx2 (minusWord# m 1##))))
|
|
| 1618 | + of
|
|
| 1619 | + { (# ipv1 #) ->
|
|
| 1620 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq lvl2 ipv ipv1 of {
|
|
| 1621 | + False -> GHC.Internal.Types.False;
|
|
| 1622 | + True -> jump $wgo (and# ds1 (not# m))
|
|
| 1623 | + }
|
|
| 1624 | + }
|
|
| 1625 | + };
|
|
| 1626 | + 0## -> GHC.Internal.Types.True
|
|
| 1627 | + }; } in
|
|
| 1628 | + jump $wgo wild2;
|
|
| 1629 | + 1# -> GHC.Internal.Types.False
|
|
| 1630 | + }
|
|
| 1631 | + };
|
|
| 1632 | + 0## -> GHC.Internal.Types.True
|
|
| 1633 | + };
|
|
| 1634 | + Full bx2 ->
|
|
| 1635 | + let {
|
|
| 1636 | + lvl2 :: Int#
|
|
| 1637 | + [LclId]
|
|
| 1638 | + lvl2 = +# ww 5# } in
|
|
| 1639 | + joinrec {
|
|
| 1640 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)] :: Word# -> Bool
|
|
| 1641 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 1642 | + $wgo (ww1 :: Word#)
|
|
| 1643 | + = case ww1 of ds1 {
|
|
| 1644 | + __DEFAULT ->
|
|
| 1645 | + let {
|
|
| 1646 | + m :: Word#
|
|
| 1647 | + [LclId]
|
|
| 1648 | + m = and# ds1 (int2Word# (negateInt# (word2Int# ds1))) } in
|
|
| 1649 | + case indexSmallArray#
|
|
| 1650 | + @Lifted
|
|
| 1651 | + @(HashMap k a)
|
|
| 1652 | + bx1
|
|
| 1653 | + (word2Int# (popCnt# (and# bx (minusWord# m 1##))))
|
|
| 1654 | + of
|
|
| 1655 | + { (# ipv #) ->
|
|
| 1656 | + case indexSmallArray#
|
|
| 1657 | + @Lifted
|
|
| 1658 | + @(HashMap k b)
|
|
| 1659 | + bx2
|
|
| 1660 | + (word2Int# (popCnt# (and# 4294967295## (minusWord# m 1##))))
|
|
| 1661 | + of
|
|
| 1662 | + { (# ipv1 #) ->
|
|
| 1663 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq lvl2 ipv ipv1 of {
|
|
| 1664 | + False -> GHC.Internal.Types.False;
|
|
| 1665 | + True -> jump $wgo (and# ds1 (not# m))
|
|
| 1666 | + }
|
|
| 1667 | + }
|
|
| 1668 | + };
|
|
| 1669 | + 0## -> GHC.Internal.Types.True
|
|
| 1670 | + }; } in
|
|
| 1671 | + jump $wgo (and# bx 4294967295##)
|
|
| 1672 | + };
|
|
| 1673 | + Full bx ->
|
|
| 1674 | + case _b of {
|
|
| 1675 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 1676 | + BitmapIndexed bx1 bx2 ->
|
|
| 1677 | + let {
|
|
| 1678 | + lvl2 :: Int#
|
|
| 1679 | + [LclId]
|
|
| 1680 | + lvl2 = +# ww 5# } in
|
|
| 1681 | + joinrec {
|
|
| 1682 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)] :: Word# -> Bool
|
|
| 1683 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 1684 | + $wgo (ww1 :: Word#)
|
|
| 1685 | + = case ww1 of ds1 {
|
|
| 1686 | + __DEFAULT ->
|
|
| 1687 | + let {
|
|
| 1688 | + m :: Word#
|
|
| 1689 | + [LclId]
|
|
| 1690 | + m = and# ds1 (int2Word# (negateInt# (word2Int# ds1))) } in
|
|
| 1691 | + case indexSmallArray#
|
|
| 1692 | + @Lifted
|
|
| 1693 | + @(HashMap k a)
|
|
| 1694 | + bx
|
|
| 1695 | + (word2Int# (popCnt# (and# 4294967295## (minusWord# m 1##))))
|
|
| 1696 | + of
|
|
| 1697 | + { (# ipv #) ->
|
|
| 1698 | + case indexSmallArray#
|
|
| 1699 | + @Lifted
|
|
| 1700 | + @(HashMap k b)
|
|
| 1701 | + bx2
|
|
| 1702 | + (word2Int# (popCnt# (and# bx1 (minusWord# m 1##))))
|
|
| 1703 | + of
|
|
| 1704 | + { (# ipv1 #) ->
|
|
| 1705 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq lvl2 ipv ipv1 of {
|
|
| 1706 | + False -> GHC.Internal.Types.False;
|
|
| 1707 | + True -> jump $wgo (and# ds1 (not# m))
|
|
| 1708 | + }
|
|
| 1709 | + }
|
|
| 1710 | + };
|
|
| 1711 | + 0## -> GHC.Internal.Types.True
|
|
| 1712 | + }; } in
|
|
| 1713 | + jump $wgo (and# 4294967295## bx1);
|
|
| 1714 | + Full bx1 ->
|
|
| 1715 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 1716 | + @(*)
|
|
| 1717 | + @(SmallArray# (HashMap k a) -> SmallArray# (HashMap k b) -> Int#)
|
|
| 1718 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 1719 | + -> GHC.Internal.Types.UnusedType 1 "b" -> Int#)
|
|
| 1720 | + of
|
|
| 1721 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 1722 | + case reallyUnsafePtrEquality#
|
|
| 1723 | + @Lifted
|
|
| 1724 | + @Lifted
|
|
| 1725 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 1726 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 1727 | + (bx
|
|
| 1728 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 1729 | + :: SmallArray# (HashMap k a)
|
|
| 1730 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 1731 | + (bx1
|
|
| 1732 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 1733 | + :: SmallArray# (HashMap k b)
|
|
| 1734 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 1735 | + of {
|
|
| 1736 | + __DEFAULT ->
|
|
| 1737 | + let {
|
|
| 1738 | + lvl2 :: Int#
|
|
| 1739 | + [LclId]
|
|
| 1740 | + lvl2 = +# ww 5# } in
|
|
| 1741 | + joinrec {
|
|
| 1742 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)] :: Int# -> Bool
|
|
| 1743 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 1744 | + $wgo (ww1 :: Int#)
|
|
| 1745 | + = case <# ww1 0# of {
|
|
| 1746 | + __DEFAULT ->
|
|
| 1747 | + case indexSmallArray# @Lifted @(HashMap k a) bx ww1 of
|
|
| 1748 | + { (# ipv #) ->
|
|
| 1749 | + case indexSmallArray# @Lifted @(HashMap k b) bx1 ww1 of
|
|
| 1750 | + { (# ipv1 #) ->
|
|
| 1751 | + case T26615a.$wdisjointSubtrees @k @a @b $dEq lvl2 ipv ipv1 of {
|
|
| 1752 | + False -> GHC.Internal.Types.False;
|
|
| 1753 | + True -> jump $wgo (-# ww1 1#)
|
|
| 1754 | + }
|
|
| 1755 | + }
|
|
| 1756 | + };
|
|
| 1757 | + 1# -> GHC.Internal.Types.True
|
|
| 1758 | + }; } in
|
|
| 1759 | + jump $wgo 31#;
|
|
| 1760 | + 1# -> GHC.Internal.Types.False
|
|
| 1761 | + }
|
|
| 1762 | + }
|
|
| 1763 | + }
|
|
| 1764 | + }
|
|
| 1765 | +end Rec }
|
|
| 1766 | + |
|
| 1767 | +-- RHS size: {terms: 15, types: 17, coercions: 0, joins: 0/0}
|
|
| 1768 | +disjointSubtrees [InlPrag=INLINABLE[2]]
|
|
| 1769 | + :: forall k a b. Eq k => Int -> HashMap k a -> HashMap k b -> Bool
|
|
| 1770 | +[GblId,
|
|
| 1771 | + Arity=4,
|
|
| 1772 | + Str=<LP(LC(L,C(1,L)),LC(S,C(1,L)))><1!P(L)><SL><L>,
|
|
| 1773 | + Unf=Unf{Src=StableSystem, TopLvl=True,
|
|
| 1774 | + Value=True, ConLike=True, WorkFree=True, Expandable=True,
|
|
| 1775 | + Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
|
|
| 1776 | + Tmpl= \ (@k)
|
|
| 1777 | + (@a)
|
|
| 1778 | + (@b)
|
|
| 1779 | + ($dEq [Occ=Once1] :: Eq k)
|
|
| 1780 | + (_s [Occ=Once1!] :: Int)
|
|
| 1781 | + (ds [Occ=Once1] :: HashMap k a)
|
|
| 1782 | + (_b [Occ=Once1] :: HashMap k b) ->
|
|
| 1783 | + case _s of { I# ww [Occ=Once1] ->
|
|
| 1784 | + T26615a.$wdisjointSubtrees @k @a @b $dEq ww ds _b
|
|
| 1785 | + }}]
|
|
| 1786 | +disjointSubtrees
|
|
| 1787 | + = \ (@k)
|
|
| 1788 | + (@a)
|
|
| 1789 | + (@b)
|
|
| 1790 | + ($dEq :: Eq k)
|
|
| 1791 | + (_s :: Int)
|
|
| 1792 | + (ds :: HashMap k a)
|
|
| 1793 | + (_b :: HashMap k b) ->
|
|
| 1794 | + case _s of { I# ww ->
|
|
| 1795 | + T26615a.$wdisjointSubtrees @k @a @b $dEq ww ds _b
|
|
| 1796 | + }
|
|
| 1797 | + |
|
| 1798 | + |
|
| 1799 | +------ Local rules for imported ids --------
|
|
| 1800 | +"SC:$wdisjointSubtrees1" [1]
|
|
| 1801 | + forall (@k)
|
|
| 1802 | + (@b)
|
|
| 1803 | + (@a)
|
|
| 1804 | + (sc :: Eq k)
|
|
| 1805 | + (sc1 :: Int#)
|
|
| 1806 | + (sc2 :: Word#)
|
|
| 1807 | + (sc3 :: SmallArray# (Leaf k b))
|
|
| 1808 | + (sc4 :: Word#)
|
|
| 1809 | + (sc5 :: SmallArray# (Leaf k a)).
|
|
| 1810 | + T26615a.$wdisjointSubtrees @k
|
|
| 1811 | + @b
|
|
| 1812 | + @a
|
|
| 1813 | + sc
|
|
| 1814 | + sc1
|
|
| 1815 | + (T26615a.Collision @k @b sc2 sc3)
|
|
| 1816 | + (T26615a.Collision @k @a sc4 sc5)
|
|
| 1817 | + = T26615a.$wdisjointCollisions
|
|
| 1818 | + @k @b @a sc sc2 (T26615a.Array @(Leaf k b) sc3) sc4 sc5
|
|
| 1819 | +"SC:$wdisjointSubtrees0" [1]
|
|
| 1820 | + forall (@k)
|
|
| 1821 | + (@a)
|
|
| 1822 | + (@b)
|
|
| 1823 | + (sc :: Eq k)
|
|
| 1824 | + (sc1 :: Int#)
|
|
| 1825 | + (sc2 :: Word#)
|
|
| 1826 | + (sc3 :: SmallArray# (Leaf k a)).
|
|
| 1827 | + T26615a.$wdisjointSubtrees @k
|
|
| 1828 | + @a
|
|
| 1829 | + @b
|
|
| 1830 | + sc
|
|
| 1831 | + sc1
|
|
| 1832 | + (T26615a.Collision @k @a sc2 sc3)
|
|
| 1833 | + = T26615a.disjointSubtrees_$s$wdisjointSubtrees
|
|
| 1834 | + @k @a @b sc sc1 sc2 sc3
|
|
| 1835 | + |
|
| 1836 | + |
|
| 1837 | +[2 of 2] Compiling T26615 ( T26615.hs, T26615.o )
|
|
| 1838 | + |
|
| 1839 | +==================== Tidy Core ====================
|
|
| 1840 | +Result size of Tidy Core
|
|
| 1841 | + = {terms: 614, types: 682, coercions: 18, joins: 8/14}
|
|
| 1842 | + |
|
| 1843 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 1844 | +$trModule1 :: GHC.Internal.Prim.Addr#
|
|
| 1845 | +[GblId, Unf=OtherCon []]
|
|
| 1846 | +$trModule1 = "T26615"#
|
|
| 1847 | + |
|
| 1848 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 1849 | +$trModule2 :: GHC.Internal.Types.TrName
|
|
| 1850 | +[GblId, Unf=OtherCon []]
|
|
| 1851 | +$trModule2 = GHC.Internal.Types.TrNameS $trModule1
|
|
| 1852 | + |
|
| 1853 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 1854 | +$trModule3 :: GHC.Internal.Prim.Addr#
|
|
| 1855 | +[GblId, Unf=OtherCon []]
|
|
| 1856 | +$trModule3 = "main"#
|
|
| 1857 | + |
|
| 1858 | +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
|
|
| 1859 | +$trModule4 :: GHC.Internal.Types.TrName
|
|
| 1860 | +[GblId, Unf=OtherCon []]
|
|
| 1861 | +$trModule4 = GHC.Internal.Types.TrNameS $trModule3
|
|
| 1862 | + |
|
| 1863 | +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
|
|
| 1864 | +T26615.$trModule [InlPrag=[~]] :: GHC.Internal.Types.Module
|
|
| 1865 | +[GblId, Unf=OtherCon []]
|
|
| 1866 | +T26615.$trModule = GHC.Internal.Types.Module $trModule4 $trModule2
|
|
| 1867 | + |
|
| 1868 | +-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
|
|
| 1869 | +lvl :: GHC.Internal.Prim.Addr#
|
|
| 1870 | +[GblId, Unf=OtherCon []]
|
|
| 1871 | +lvl = "T26615a.hs:(26,1)-(65,59)|function disjointSubtrees"#
|
|
| 1872 | + |
|
| 1873 | +-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
|
|
| 1874 | +lvl1 :: ()
|
|
| 1875 | +[GblId, Str=b, Cpr=b]
|
|
| 1876 | +lvl1
|
|
| 1877 | + = GHC.Internal.Control.Exception.Base.patError
|
|
| 1878 | + @GHC.Internal.Types.LiftedRep @() lvl
|
|
| 1879 | + |
|
| 1880 | +Rec {
|
|
| 1881 | +-- RHS size: {terms: 37, types: 30, coercions: 0, joins: 0/0}
|
|
| 1882 | +$wpoly_lookupInArrayCont_
|
|
| 1883 | + :: forall a.
|
|
| 1884 | + String
|
|
| 1885 | + -> GHC.Internal.Prim.SmallArray# (T26615a.Leaf String a)
|
|
| 1886 | + -> GHC.Internal.Prim.Int#
|
|
| 1887 | + -> GHC.Internal.Prim.Int#
|
|
| 1888 | + -> Bool
|
|
| 1889 | +[GblId[StrictWorker([!])],
|
|
| 1890 | + Arity=4,
|
|
| 1891 | + Str=<1L><L><L><L>,
|
|
| 1892 | + Unf=OtherCon []]
|
|
| 1893 | +$wpoly_lookupInArrayCont_
|
|
| 1894 | + = \ (@a)
|
|
| 1895 | + (k1 :: String)
|
|
| 1896 | + (ww :: GHC.Internal.Prim.SmallArray# (T26615a.Leaf String a))
|
|
| 1897 | + (ww1 :: GHC.Internal.Prim.Int#)
|
|
| 1898 | + (ww2 :: GHC.Internal.Prim.Int#) ->
|
|
| 1899 | + case k1 of k2 { __DEFAULT ->
|
|
| 1900 | + case GHC.Internal.Prim.>=# ww1 ww2 of {
|
|
| 1901 | + __DEFAULT ->
|
|
| 1902 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 1903 | + @GHC.Internal.Types.Lifted @(T26615a.Leaf String a) ww ww1
|
|
| 1904 | + of
|
|
| 1905 | + { (# ipv5 #) ->
|
|
| 1906 | + case ipv5 of { T26615a.L kx v ->
|
|
| 1907 | + case GHC.Internal.Base.eqString k2 kx of {
|
|
| 1908 | + False ->
|
|
| 1909 | + $wpoly_lookupInArrayCont_
|
|
| 1910 | + @a k2 ww (GHC.Internal.Prim.+# ww1 1#) ww2;
|
|
| 1911 | + True -> GHC.Internal.Types.False
|
|
| 1912 | + }
|
|
| 1913 | + }
|
|
| 1914 | + };
|
|
| 1915 | + 1# -> GHC.Internal.Types.True
|
|
| 1916 | + }
|
|
| 1917 | + }
|
|
| 1918 | +end Rec }
|
|
| 1919 | + |
|
| 1920 | +Rec {
|
|
| 1921 | +-- RHS size: {terms: 98, types: 73, coercions: 0, joins: 0/1}
|
|
| 1922 | +$wpoly_lookupCont_
|
|
| 1923 | + :: forall a.
|
|
| 1924 | + GHC.Internal.Prim.Word#
|
|
| 1925 | + -> String -> GHC.Internal.Prim.Int# -> HashMap String a -> Bool
|
|
| 1926 | +[GblId[StrictWorker([~, !, ~, !])],
|
|
| 1927 | + Arity=4,
|
|
| 1928 | + Str=<L><1L><L><1L>,
|
|
| 1929 | + Unf=OtherCon []]
|
|
| 1930 | +$wpoly_lookupCont_
|
|
| 1931 | + = \ (@a)
|
|
| 1932 | + (ww :: GHC.Internal.Prim.Word#)
|
|
| 1933 | + (ds5 :: String)
|
|
| 1934 | + (ww1 :: GHC.Internal.Prim.Int#)
|
|
| 1935 | + (ds7 :: HashMap String a) ->
|
|
| 1936 | + case ds5 of ds9 { __DEFAULT ->
|
|
| 1937 | + case ds7 of {
|
|
| 1938 | + T26615a.Empty -> GHC.Internal.Types.True;
|
|
| 1939 | + T26615a.Leaf bx1 ds11 ->
|
|
| 1940 | + case ds11 of { T26615a.L kx x ->
|
|
| 1941 | + case GHC.Internal.Prim.eqWord# ww bx1 of {
|
|
| 1942 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1943 | + 1# ->
|
|
| 1944 | + case GHC.Internal.Base.eqString ds9 kx of {
|
|
| 1945 | + False -> GHC.Internal.Types.True;
|
|
| 1946 | + True -> GHC.Internal.Types.False
|
|
| 1947 | + }
|
|
| 1948 | + }
|
|
| 1949 | + };
|
|
| 1950 | + T26615a.Collision bx1 bx2 ->
|
|
| 1951 | + case GHC.Internal.Prim.eqWord# ww bx1 of {
|
|
| 1952 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 1953 | + 1# ->
|
|
| 1954 | + $wpoly_lookupInArrayCont_
|
|
| 1955 | + @a
|
|
| 1956 | + ds9
|
|
| 1957 | + bx2
|
|
| 1958 | + 0#
|
|
| 1959 | + (GHC.Internal.Prim.sizeofSmallArray#
|
|
| 1960 | + @GHC.Internal.Types.Lifted @(T26615a.Leaf String a) bx2)
|
|
| 1961 | + };
|
|
| 1962 | + T26615a.BitmapIndexed bx1 bx2 ->
|
|
| 1963 | + let {
|
|
| 1964 | + m :: GHC.Internal.Prim.Word#
|
|
| 1965 | + [LclId]
|
|
| 1966 | + m = GHC.Internal.Prim.uncheckedShiftL#
|
|
| 1967 | + 1##
|
|
| 1968 | + (GHC.Internal.Prim.word2Int#
|
|
| 1969 | + (GHC.Internal.Prim.and#
|
|
| 1970 | + (GHC.Internal.Prim.uncheckedShiftRL# ww ww1) 31##)) } in
|
|
| 1971 | + case GHC.Internal.Prim.and# bx1 m of {
|
|
| 1972 | + __DEFAULT ->
|
|
| 1973 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 1974 | + @GHC.Internal.Types.Lifted
|
|
| 1975 | + @(HashMap String a)
|
|
| 1976 | + bx2
|
|
| 1977 | + (GHC.Internal.Prim.word2Int#
|
|
| 1978 | + (GHC.Internal.Prim.popCnt#
|
|
| 1979 | + (GHC.Internal.Prim.and# bx1 (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 1980 | + of
|
|
| 1981 | + { (# ipv2 #) ->
|
|
| 1982 | + $wpoly_lookupCont_ @a ww ds9 (GHC.Internal.Prim.+# ww1 5#) ipv2
|
|
| 1983 | + };
|
|
| 1984 | + 0## -> GHC.Internal.Types.True
|
|
| 1985 | + };
|
|
| 1986 | + T26615a.Full bx1 ->
|
|
| 1987 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 1988 | + @GHC.Internal.Types.Lifted
|
|
| 1989 | + @(HashMap String a)
|
|
| 1990 | + bx1
|
|
| 1991 | + (GHC.Internal.Prim.word2Int#
|
|
| 1992 | + (GHC.Internal.Prim.and#
|
|
| 1993 | + (GHC.Internal.Prim.uncheckedShiftRL# ww ww1) 31##))
|
|
| 1994 | + of
|
|
| 1995 | + { (# ipv2 #) ->
|
|
| 1996 | + $wpoly_lookupCont_ @a ww ds9 (GHC.Internal.Prim.+# ww1 5#) ipv2
|
|
| 1997 | + }
|
|
| 1998 | + }
|
|
| 1999 | + }
|
|
| 2000 | +end Rec }
|
|
| 2001 | + |
|
| 2002 | +Rec {
|
|
| 2003 | +-- RHS size: {terms: 448, types: 523, coercions: 18, joins: 8/13}
|
|
| 2004 | +T26615.$s$wdisjointSubtrees [InlPrag=[~], Occ=LoopBreaker]
|
|
| 2005 | + :: forall a b.
|
|
| 2006 | + GHC.Internal.Prim.Int#
|
|
| 2007 | + -> HashMap String a -> HashMap String b -> Bool
|
|
| 2008 | +[GblId, Arity=3, Str=<L><SL><L>, Unf=OtherCon []]
|
|
| 2009 | +T26615.$s$wdisjointSubtrees
|
|
| 2010 | + = \ (@a)
|
|
| 2011 | + (@b)
|
|
| 2012 | + (ww :: GHC.Internal.Prim.Int#)
|
|
| 2013 | + (ds :: HashMap String a)
|
|
| 2014 | + (_b :: HashMap String b) ->
|
|
| 2015 | + join {
|
|
| 2016 | + fail [Dmd=MC(1,L)] :: (# #) -> Bool
|
|
| 2017 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<A>, Unf=OtherCon []]
|
|
| 2018 | + fail (ds1 [Occ=Dead, OS=OneShot] :: (# #))
|
|
| 2019 | + = case _b of wild {
|
|
| 2020 | + __DEFAULT -> case lvl1 of {};
|
|
| 2021 | + T26615a.Empty -> GHC.Internal.Types.True;
|
|
| 2022 | + T26615a.Leaf bx ds2 ->
|
|
| 2023 | + case ds2 of { T26615a.L kB ds3 ->
|
|
| 2024 | + $wpoly_lookupCont_ @a bx kB ww ds
|
|
| 2025 | + };
|
|
| 2026 | + T26615a.Collision bx bx1 ->
|
|
| 2027 | + T26615.$s$wdisjointSubtrees @b @a ww wild ds
|
|
| 2028 | + } } in
|
|
| 2029 | + case ds of wild {
|
|
| 2030 | + T26615a.Empty -> GHC.Internal.Types.True;
|
|
| 2031 | + T26615a.Leaf bx ds1 ->
|
|
| 2032 | + case ds1 of { T26615a.L kA ds2 ->
|
|
| 2033 | + case _b of wild2 {
|
|
| 2034 | + __DEFAULT -> $wpoly_lookupCont_ @b bx kA ww wild2;
|
|
| 2035 | + T26615a.Leaf bx1 ds3 ->
|
|
| 2036 | + case ds3 of { T26615a.L kB ds4 ->
|
|
| 2037 | + case GHC.Internal.Prim.neWord# bx bx1 of {
|
|
| 2038 | + __DEFAULT ->
|
|
| 2039 | + case GHC.Internal.Classes.$fEqList_$s$c==1 kA kB of {
|
|
| 2040 | + False -> GHC.Internal.Types.True;
|
|
| 2041 | + True -> GHC.Internal.Types.False
|
|
| 2042 | + };
|
|
| 2043 | + 1# -> GHC.Internal.Types.True
|
|
| 2044 | + }
|
|
| 2045 | + }
|
|
| 2046 | + }
|
|
| 2047 | + };
|
|
| 2048 | + T26615a.Collision bx bx1 ->
|
|
| 2049 | + case _b of {
|
|
| 2050 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 2051 | + T26615a.Collision bx2 bx3 ->
|
|
| 2052 | + case GHC.Internal.Prim.eqWord# bx bx2 of {
|
|
| 2053 | + __DEFAULT -> GHC.Internal.Types.True;
|
|
| 2054 | + 1# ->
|
|
| 2055 | + let {
|
|
| 2056 | + lvl2 :: GHC.Internal.Prim.Int#
|
|
| 2057 | + [LclId]
|
|
| 2058 | + lvl2
|
|
| 2059 | + = GHC.Internal.Prim.sizeofSmallArray#
|
|
| 2060 | + @GHC.Internal.Types.Lifted @(T26615a.Leaf String b) bx3 } in
|
|
| 2061 | + joinrec {
|
|
| 2062 | + $s$wfoldr_ [InlPrag=[2],
|
|
| 2063 | + Occ=LoopBreaker,
|
|
| 2064 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 2065 | + :: GHC.Internal.Prim.SmallArray# (T26615a.Leaf [Char] a)
|
|
| 2066 | + -> GHC.Internal.Prim.Int# -> GHC.Internal.Prim.Int# -> Bool -> Bool
|
|
| 2067 | + [LclId[JoinId(4)(Nothing)],
|
|
| 2068 | + Arity=4,
|
|
| 2069 | + Str=<L><L><L><L>,
|
|
| 2070 | + Unf=OtherCon []]
|
|
| 2071 | + $s$wfoldr_ (sc
|
|
| 2072 | + :: GHC.Internal.Prim.SmallArray# (T26615a.Leaf [Char] a))
|
|
| 2073 | + (sc1 :: GHC.Internal.Prim.Int#)
|
|
| 2074 | + (sc2 :: GHC.Internal.Prim.Int#)
|
|
| 2075 | + (sc3 :: Bool)
|
|
| 2076 | + = case GHC.Internal.Prim.>=# sc2 sc1 of {
|
|
| 2077 | + __DEFAULT ->
|
|
| 2078 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2079 | + @GHC.Internal.Types.Lifted @(T26615a.Leaf String a) sc sc2
|
|
| 2080 | + of
|
|
| 2081 | + { (# ipv1 #) ->
|
|
| 2082 | + case ipv1 of { T26615a.L kA ds2 ->
|
|
| 2083 | + join {
|
|
| 2084 | + $j :: Bool
|
|
| 2085 | + [LclId[JoinId(0)(Nothing)]]
|
|
| 2086 | + $j = jump $s$wfoldr_ sc sc1 (GHC.Internal.Prim.+# sc2 1#) sc3 } in
|
|
| 2087 | + joinrec {
|
|
| 2088 | + $wlookupInArrayCont_ [InlPrag=[2],
|
|
| 2089 | + Occ=LoopBreaker,
|
|
| 2090 | + Dmd=SC(S,C(1,C(1,C(1,L))))]
|
|
| 2091 | + :: String
|
|
| 2092 | + -> GHC.Internal.Prim.SmallArray# (T26615a.Leaf String b)
|
|
| 2093 | + -> GHC.Internal.Prim.Int#
|
|
| 2094 | + -> GHC.Internal.Prim.Int#
|
|
| 2095 | + -> Bool
|
|
| 2096 | + [LclId[JoinId(4)(Just [!])],
|
|
| 2097 | + Arity=4,
|
|
| 2098 | + Str=<1L><L><L><L>,
|
|
| 2099 | + Unf=OtherCon []]
|
|
| 2100 | + $wlookupInArrayCont_ (k1 :: String)
|
|
| 2101 | + (ww1
|
|
| 2102 | + :: GHC.Internal.Prim.SmallArray#
|
|
| 2103 | + (T26615a.Leaf String b))
|
|
| 2104 | + (ww2 :: GHC.Internal.Prim.Int#)
|
|
| 2105 | + (ww3 :: GHC.Internal.Prim.Int#)
|
|
| 2106 | + = case k1 of k2 { __DEFAULT ->
|
|
| 2107 | + case GHC.Internal.Prim.>=# ww2 ww3 of {
|
|
| 2108 | + __DEFAULT ->
|
|
| 2109 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2110 | + @GHC.Internal.Types.Lifted
|
|
| 2111 | + @(T26615a.Leaf String b)
|
|
| 2112 | + ww1
|
|
| 2113 | + ww2
|
|
| 2114 | + of
|
|
| 2115 | + { (# ipv5 #) ->
|
|
| 2116 | + case ipv5 of { T26615a.L kx v ->
|
|
| 2117 | + case GHC.Internal.Base.eqString k2 kx of {
|
|
| 2118 | + False ->
|
|
| 2119 | + jump $wlookupInArrayCont_
|
|
| 2120 | + k2 ww1 (GHC.Internal.Prim.+# ww2 1#) ww3;
|
|
| 2121 | + True -> GHC.Internal.Types.False
|
|
| 2122 | + }
|
|
| 2123 | + }
|
|
| 2124 | + };
|
|
| 2125 | + 1# -> jump $j
|
|
| 2126 | + }
|
|
| 2127 | + }; } in
|
|
| 2128 | + jump $wlookupInArrayCont_ kA bx3 0# lvl2
|
|
| 2129 | + }
|
|
| 2130 | + };
|
|
| 2131 | + 1# -> sc3
|
|
| 2132 | + }; } in
|
|
| 2133 | + jump $s$wfoldr_
|
|
| 2134 | + bx1
|
|
| 2135 | + (GHC.Internal.Prim.sizeofSmallArray#
|
|
| 2136 | + @GHC.Internal.Types.Lifted @(T26615a.Leaf String a) bx1)
|
|
| 2137 | + 0#
|
|
| 2138 | + GHC.Internal.Types.True
|
|
| 2139 | + };
|
|
| 2140 | + T26615a.BitmapIndexed bx2 bx3 ->
|
|
| 2141 | + let {
|
|
| 2142 | + m :: GHC.Internal.Prim.Word#
|
|
| 2143 | + [LclId]
|
|
| 2144 | + m = GHC.Internal.Prim.uncheckedShiftL#
|
|
| 2145 | + 1##
|
|
| 2146 | + (GHC.Internal.Prim.word2Int#
|
|
| 2147 | + (GHC.Internal.Prim.and#
|
|
| 2148 | + (GHC.Internal.Prim.uncheckedShiftRL# bx ww) 31##)) } in
|
|
| 2149 | + case GHC.Internal.Prim.and# m bx2 of {
|
|
| 2150 | + __DEFAULT ->
|
|
| 2151 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2152 | + @GHC.Internal.Types.Lifted
|
|
| 2153 | + @(HashMap String b)
|
|
| 2154 | + bx3
|
|
| 2155 | + (GHC.Internal.Prim.word2Int#
|
|
| 2156 | + (GHC.Internal.Prim.popCnt#
|
|
| 2157 | + (GHC.Internal.Prim.and# bx2 (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2158 | + of
|
|
| 2159 | + { (# ipv #) ->
|
|
| 2160 | + T26615.$s$wdisjointSubtrees
|
|
| 2161 | + @a @b (GHC.Internal.Prim.+# ww 5#) wild ipv
|
|
| 2162 | + };
|
|
| 2163 | + 0## -> GHC.Internal.Types.True
|
|
| 2164 | + };
|
|
| 2165 | + T26615a.Full bx2 ->
|
|
| 2166 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2167 | + @GHC.Internal.Types.Lifted
|
|
| 2168 | + @(HashMap String b)
|
|
| 2169 | + bx2
|
|
| 2170 | + (GHC.Internal.Prim.word2Int#
|
|
| 2171 | + (GHC.Internal.Prim.and#
|
|
| 2172 | + (GHC.Internal.Prim.uncheckedShiftRL# bx ww) 31##))
|
|
| 2173 | + of
|
|
| 2174 | + { (# ipv #) ->
|
|
| 2175 | + T26615.$s$wdisjointSubtrees
|
|
| 2176 | + @a @b (GHC.Internal.Prim.+# ww 5#) wild ipv
|
|
| 2177 | + }
|
|
| 2178 | + };
|
|
| 2179 | + T26615a.BitmapIndexed bx bx1 ->
|
|
| 2180 | + case _b of {
|
|
| 2181 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 2182 | + T26615a.BitmapIndexed bx2 bx3 ->
|
|
| 2183 | + case GHC.Internal.Prim.and# bx bx2 of wild2 {
|
|
| 2184 | + __DEFAULT ->
|
|
| 2185 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 2186 | + @(*)
|
|
| 2187 | + @(GHC.Internal.Prim.SmallArray# (HashMap String a)
|
|
| 2188 | + -> GHC.Internal.Prim.SmallArray# (HashMap String b)
|
|
| 2189 | + -> GHC.Internal.Prim.Int#)
|
|
| 2190 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 2191 | + -> GHC.Internal.Types.UnusedType 1 "b" -> GHC.Internal.Prim.Int#)
|
|
| 2192 | + of
|
|
| 2193 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 2194 | + case GHC.Internal.Prim.reallyUnsafePtrEquality#
|
|
| 2195 | + @GHC.Internal.Types.Lifted
|
|
| 2196 | + @GHC.Internal.Types.Lifted
|
|
| 2197 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 2198 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 2199 | + (bx1
|
|
| 2200 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 2201 | + :: GHC.Internal.Prim.SmallArray# (HashMap String a)
|
|
| 2202 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 2203 | + (bx3
|
|
| 2204 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 2205 | + :: GHC.Internal.Prim.SmallArray# (HashMap String b)
|
|
| 2206 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 2207 | + of {
|
|
| 2208 | + __DEFAULT ->
|
|
| 2209 | + joinrec {
|
|
| 2210 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)]
|
|
| 2211 | + :: GHC.Internal.Prim.Word# -> Bool
|
|
| 2212 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 2213 | + $wgo (ww1 :: GHC.Internal.Prim.Word#)
|
|
| 2214 | + = case ww1 of ds3 {
|
|
| 2215 | + __DEFAULT ->
|
|
| 2216 | + let {
|
|
| 2217 | + m :: GHC.Internal.Prim.Word#
|
|
| 2218 | + [LclId]
|
|
| 2219 | + m = GHC.Internal.Prim.and#
|
|
| 2220 | + ds3
|
|
| 2221 | + (GHC.Internal.Prim.int2Word#
|
|
| 2222 | + (GHC.Internal.Prim.negateInt#
|
|
| 2223 | + (GHC.Internal.Prim.word2Int# ds3))) } in
|
|
| 2224 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2225 | + @GHC.Internal.Types.Lifted
|
|
| 2226 | + @(HashMap String a)
|
|
| 2227 | + bx1
|
|
| 2228 | + (GHC.Internal.Prim.word2Int#
|
|
| 2229 | + (GHC.Internal.Prim.popCnt#
|
|
| 2230 | + (GHC.Internal.Prim.and#
|
|
| 2231 | + bx (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2232 | + of
|
|
| 2233 | + { (# ipv #) ->
|
|
| 2234 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2235 | + @GHC.Internal.Types.Lifted
|
|
| 2236 | + @(HashMap String b)
|
|
| 2237 | + bx3
|
|
| 2238 | + (GHC.Internal.Prim.word2Int#
|
|
| 2239 | + (GHC.Internal.Prim.popCnt#
|
|
| 2240 | + (GHC.Internal.Prim.and#
|
|
| 2241 | + bx2 (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2242 | + of
|
|
| 2243 | + { (# ipv1 #) ->
|
|
| 2244 | + case T26615.$s$wdisjointSubtrees
|
|
| 2245 | + @a @b (GHC.Internal.Prim.+# ww 5#) ipv ipv1
|
|
| 2246 | + of {
|
|
| 2247 | + False -> GHC.Internal.Types.False;
|
|
| 2248 | + True ->
|
|
| 2249 | + jump $wgo
|
|
| 2250 | + (GHC.Internal.Prim.and# ds3 (GHC.Internal.Prim.not# m))
|
|
| 2251 | + }
|
|
| 2252 | + }
|
|
| 2253 | + };
|
|
| 2254 | + 0## -> GHC.Internal.Types.True
|
|
| 2255 | + }; } in
|
|
| 2256 | + jump $wgo wild2;
|
|
| 2257 | + 1# -> GHC.Internal.Types.False
|
|
| 2258 | + }
|
|
| 2259 | + };
|
|
| 2260 | + 0## -> GHC.Internal.Types.True
|
|
| 2261 | + };
|
|
| 2262 | + T26615a.Full bx2 ->
|
|
| 2263 | + joinrec {
|
|
| 2264 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)]
|
|
| 2265 | + :: GHC.Internal.Prim.Word# -> Bool
|
|
| 2266 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 2267 | + $wgo (ww1 :: GHC.Internal.Prim.Word#)
|
|
| 2268 | + = case ww1 of ds3 {
|
|
| 2269 | + __DEFAULT ->
|
|
| 2270 | + let {
|
|
| 2271 | + m :: GHC.Internal.Prim.Word#
|
|
| 2272 | + [LclId]
|
|
| 2273 | + m = GHC.Internal.Prim.and#
|
|
| 2274 | + ds3
|
|
| 2275 | + (GHC.Internal.Prim.int2Word#
|
|
| 2276 | + (GHC.Internal.Prim.negateInt#
|
|
| 2277 | + (GHC.Internal.Prim.word2Int# ds3))) } in
|
|
| 2278 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2279 | + @GHC.Internal.Types.Lifted
|
|
| 2280 | + @(HashMap String a)
|
|
| 2281 | + bx1
|
|
| 2282 | + (GHC.Internal.Prim.word2Int#
|
|
| 2283 | + (GHC.Internal.Prim.popCnt#
|
|
| 2284 | + (GHC.Internal.Prim.and#
|
|
| 2285 | + bx (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2286 | + of
|
|
| 2287 | + { (# ipv #) ->
|
|
| 2288 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2289 | + @GHC.Internal.Types.Lifted
|
|
| 2290 | + @(HashMap String b)
|
|
| 2291 | + bx2
|
|
| 2292 | + (GHC.Internal.Prim.word2Int#
|
|
| 2293 | + (GHC.Internal.Prim.popCnt#
|
|
| 2294 | + (GHC.Internal.Prim.and#
|
|
| 2295 | + 4294967295## (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2296 | + of
|
|
| 2297 | + { (# ipv1 #) ->
|
|
| 2298 | + case T26615.$s$wdisjointSubtrees
|
|
| 2299 | + @a @b (GHC.Internal.Prim.+# ww 5#) ipv ipv1
|
|
| 2300 | + of {
|
|
| 2301 | + False -> GHC.Internal.Types.False;
|
|
| 2302 | + True ->
|
|
| 2303 | + jump $wgo (GHC.Internal.Prim.and# ds3 (GHC.Internal.Prim.not# m))
|
|
| 2304 | + }
|
|
| 2305 | + }
|
|
| 2306 | + };
|
|
| 2307 | + 0## -> GHC.Internal.Types.True
|
|
| 2308 | + }; } in
|
|
| 2309 | + jump $wgo (GHC.Internal.Prim.and# bx 4294967295##)
|
|
| 2310 | + };
|
|
| 2311 | + T26615a.Full bx ->
|
|
| 2312 | + case _b of {
|
|
| 2313 | + __DEFAULT -> jump fail GHC.Internal.Types.(##);
|
|
| 2314 | + T26615a.BitmapIndexed bx1 bx2 ->
|
|
| 2315 | + joinrec {
|
|
| 2316 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)]
|
|
| 2317 | + :: GHC.Internal.Prim.Word# -> Bool
|
|
| 2318 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<1L>, Unf=OtherCon []]
|
|
| 2319 | + $wgo (ww1 :: GHC.Internal.Prim.Word#)
|
|
| 2320 | + = case ww1 of ds3 {
|
|
| 2321 | + __DEFAULT ->
|
|
| 2322 | + let {
|
|
| 2323 | + m :: GHC.Internal.Prim.Word#
|
|
| 2324 | + [LclId]
|
|
| 2325 | + m = GHC.Internal.Prim.and#
|
|
| 2326 | + ds3
|
|
| 2327 | + (GHC.Internal.Prim.int2Word#
|
|
| 2328 | + (GHC.Internal.Prim.negateInt#
|
|
| 2329 | + (GHC.Internal.Prim.word2Int# ds3))) } in
|
|
| 2330 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2331 | + @GHC.Internal.Types.Lifted
|
|
| 2332 | + @(HashMap String a)
|
|
| 2333 | + bx
|
|
| 2334 | + (GHC.Internal.Prim.word2Int#
|
|
| 2335 | + (GHC.Internal.Prim.popCnt#
|
|
| 2336 | + (GHC.Internal.Prim.and#
|
|
| 2337 | + 4294967295## (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2338 | + of
|
|
| 2339 | + { (# ipv #) ->
|
|
| 2340 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2341 | + @GHC.Internal.Types.Lifted
|
|
| 2342 | + @(HashMap String b)
|
|
| 2343 | + bx2
|
|
| 2344 | + (GHC.Internal.Prim.word2Int#
|
|
| 2345 | + (GHC.Internal.Prim.popCnt#
|
|
| 2346 | + (GHC.Internal.Prim.and#
|
|
| 2347 | + bx1 (GHC.Internal.Prim.minusWord# m 1##))))
|
|
| 2348 | + of
|
|
| 2349 | + { (# ipv1 #) ->
|
|
| 2350 | + case T26615.$s$wdisjointSubtrees
|
|
| 2351 | + @a @b (GHC.Internal.Prim.+# ww 5#) ipv ipv1
|
|
| 2352 | + of {
|
|
| 2353 | + False -> GHC.Internal.Types.False;
|
|
| 2354 | + True ->
|
|
| 2355 | + jump $wgo (GHC.Internal.Prim.and# ds3 (GHC.Internal.Prim.not# m))
|
|
| 2356 | + }
|
|
| 2357 | + }
|
|
| 2358 | + };
|
|
| 2359 | + 0## -> GHC.Internal.Types.True
|
|
| 2360 | + }; } in
|
|
| 2361 | + jump $wgo (GHC.Internal.Prim.and# 4294967295## bx1);
|
|
| 2362 | + T26615a.Full bx1 ->
|
|
| 2363 | + case GHC.Internal.Unsafe.Coerce.unsafeEqualityProof
|
|
| 2364 | + @(*)
|
|
| 2365 | + @(GHC.Internal.Prim.SmallArray# (HashMap String a)
|
|
| 2366 | + -> GHC.Internal.Prim.SmallArray# (HashMap String b)
|
|
| 2367 | + -> GHC.Internal.Prim.Int#)
|
|
| 2368 | + @(GHC.Internal.Types.UnusedType 0 "a"
|
|
| 2369 | + -> GHC.Internal.Types.UnusedType 1 "b" -> GHC.Internal.Prim.Int#)
|
|
| 2370 | + of
|
|
| 2371 | + { GHC.Internal.Unsafe.Coerce.UnsafeRefl v2 ->
|
|
| 2372 | + case GHC.Internal.Prim.reallyUnsafePtrEquality#
|
|
| 2373 | + @GHC.Internal.Types.Lifted
|
|
| 2374 | + @GHC.Internal.Types.Lifted
|
|
| 2375 | + @(GHC.Internal.Types.UnusedType 0 "a")
|
|
| 2376 | + @(GHC.Internal.Types.UnusedType 1 "b")
|
|
| 2377 | + (bx
|
|
| 2378 | + `cast` (SelCo:Fun(arg) (Sub (Sym v2))
|
|
| 2379 | + :: GHC.Internal.Prim.SmallArray# (HashMap String a)
|
|
| 2380 | + ~R# GHC.Internal.Types.UnusedType 0 "a"))
|
|
| 2381 | + (bx1
|
|
| 2382 | + `cast` (SelCo:Fun(arg) (SelCo:Fun(res) (Sub (Sym v2)))
|
|
| 2383 | + :: GHC.Internal.Prim.SmallArray# (HashMap String b)
|
|
| 2384 | + ~R# GHC.Internal.Types.UnusedType 1 "b"))
|
|
| 2385 | + of {
|
|
| 2386 | + __DEFAULT ->
|
|
| 2387 | + joinrec {
|
|
| 2388 | + $wgo [InlPrag=[2], Occ=LoopBreaker, Dmd=SC(S,L)]
|
|
| 2389 | + :: GHC.Internal.Prim.Int# -> Bool
|
|
| 2390 | + [LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
|
|
| 2391 | + $wgo (ww1 :: GHC.Internal.Prim.Int#)
|
|
| 2392 | + = case GHC.Internal.Prim.<# ww1 0# of {
|
|
| 2393 | + __DEFAULT ->
|
|
| 2394 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2395 | + @GHC.Internal.Types.Lifted @(HashMap String a) bx ww1
|
|
| 2396 | + of
|
|
| 2397 | + { (# ipv #) ->
|
|
| 2398 | + case GHC.Internal.Prim.indexSmallArray#
|
|
| 2399 | + @GHC.Internal.Types.Lifted @(HashMap String b) bx1 ww1
|
|
| 2400 | + of
|
|
| 2401 | + { (# ipv1 #) ->
|
|
| 2402 | + case T26615.$s$wdisjointSubtrees
|
|
| 2403 | + @a @b (GHC.Internal.Prim.+# ww 5#) ipv ipv1
|
|
| 2404 | + of {
|
|
| 2405 | + False -> GHC.Internal.Types.False;
|
|
| 2406 | + True -> jump $wgo (GHC.Internal.Prim.-# ww1 1#)
|
|
| 2407 | + }
|
|
| 2408 | + }
|
|
| 2409 | + };
|
|
| 2410 | + 1# -> GHC.Internal.Types.True
|
|
| 2411 | + }; } in
|
|
| 2412 | + jump $wgo 31#;
|
|
| 2413 | + 1# -> GHC.Internal.Types.False
|
|
| 2414 | + }
|
|
| 2415 | + }
|
|
| 2416 | + }
|
|
| 2417 | + }
|
|
| 2418 | +end Rec }
|
|
| 2419 | + |
|
| 2420 | +-- RHS size: {terms: 8, types: 10, coercions: 0, joins: 0/0}
|
|
| 2421 | +f :: forall a b. HashMap String a -> HashMap String b -> Bool
|
|
| 2422 | +[GblId,
|
|
| 2423 | + Arity=2,
|
|
| 2424 | + Str=<SL><L>,
|
|
| 2425 | + Unf=Unf{Src=<vanilla>, TopLvl=True,
|
|
| 2426 | + Value=True, ConLike=True, WorkFree=True, Expandable=True,
|
|
| 2427 | + Guidance=IF_ARGS [0 0] 40 0}]
|
|
| 2428 | +f = \ (@a)
|
|
| 2429 | + (@b)
|
|
| 2430 | + (ds :: HashMap String a)
|
|
| 2431 | + (_b :: HashMap String b) ->
|
|
| 2432 | + T26615.$s$wdisjointSubtrees @a @b 0# ds _b
|
|
| 2433 | + |
|
| 2434 | + |
|
| 2435 | +------ Local rules for imported ids --------
|
|
| 2436 | +"SPEC/T26615 $wdisjointSubtrees @String @_ @_" [2]
|
|
| 2437 | + forall (@a) (@b) ($dEq [Occ=Dead] :: Eq String).
|
|
| 2438 | + T26615a.$wdisjointSubtrees @String @a @b $dEq
|
|
| 2439 | + = T26615.$s$wdisjointSubtrees @a @b
|
|
| 2440 | + |
|
| 2441 | + |
| ... | ... | @@ -14,15 +14,15 @@ T13292a.hs:4:12: warning: [GHC-39999] [-Wdeferred-type-errors (in -Wdefault)] |
| 14 | 14 | In an equation for ‘someFunc’: someFunc = return ()
|
| 15 | 15 | |
| 16 | 16 | T13292.hs:6:1: warning: [GHC-83865] [-Wdeferred-type-errors (in -Wdefault)]
|
| 17 | - • Couldn't match type ‘GHC.Types.ZonkAny 0’ with ‘IO’
|
|
| 17 | + • Couldn't match type ‘m00’ with ‘IO’
|
|
| 18 | 18 | Expected: IO ()
|
| 19 | - Actual: GHC.Types.ZonkAny 0 ()
|
|
| 19 | + Actual: m00
|
|
| 20 | 20 | • When checking the type of the IO action ‘main’
|
| 21 | 21 | |
| 22 | 22 | T13292.hs:6:1: warning: [GHC-83865] [-Wdeferred-type-errors (in -Wdefault)]
|
| 23 | - • Couldn't match type ‘GHC.Types.ZonkAny 0’ with ‘IO’
|
|
| 23 | + • Couldn't match type ‘m00’ with ‘IO’
|
|
| 24 | 24 | Expected: IO ()
|
| 25 | - Actual: GHC.Types.ZonkAny 0 ()
|
|
| 25 | + Actual: m00
|
|
| 26 | 26 | • In the expression: main
|
| 27 | 27 | When checking the type of the IO action ‘main’
|
| 28 | 28 |