[GHC] #9352: Allow `State# s` argument/result types in `ccall` FFI imports

[GHC]

#9352: Allow `State# s` argument/result types in `ccall` FFI imports
-------------------------------------+-------------------------------------
              Reporter:  hvr         |            Owner:
                  Type:  feature     |           Status:  new
  request                            |        Milestone:  7.10.1
              Priority:  normal      |          Version:  7.8.2
             Component:  Compiler    |         Keywords:
  (Type checker)                     |     Architecture:  Unknown/Multiple
            Resolution:              |       Difficulty:  Unknown
      Operating System:              |       Blocked By:
  Unknown/Multiple                   |  Related Tickets:  #9281
       Type of failure:              |
  None/Unknown                       |
             Test Case:              |
              Blocking:              |
Differential Revisions:              |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 Simon M: looking into the code, I'm quite perplexed.  Have a look at:
 DsCCall.boxResult.  It seems the when we say
 {{{
 foreign import foo :: Int -> Int
 }}}
 we actually generate (in effect) an inline use of `unsafePerformIO`.
 Here's the tidy core:
 {{{
 M.foo :: GHC.Types.Int -> GHC.Types.Int
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType]
 M.foo =
   \ (ds_d1A2 :: GHC.Types.Int) ->
     case ds_d1A2 of _ [Occ=Dead] { GHC.Types.I# ds2_d1A4 ->
     case {__pkg_ccall main foo Int#
                       -> State# RealWorld -> (# State# RealWorld, Int#
 #)}_d1A7
            ds2_d1A4 GHC.Prim.realWorld#
     of _ [Occ=Dead] { (# ds3_d1A6, ds4_d1A5 #) ->
     GHC.Types.I# ds4_d1A5 } }
 }}}
 Note that we come up with a `realWorld#` out of thin air and then discard
 it again... that's the `unsafePerformIO` stuff.  Then the code generator
 has to painstakingly discard all that state-passing nonsense, to get back
 to a simple C call to "foo".

 Why do we bother with this?  Why not produce this core:
 {{{
 M.foo :: GHC.Types.Int -> GHC.Types.Int
 M.foo =
   \ (ds_d1A2 :: GHC.Types.Int) ->
     case ds_d1A2 of _ [Occ=Dead] { GHC.Types.I# ds2_d1A4 ->
     case {__pkg_ccall main foo Int# -> Int#}_d1A7
            ds2_d1A4
     of ds4_d1A5 [Occ=Dead] { DEFAULT ->
     GHC.Types.I# ds4_d1A5 } }
 }}}
 Simpler, more direct, and should generate exactly the same code.  At the
 moment the built-in `FCallId` Ids always have an IO-ish type, but I see no
 reason to require that.

 If we did this, then I think the distinction between `boxResult` and
 `resultWrapper` could disappear, leading to a simpler, compositional
 structur.

 Moreover, if we want to accommodate
 {{{
 foreign import foo :: Int -> State# s -> (# State# s, Int #)
 }}}
 which doesn't have an IO-ish type (at least not built with the `IO` type
 constructor), it would seem utterly bizarre to enclose it in the
 `unsafePerformIO` boilerplate as above.

 I think Herbert might be able to act on all this, but first let's check
 that I have not forgotten anything stupid.

 Simon

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9352#comment:5>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler