GitLab

This patch teaches SpecConstr about casts; see Note [SpecConstr for casts]

Note [Float coercions]
~~~~~~~~~~~~~~~~~~~~~~
When we find the binding
	x = e `cast` co
we'd like to transform it to
	x' = e
	x = x `cast` co		-- A trivial binding
There's a chance that e will be a constructor application or function, or something
like that, so moving the coerion to the usage site may well cancel the coersions
and lead to further optimisation.  Example:

     data family T a :: *
     data instance T Int = T Int

     foo :: Int -> Int -> Int
     foo m n = ...
        where
          x = T m
          go 0 = 0
          go n = case x of { T m -> go (n-m) }
		-- This case should optimise

The substitution used to carry "fragile" OccInfo to call sites via the
DoneId constructor of SimplEnv.SimplSR.  This was always a tricky thing 
to do, and for some time I've been removing the need for it.

Now at last I think we can nuke it altogether.  Hooray.

I did a full nonfib run, and got zero perf changes.

This is another attempt to fix the interaction between recursion and
RULES.  I just had it wrong before!  Now the significance of the
flag on IAmALoopBreaker is given in BasicTypes

  | IAmALoopBreaker	-- Used by the occurrence analyser to mark loop-breakers
			-- in a group of recursive definitions
	!RulesOnly	-- True <=> This loop breaker mentions the other binders
			--	    in its recursive group only in its RULES, not
			--	    in its rhs
			--  See OccurAnal Note [RulesOnly]

Note [Recursive unboxing]
~~~~~~~~~~~~~~~~~~~~~~~~~
Be careful not to try to unbox this!
	data T = MkT !T Int
But it's the *argument* type that matters. This is fine:
	data S = MkS S !Int
because Int is non-recursive.


Before this patch, we were only doing the unboxing if the *parent*
data type was non-recursive (eg that meant S was not unboxed), but
that is over-conservative. 

This showed up with indexed data types (thanks to Roman for finding it)
because indexed data types are conservatively regarded as always recursive.

Note [Scrutinee with cast]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this:
    f = \ t -> case (v `cast` co) of
	         V a b -> a : f t

Exactly the same optimistaion (unrolling one call to f) will work here, 
despite the cast.  See mk_alt_env in the Case branch of libCase.

This patch does the job.  For a change, it was really easy.

Remove ILX from the GHC altogether (although I left the source file IlxGen in case anyone wants to see it)

We want the universal and existential tyvars of a data constructor to
have distinct OccNames.  It's confusing if they don't (in error messages,
for example), and with the current way of generating IfaceSyn, it actally
generates bogus interface files.  (Which bit Roman.)

When IfaceSyn is full of Names, this won't matter so much, but it still
seems cleaner.

This patch adds a 'tidy' step to the generation of DataCon type 
variables in TcTyClDecls.tcResultType 

This is part 2 of the patch that improved the interaction of RULES and
recursion.  It's vital that all Ids that may be referred to from later in
the module are marked 'IAmALoopBreaker' because otherwise we may do
postInlineUnconditionally, and lose the binding altogether. 

So I've added a boolean rules-only flag to IAmALoopBreaker.  Now we can
do inlining for rules-only loop-breakers.