GHC.Core.Opt renaming

* GHC.Core.Op                  => GHC.Core.Opt
* GHC.Core.Opt.Simplify.Driver => GHC.Core.Opt.Driver
* GHC.Core.Opt.Tidy            => GHC.Core.Tidy
* GHC.Core.Opt.WorkWrap.Lib    => GHC.Core.Opt.WorkWrap.Utils

As discussed in:
 * https://mail.haskell.org/pipermail/ghc-devs/2020-April/018758.html
 * https://gitlab.haskell.org/ghc/ghc/issues/13009#note_264650

4 files changed, 8 insertions, 8 deletions

diff --git a/libraries/base/Data/Foldable.hs b/libraries/base/Data/Foldable.hs
index 2ca70bcb89..98dd072a91 100644
--- a/libraries/base/Data/Foldable.hs
+++ b/libraries/base/Data/Foldable.hs
@@ -1227,7 +1227,7 @@ Now we get
 
 Notice that `f` does not inline into the RHS of `c`,
 because the INLINE pragma stops it; see
-Note [Simplifying inside stable unfoldings] in GHC.Core.Op.Simplify.Utils.
+Note [Simplifying inside stable unfoldings] in GHC.Core.Opt.Simplify.Utils.
 Continuing:
 
   = { foldr/build rule }
diff --git a/libraries/base/GHC/Base.hs b/libraries/base/GHC/Base.hs
index 610e2996a8..8b78f001ca 100644
--- a/libraries/base/GHC/Base.hs
+++ b/libraries/base/GHC/Base.hs
@@ -1358,7 +1358,7 @@ eqString (c1:cs1) (c2:cs2) = c1 == c2 && cs1 `eqString` cs2
 eqString _        _        = False
 
 {-# RULES "eqString" (==) = eqString #-}
--- eqString also has a BuiltInRule in GHC.Core.Op.ConstantFold:
+-- eqString also has a BuiltInRule in GHC.Core.Opt.ConstantFold:
 --      eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)) = s1==s2
 
 
@@ -1624,7 +1624,7 @@ a `iShiftRL#` b | isTrue# (b >=# WORD_SIZE_IN_BITS#) = 0#
 "unpack-list"  [1]  forall a   . unpackFoldrCString# a (:) [] = unpackCString# a
 "unpack-append"     forall a n . unpackFoldrCString# a (:) n  = unpackAppendCString# a n
 
--- There's a built-in rule (in GHC.Core.Op.ConstantFold) for
+-- There's a built-in rule (in GHC.Core.Opt.ConstantFold) for
 --      unpackFoldr "foo" c (unpackFoldr "baz" c n)  =  unpackFoldr "foobaz" c n
 
   #-}
diff --git a/libraries/base/GHC/Real.hs b/libraries/base/GHC/Real.hs
index 295b0131bb..38a3aa2870 100644
--- a/libraries/base/GHC/Real.hs
+++ b/libraries/base/GHC/Real.hs
@@ -417,7 +417,7 @@ instance Real Natural where
 --
 -- Constant folding of quot, rem, div, mod, divMod and quotRem for
 -- Integer arguments depends crucially on inlining. Constant folding
--- rules defined in GHC.Core.Op.ConstantFold trigger for
+-- rules defined in GHC.Core.Opt.ConstantFold trigger for
 -- quotInteger, remInteger and so on. So if calls to quot, rem and so on
 -- were not inlined the rules would not fire. The rules would also not
 -- fire if calls to quotInteger and so on were inlined, but this does not
diff --git a/libraries/ghc-prim/GHC/CString.hs b/libraries/ghc-prim/GHC/CString.hs
index 3ae4d50532..8c0d272a67 100644
--- a/libraries/ghc-prim/GHC/CString.hs
+++ b/libraries/ghc-prim/GHC/CString.hs
@@ -46,7 +46,7 @@ is a waste.
 Moreover, inlining early may interfere with a variety of rules that are supposed
 to match unpackCString#,
 
- * BuiltInRules in GHC.Core.Op.ConstantFold; e.g.
+ * BuiltInRules in GHC.Core.Opt.ConstantFold; e.g.
        eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)
           = s1 == s2
 
@@ -60,8 +60,8 @@ to match unpackCString#,
 
 Moreover, we want to make it CONLIKE, so that:
 
-* the rules in GHC.Core.Op.ConstantFold will fire when the string is let-bound.
-  E.g. the eqString rule in GHC.Core.Op.ConstantFold
+* the rules in GHC.Core.Opt.ConstantFold will fire when the string is let-bound.
+  E.g. the eqString rule in GHC.Core.Opt.ConstantFold
    eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2) = s1==s2
 
 * exprIsConApp_maybe will see the string when we have
@@ -115,7 +115,7 @@ unpackFoldrCString# :: Addr# -> (Char  -> a -> a) -> a -> a
 
 -- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString#
 
--- It also has a BuiltInRule in GHC.Core.Op.ConstantFold:
+-- It also has a BuiltInRule in GHC.Core.Opt.ConstantFold:
 --      unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)
 --        =  unpackFoldrCString# "foobaz" c n