INLINE and strictness

Consider this code

module A where
  {-# INLINE [0] foo #-}
  {#- RULE foo (reverse xs) = xs #-}
  foo xs = reverse $ xs

module B where
  import A( foo )
  g b ys = foo (case b of 
                  True -> reverse ys
                  False -> ys)

  h xs = map foo xs

At the moment the body of foo is not optimised at all, because it's going to be inlined. But that means that

• The foo executed by the map in h is very inefficient, because it actually calls $ etc.
• The strictness analyser doesn't see that foo is strict, because again the $ gets in the way. So the rule for foo does not match in the RHS of g. (If foo were strict, we'd push the call to foo inside the case branches.)

For both reasons it'd be better to

• Retain the original RHS of foo for inlining purposes
• But otherwise optimise foo normally, so that if it is not inlined, we get the efficient version, and so that strictness analysis does the right thing.

Hmm. Maybe INLINE should turn into a RULE, rather than (as now) a Note in Core?

Anyway, this ticket is to make sure I don't forget this point.

Trac metadata

Trac field	Value
Version	6.8.2
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC	ndp@cse.unsw.edu.au
Operating system	Unknown
Architecture	Unknown