Use "to" instead of "2" in internal names of conversion ops

Change the constructors for the primop union, and also names of the
literal conversion functions.

"2" runs into trouble when we need to do conversions from fixed-width
types, and end up with thing like "Int642Word".

Only the names internal to GHC are changed, as I don't want to worry
about breaking changes ATM.

4 files changed, 70 insertions, 70 deletions

diff --git a/compiler/GHC/Builtin/primops.txt.pp b/compiler/GHC/Builtin/primops.txt.pp
index 59f31faf57..9cbe75be35 100644
--- a/compiler/GHC/Builtin/primops.txt.pp
+++ b/compiler/GHC/Builtin/primops.txt.pp
@@ -603,14 +603,14 @@ primop   IntLeOp  "<=#"   Compare   Int# -> Int# -> Int#
 primop   ChrOp   "chr#"   GenPrimOp   Int# -> Char#
    with code_size = 0
 
-primop   Int2WordOp "int2Word#" GenPrimOp Int# -> Word#
+primop   IntToWordOp "int2Word#" GenPrimOp Int# -> Word#
    with code_size = 0
 
-primop   Int2FloatOp   "int2Float#"      GenPrimOp  Int# -> Float#
-primop   Int2DoubleOp   "int2Double#"          GenPrimOp  Int# -> Double#
+primop   IntToFloatOp   "int2Float#"      GenPrimOp  Int# -> Float#
+primop   IntToDoubleOp   "int2Double#"          GenPrimOp  Int# -> Double#
 
-primop   Word2FloatOp   "word2Float#"      GenPrimOp  Word# -> Float#
-primop   Word2DoubleOp   "word2Double#"          GenPrimOp  Word# -> Double#
+primop   WordToFloatOp   "word2Float#"      GenPrimOp  Word# -> Float#
+primop   WordToDoubleOp   "word2Double#"          GenPrimOp  Word# -> Double#
 
 primop   ISllOp   "uncheckedIShiftL#" GenPrimOp  Int# -> Int# -> Int#
          {Shift left.  Result undefined if shift amount is not
@@ -696,7 +696,7 @@ primop   SrlOp   "uncheckedShiftRL#"   GenPrimOp   Word# -> Int# -> Word#
          {Shift right logical.   Result undefined if shift  amount is not
           in the range 0 to word size - 1 inclusive.}
 
-primop   Word2IntOp   "word2Int#"   GenPrimOp   Word# -> Int#
+primop   WordToIntOp   "word2Int#"   GenPrimOp   Word# -> Int#
    with code_size = 0
 
 primop   WordGtOp   "gtWord#"   Compare   Word# -> Word# -> Int#
@@ -844,12 +844,12 @@ primop   DoubleNegOp   "negateDouble#"  GenPrimOp   Double# -> Double#
 
 primop   DoubleFabsOp  "fabsDouble#"    GenPrimOp   Double# -> Double#
 
-primop   Double2IntOp   "double2Int#"          GenPrimOp  Double# -> Int#
+primop   DoubleToIntOp   "double2Int#"          GenPrimOp  Double# -> Int#
    {Truncates a {\tt Double#} value to the nearest {\tt Int#}.
     Results are undefined if the truncation if truncation yields
     a value outside the range of {\tt Int#}.}
 
-primop   Double2FloatOp   "double2Float#" GenPrimOp Double# -> Float#
+primop   DoubleToFloatOp   "double2Float#" GenPrimOp Double# -> Float#
 
 primop   DoubleExpOp   "expDouble#"      GenPrimOp
    Double# -> Double#
@@ -998,7 +998,7 @@ primop   FloatNegOp   "negateFloat#"      GenPrimOp    Float# -> Float#
 
 primop   FloatFabsOp  "fabsFloat#"        GenPrimOp    Float# -> Float#
 
-primop   Float2IntOp   "float2Int#"      GenPrimOp  Float# -> Int#
+primop   FloatToIntOp   "float2Int#"      GenPrimOp  Float# -> Int#
    {Truncates a {\tt Float#} value to the nearest {\tt Int#}.
     Results are undefined if the truncation if truncation yields
     a value outside the range of {\tt Int#}.}
@@ -1097,7 +1097,7 @@ primop   FloatPowerOp   "powerFloat#"      GenPrimOp
    with
    code_size = { primOpCodeSizeForeignCall }
 
-primop   Float2DoubleOp   "float2Double#" GenPrimOp  Float# -> Double#
+primop   FloatToDoubleOp   "float2Double#" GenPrimOp  Float# -> Double#
 
 primop   FloatDecode_IntOp   "decodeFloat_Int#" GenPrimOp
    Float# -> (# Int#, Int# #)
@@ -2283,11 +2283,11 @@ primop   AddrSubOp "minusAddr#" GenPrimOp Addr# -> Addr# -> Int#
 primop   AddrRemOp "remAddr#" GenPrimOp Addr# -> Int# -> Int#
          {Return the remainder when the {\tt Addr\#} arg, treated like an {\tt Int\#},
           is divided by the {\tt Int\#} arg.}
-primop   Addr2IntOp  "addr2Int#"     GenPrimOp   Addr# -> Int#
+primop   AddrToIntOp  "addr2Int#"     GenPrimOp   Addr# -> Int#
         {Coerce directly from address to int.}
    with code_size = 0
         deprecated_msg = { This operation is strongly deprecated. }
-primop   Int2AddrOp   "int2Addr#"    GenPrimOp  Int# -> Addr#
+primop   IntToAddrOp   "int2Addr#"    GenPrimOp  Int# -> Addr#
         {Coerce directly from int to address.}
    with code_size = 0
         deprecated_msg = { This operation is strongly deprecated. }
diff --git a/compiler/GHC/Core/Opt/ConstantFold.hs b/compiler/GHC/Core/Opt/ConstantFold.hs
index 8c44a5d72d..eaf7aa65e4 100644
--- a/compiler/GHC/Core/Opt/ConstantFold.hs
+++ b/compiler/GHC/Core/Opt/ConstantFold.hs
@@ -193,10 +193,10 @@ primOpRules nm = \case
    SrlOp       -> mkPrimOpRule nm 2 [ shiftRule LitNumWord shiftRightLogical ]
 
    -- coercions
-   Word2IntOp     -> mkPrimOpRule nm 1 [ liftLitPlatform word2IntLit
-                                       , inversePrimOp Int2WordOp ]
-   Int2WordOp     -> mkPrimOpRule nm 1 [ liftLitPlatform int2WordLit
-                                       , inversePrimOp Word2IntOp ]
+   WordToIntOp    -> mkPrimOpRule nm 1 [ liftLitPlatform wordToIntLit
+                                       , inversePrimOp IntToWordOp ]
+   IntToWordOp    -> mkPrimOpRule nm 1 [ liftLitPlatform intToWordLit
+                                       , inversePrimOp WordToIntOp ]
    Narrow8IntOp   -> mkPrimOpRule nm 1 [ liftLit narrow8IntLit
                                        , subsumedByPrimOp Narrow8IntOp
                                        , Narrow8IntOp `subsumesPrimOp` Narrow16IntOp
@@ -229,19 +229,19 @@ primOpRules nm = \case
                                        , subsumedByPrimOp Narrow32WordOp
                                        , removeOp32
                                        , narrowSubsumesAnd AndOp Narrow32WordOp 32 ]
-   OrdOp          -> mkPrimOpRule nm 1 [ liftLit char2IntLit
+   OrdOp          -> mkPrimOpRule nm 1 [ liftLit charToIntLit
                                        , inversePrimOp ChrOp ]
    ChrOp          -> mkPrimOpRule nm 1 [ do [Lit lit] <- getArgs
                                             guard (litFitsInChar lit)
-                                            liftLit int2CharLit
+                                            liftLit intToCharLit
                                        , inversePrimOp OrdOp ]
-   Float2IntOp    -> mkPrimOpRule nm 1 [ liftLit float2IntLit ]
-   Int2FloatOp    -> mkPrimOpRule nm 1 [ liftLit int2FloatLit ]
-   Double2IntOp   -> mkPrimOpRule nm 1 [ liftLit double2IntLit ]
-   Int2DoubleOp   -> mkPrimOpRule nm 1 [ liftLit int2DoubleLit ]
+   FloatToIntOp    -> mkPrimOpRule nm 1 [ liftLit floatToIntLit ]
+   IntToFloatOp    -> mkPrimOpRule nm 1 [ liftLit intToFloatLit ]
+   DoubleToIntOp   -> mkPrimOpRule nm 1 [ liftLit doubleToIntLit ]
+   IntToDoubleOp   -> mkPrimOpRule nm 1 [ liftLit intToDoubleLit ]
    -- SUP: Not sure what the standard says about precision in the following 2 cases
-   Float2DoubleOp -> mkPrimOpRule nm 1 [ liftLit float2DoubleLit ]
-   Double2FloatOp -> mkPrimOpRule nm 1 [ liftLit double2FloatLit ]
+   FloatToDoubleOp -> mkPrimOpRule nm 1 [ liftLit floatToDoubleLit ]
+   DoubleToFloatOp -> mkPrimOpRule nm 1 [ liftLit doubleToFloatLit ]
 
    -- Float
    FloatAddOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (+))
@@ -1364,9 +1364,9 @@ builtinBignumRules _ =
       , rule_passthrough      "Word# -> Integer -> Word#"       integerToWordName   integerFromWordName
       , rule_passthrough      "Int64# -> Integer -> Int64#"     integerToInt64Name  integerFromInt64Name
       , rule_passthrough      "Word64# -> Integer -> Word64#"   integerToWord64Name integerFromWord64Name
-      , rule_smallIntegerTo   "IS -> Word#"                     integerToWordName   Int2WordOp
-      , rule_smallIntegerTo   "IS -> Float"                     integerToFloatName  Int2FloatOp
-      , rule_smallIntegerTo   "IS -> Double"                    integerToDoubleName Int2DoubleOp
+      , rule_smallIntegerTo   "IS -> Word#"                     integerToWordName   IntToWordOp
+      , rule_smallIntegerTo   "IS -> Float"                     integerToFloatName  IntToFloatOp
+      , rule_smallIntegerTo   "IS -> Double"                    integerToDoubleName IntToDoubleOp
       , rule_passthrough      "Word# -> Natural -> Word#"       naturalToWordName   naturalNSDataConName
 
       , rule_IntegerToNaturalClamp "Integer -> Natural (clamp)" integerToNaturalClampName
diff --git a/compiler/GHC/StgToCmm/Prim.hs b/compiler/GHC/StgToCmm/Prim.hs
index 4c69537733..90cb963e89 100644
--- a/compiler/GHC/StgToCmm/Prim.hs
+++ b/compiler/GHC/StgToCmm/Prim.hs
@@ -840,9 +840,9 @@ emitPrimOp dflags primop = case primop of
     emitCtzCall res w (wordWidth platform)
 
 -- Unsigned int to floating point conversions
-  Word2FloatOp -> \[w] -> opIntoRegs $ \[res] -> do
+  WordToFloatOp -> \[w] -> opIntoRegs $ \[res] -> do
     emitPrimCall [res] (MO_UF_Conv W32) [w]
-  Word2DoubleOp -> \[w] -> opIntoRegs $ \[res] -> do
+  WordToDoubleOp -> \[w] -> opIntoRegs $ \[res] -> do
     emitPrimCall [res] (MO_UF_Conv W64) [w]
 
 -- Atomic operations
@@ -1056,10 +1056,10 @@ emitPrimOp dflags primop = case primop of
 
 -- The rest just translate straightforwardly
 
-  Int2WordOp      -> \args -> opNop args
-  Word2IntOp      -> \args -> opNop args
-  Int2AddrOp      -> \args -> opNop args
-  Addr2IntOp      -> \args -> opNop args
+  IntToWordOp     -> \args -> opNop args
+  WordToIntOp     -> \args -> opNop args
+  IntToAddrOp     -> \args -> opNop args
+  AddrToIntOp     -> \args -> opNop args
   ChrOp           -> \args -> opNop args  -- Int# and Char# are rep'd the same
   OrdOp           -> \args -> opNop args
 
@@ -1309,14 +1309,14 @@ emitPrimOp dflags primop = case primop of
 
 -- Conversions
 
-  Int2DoubleOp   -> \args -> opTranslate args (MO_SF_Conv (wordWidth platform) W64)
-  Double2IntOp   -> \args -> opTranslate args (MO_FS_Conv W64 (wordWidth platform))
+  IntToDoubleOp   -> \args -> opTranslate args (MO_SF_Conv (wordWidth platform) W64)
+  DoubleToIntOp   -> \args -> opTranslate args (MO_FS_Conv W64 (wordWidth platform))
 
-  Int2FloatOp    -> \args -> opTranslate args (MO_SF_Conv (wordWidth platform) W32)
-  Float2IntOp    -> \args -> opTranslate args (MO_FS_Conv W32 (wordWidth platform))
+  IntToFloatOp    -> \args -> opTranslate args (MO_SF_Conv (wordWidth platform) W32)
+  FloatToIntOp    -> \args -> opTranslate args (MO_FS_Conv W32 (wordWidth platform))
 
-  Float2DoubleOp -> \args -> opTranslate args (MO_FF_Conv W32 W64)
-  Double2FloatOp -> \args -> opTranslate args (MO_FF_Conv W64 W32)
+  FloatToDoubleOp -> \args -> opTranslate args (MO_FF_Conv W32 W64)
+  DoubleToFloatOp -> \args -> opTranslate args (MO_FF_Conv W64 W32)
 
 -- Word comparisons masquerading as more exotic things.
 
diff --git a/compiler/GHC/Types/Literal.hs b/compiler/GHC/Types/Literal.hs
index 16d4539630..97ab69563a 100644
--- a/compiler/GHC/Types/Literal.hs
+++ b/compiler/GHC/Types/Literal.hs
@@ -39,13 +39,13 @@ module GHC.Types.Literal
         , litValue, isLitValue, isLitValue_maybe, mapLitValue
 
         -- ** Coercions
-        , word2IntLit, int2WordLit
+        , wordToIntLit, intToWordLit
         , narrowLit
         , narrow8IntLit, narrow16IntLit, narrow32IntLit
         , narrow8WordLit, narrow16WordLit, narrow32WordLit
-        , char2IntLit, int2CharLit
-        , float2IntLit, int2FloatLit, double2IntLit, int2DoubleLit
-        , nullAddrLit, rubbishLit, float2DoubleLit, double2FloatLit
+        , charToIntLit, intToCharLit
+        , floatToIntLit, intToFloatLit, doubleToIntLit, intToDoubleLit
+        , nullAddrLit, rubbishLit, floatToDoubleLit, doubleToFloatLit
         ) where
 
 #include "HsVersions.h"
@@ -474,27 +474,27 @@ isLitValue = isJust . isLitValue_maybe
 
 narrow8IntLit, narrow16IntLit, narrow32IntLit,
   narrow8WordLit, narrow16WordLit, narrow32WordLit,
-  char2IntLit, int2CharLit,
-  float2IntLit, int2FloatLit, double2IntLit, int2DoubleLit,
-  float2DoubleLit, double2FloatLit
+  charToIntLit, intToCharLit,
+  floatToIntLit, intToFloatLit, doubleToIntLit, intToDoubleLit,
+  floatToDoubleLit, doubleToFloatLit
   :: Literal -> Literal
 
-word2IntLit, int2WordLit :: Platform -> Literal -> Literal
-word2IntLit platform (LitNumber LitNumWord w)
+wordToIntLit, intToWordLit :: Platform -> Literal -> Literal
+wordToIntLit platform (LitNumber LitNumWord w)
   -- Map Word range [max_int+1, max_word]
   -- to Int range   [min_int  , -1]
   -- Range [0,max_int] has the same representation with both Int and Word
   | w > platformMaxInt platform = mkLitInt platform (w - platformMaxWord platform - 1)
   | otherwise                   = mkLitInt platform w
-word2IntLit _ l = pprPanic "word2IntLit" (ppr l)
+wordToIntLit _ l = pprPanic "wordToIntLit" (ppr l)
 
-int2WordLit platform (LitNumber LitNumInt i)
+intToWordLit platform (LitNumber LitNumInt i)
   -- Map Int range [min_int  , -1]
   -- to Word range [max_int+1, max_word]
   -- Range [0,max_int] has the same representation with both Int and Word
   | i < 0     = mkLitWord platform (1 + platformMaxWord platform + i)
   | otherwise = mkLitWord platform i
-int2WordLit _ l = pprPanic "int2WordLit" (ppr l)
+intToWordLit _ l = pprPanic "intToWordLit" (ppr l)
 
 -- | Narrow a literal number (unchecked result range)
 narrowLit :: forall a. Integral a => Proxy a -> Literal -> Literal
@@ -508,25 +508,25 @@ narrow8WordLit  = narrowLit (Proxy :: Proxy Word8)
 narrow16WordLit = narrowLit (Proxy :: Proxy Word16)
 narrow32WordLit = narrowLit (Proxy :: Proxy Word32)
 
-char2IntLit (LitChar c)       = mkLitIntUnchecked (toInteger (ord c))
-char2IntLit l                 = pprPanic "char2IntLit" (ppr l)
-int2CharLit (LitNumber _ i)   = LitChar (chr (fromInteger i))
-int2CharLit l                 = pprPanic "int2CharLit" (ppr l)
-
-float2IntLit (LitFloat f)      = mkLitIntUnchecked (truncate f)
-float2IntLit l                 = pprPanic "float2IntLit" (ppr l)
-int2FloatLit (LitNumber _ i)   = LitFloat (fromInteger i)
-int2FloatLit l                 = pprPanic "int2FloatLit" (ppr l)
-
-double2IntLit (LitDouble f)     = mkLitIntUnchecked (truncate f)
-double2IntLit l                 = pprPanic "double2IntLit" (ppr l)
-int2DoubleLit (LitNumber _ i)   = LitDouble (fromInteger i)
-int2DoubleLit l                 = pprPanic "int2DoubleLit" (ppr l)
-
-float2DoubleLit (LitFloat  f) = LitDouble f
-float2DoubleLit l             = pprPanic "float2DoubleLit" (ppr l)
-double2FloatLit (LitDouble d) = LitFloat  d
-double2FloatLit l             = pprPanic "double2FloatLit" (ppr l)
+charToIntLit (LitChar c)       = mkLitIntUnchecked (toInteger (ord c))
+charToIntLit l                 = pprPanic "charToIntLit" (ppr l)
+intToCharLit (LitNumber _ i)   = LitChar (chr (fromInteger i))
+intToCharLit l                 = pprPanic "intToCharLit" (ppr l)
+
+floatToIntLit (LitFloat f)      = mkLitIntUnchecked (truncate f)
+floatToIntLit l                 = pprPanic "floatToIntLit" (ppr l)
+intToFloatLit (LitNumber _ i)   = LitFloat (fromInteger i)
+intToFloatLit l                 = pprPanic "intToFloatLit" (ppr l)
+
+doubleToIntLit (LitDouble f)     = mkLitIntUnchecked (truncate f)
+doubleToIntLit l                 = pprPanic "doubleToIntLit" (ppr l)
+intToDoubleLit (LitNumber _ i)   = LitDouble (fromInteger i)
+intToDoubleLit l                 = pprPanic "intToDoubleLit" (ppr l)
+
+floatToDoubleLit (LitFloat  f) = LitDouble f
+floatToDoubleLit l             = pprPanic "floatToDoubleLit" (ppr l)
+doubleToFloatLit (LitDouble d) = LitFloat  d
+doubleToFloatLit l             = pprPanic "doubleToFloatLit" (ppr l)
 
 nullAddrLit :: Literal
 nullAddrLit = LitNullAddr