GitLab

A type variable has a flag saying whether it is a *type* variable or
a *coercion* variable.  This patch adds assertions to check the flag.

And it adds fixes to places which were Wrong (and hence fired the
assertion)! 

Also removed isCoVar from Coercion, since it's done by Var.isCoVar.

This large commit combines several interrelated changes:

  - IfaceSyn now contains actual Names rather than the special
    IfaceExtName type.  The binary interface file contains
    a symbol table of Names, where each entry is a (package,
    ModuleName, OccName) triple.  Names in the IfaceSyn point
    to entries in the symbol table.

    This reduces the size of interface files, which should
    hopefully improve performance (not measured yet).

    The toIfaceXXX functions now do not need to pass around
    a function from Name -> IfaceExtName, which makes that
    code simpler.

  - Names now do not point directly to their parents, and the
    nameParent operation has gone away.  It turned out to be hard to
    keep this information consistent in practice, and the parent info
    was only valid in some Names.  Instead we made the following
    changes:

    * ImportAvails contains a new field 
          imp_parent :: NameEnv AvailInfo
      which gives the family info for any Name in scope, and
      is used by the renamer when renaming export lists, amongst
      other things.  This info is thrown away after renaming.

    * The mi_ver_fn field of ModIface now maps to
      (OccName,Version) instead of just Version, where the
      OccName is the parent name.  This mapping is used when
      constructing the usage info for dependent modules.
      There may be entries in mi_ver_fn for things that are not in
      scope, whereas imp_parent only deals with in-scope things.

    * The md_exports field of ModDetails now contains
      [AvailInfo] rather than NameSet.  This gives us
      family info for the exported names of a module.

Also:

   - ifaceDeclSubBinders moved to IfaceSyn (seems like the
     right place for it).

   - heavily refactored renaming of import/export lists.

   - Unfortunately external core is now broken, as it relied on
     IfaceSyn.  It requires some attention.

Mon Sep 18 17:43:31 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
  * Comments only
  Wed Aug  9 04:45:19 EDT 2006  simonpj@microsoft.com
    * Comments only

Mon Sep 18 16:43:36 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
  * Comments only
  Sun Aug  6 17:18:44 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
    * Comments only
    Tue Jul 25 12:06:00 EDT 2006  simonpj@microsoft.com

Mon Sep 18 16:41:32 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
  * fix bugs, add boolean flag to identify coercion variables
  Sun Aug  6 17:04:02 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
    * fix bugs, add boolean flag to identify coercion variables
    Tue Jul 25 06:20:05 EDT 2006  kevind@bu.edu

Fri Aug 11 13:53:24 EDT 2006  Manuel M T Chakravarty <chak@cse.unsw.edu.au>
  * Remove argument variance info of tycons
  - Following SPJ's suggestion, this patch removes the variance information from
    type constructors.  This information was computed, but never used.
  
  ** WARNING: This patch changes the format of interface files **
  **          You will need to rebuild from scratch.           **

Broken up massive patch -=chak
Original log message:  
This is (sadly) all done in one patch to avoid Darcs bugs.
It's not complete work... more FC stuff to come.  A compiler
using just this patch will fail dismally.

Most of the other users of the fptools build system have migrated to
Cabal, and with the move to darcs we can now flatten the source tree
without losing history, so here goes.

The main change is that the ghc/ subdir is gone, and most of what it
contained is now at the top level.  The build system now makes no
pretense at being multi-project, it is just the GHC build system.

No doubt this will break many things, and there will be a period of
instability while we fix the dependencies.  A straightforward build
should work, but I haven't yet fixed binary/source distributions.
Changes to the Building Guide will follow, too.

Add support for UTF-8 source files

GHC finally has support for full Unicode in source files.  Source
files are now assumed to be UTF-8 encoded, and the full range of
Unicode characters can be used, with classifications recognised using
the implementation from Data.Char.  This incedentally means that only
the stage2 compiler will recognise Unicode in source files, because I
was too lazy to port the unicode classifier code into libcompat.

Additionally, the following synonyms for keywords are now recognised:

  forall symbol 	(U+2200)	forall
  right arrow   	(U+2192)	->
  left arrow   		(U+2190)	<-
  horizontal ellipsis 	(U+22EF)	..

there are probably more things we could add here.

This will break some source files if Latin-1 characters are being used.
In most cases this should result in a UTF-8 decoding error.  Later on
if we want to support more encodings (perhaps with a pragma to specify
the encoding), I plan to do it by recoding into UTF-8 before parsing.

Internally, there were some pretty big changes:

  - FastStrings are now stored in UTF-8

  - Z-encoding has been moved right to the back end.  Previously we
    used to Z-encode every identifier on the way in for simplicity,
    and only decode when we needed to show something to the user.
    Instead, we now keep every string in its UTF-8 encoding, and
    Z-encode right before printing it out.  To avoid Z-encoding the
    same string multiple times, the Z-encoding is cached inside the
    FastString the first time it is requested.

    This speeds up the compiler - I've measured some definite
    improvement in parsing at least, and I expect compilations overall
    to be faster too.  It also cleans up a lot of cruft from the
    OccName interface.  Z-encoding is nicely hidden inside the
    Outputable instance for Names & OccNames now.

  - StringBuffers are UTF-8 too, and are now represented as
    ForeignPtrs.

  - I've put together some test cases, not by any means exhaustive,
    but there are some interesting UTF-8 decoding error cases that
    aren't obvious.  Also, take a look at unicode001.hs for a demo.

Two significant changes to the representation of types

1. Change the representation of type synonyms

    Up to now, type synonym applications have been held in
    *both* expanded *and* un-expanded form.  Unfortunately, this
    has exponential (!) behaviour when type synonyms are deeply
    nested.  E.g.
	    type P a b = (a,b)
	    f :: P a (P b (P c (P d e)))
    
    This showed up in a program of Joel Reymont, now immortalised
    as typecheck/should_compile/syn-perf.hs

    So now synonyms are held as ordinary TyConApps, and expanded
    only on demand.  

    SynNote has disappeared altogether, so the only remaining TyNote
    is a FTVNote.  I'm not sure if it's even useful.

2. Eta-reduce newtypes

    See the Note [Newtype eta] in TyCon.lhs
    
    If we have 
	    newtype T a b = MkT (S a b)
    
    then, in Core land, we would like S = T, even though the application
    of T is then not saturated. This commit eta-reduces T's RHS, and
    keeps that inside the TyCon (in nt_etad_rhs).  Result is that 
    coreEqType can be simpler, and has less need of expanding newtypes.

Yet more detail in types with -dppr-debug

Tweaks to get the GHC sources through Haddock.  Doesn't quite work
yet, because Haddock complains about the recursive modules.  Haddock
needs to understand SOURCE imports (it can probably just ignore them
as a first attempt).

---------------------------------------------
Type signatures are no longer instantiated with skolem constants
	---------------------------------------------

	Merge to STABLE

Consider

  p :: a
  q :: b
  (p,q,r) = (r,r,p)

Here, 'a' and 'b' end up being the same, because they are both bound
to the type for 'r', which is just a meta type variable.  So 'a' and 'b'
can't be skolems.

Sigh.  This commit goes back to an earlier way of doing things, by
arranging that type signatures get instantiated with *meta* type
variables; then at the end we must check that they have not been
unified with types, nor with each other.

This is a real bore.  I had to do quite a bit of related fiddling around
to make error messages come out right.  Improved one or two.

Also a small unrelated fix to make
	:i (:+)
print with parens in ghci.  Sorry this got mixed up in the same commit.

Improve pretty-printing for types

------------------------------------
	Simplify the treatment of newtypes
	Complete hi-boot file consistency checking
	------------------------------------

In the representation of types, newtypes used to have a special constructor
all to themselves, very like TyConApp, called NewTcApp.    The trouble is
that means we have to *know* when a newtype is a newtype, and in an hi-boot
context we may not -- the data type might be declared as
	data T
in the hi-boot file, but as
	newtype T = ...
in the source file.  In GHCi, which accumulates stuff from multiple compiles,
this makes a difference.

So I've nuked NewTcApp.  Newtypes are represented using TyConApps again. This
turned out to reduce the total amount of code, and simplify the Type data type,
which is all to the good.


This commit also fixes a few things in the hi-boot consistency checking
stuff.

-----------------------------------
	Do simple checking on hi-boot files
	-----------------------------------

This commit arranges that, when compiling A.hs, we compare
the types we infer with those in A.hi-boot, if the latter 
exists.  (Or, more accurately, if anything A.hs imports in
turn imports A.hi-boot, directly or indirectly.)

This has been on the to-do list forever.

------------------------------------
	Add Generalised Algebraic Data Types
	------------------------------------

This rather big commit adds support for GADTs.  For example,

    data Term a where
 	  Lit :: Int -> Term Int
	  App :: Term (a->b) -> Term a -> Term b
	  If  :: Term Bool -> Term a -> Term a
	  ..etc..

    eval :: Term a -> a
    eval (Lit i) = i
    eval (App a b) = eval a (eval b)
    eval (If p q r) | eval p    = eval q
    		    | otherwise = eval r


Lots and lots of of related changes throughout the compiler to make
this fit nicely.

One important change, only loosely related to GADTs, is that skolem
constants in the typechecker are genuinely immutable and constant, so
we often get better error messages from the type checker.  See
TcType.TcTyVarDetails.

There's a new module types/Unify.lhs, which has purely-functional
unification and matching for Type. This is used both in the typechecker
(for type refinement of GADTs) and in Core Lint (also for type refinement).

-------------------------------
	Print built-in sytax right
	-------------------------------

Built-in syntax, like (:) and [], is not "in scope" via the GlobalRdrEnv
in the usual way.  When we print it out, we should also print it in unqualified
form, even though it's not in the environment.

I've finally bitten the (not very big) bullet, and added to Name the information
about whether or not a name is one of these built-in ones.  That entailed changing
the calls to mkWiredInName, but those are exactly the places where you have to
decide whether it's built-in or not, which is fine.


Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])

Wired-in thing  => The thing (Id, TyCon) is fully known to the compiler,
		   not read from an interface file.
		   E.g. Bool, True, Int, Float, and many others

All built-in syntax is for wired-in things.

Print slightly more informative types in debug mode

----------------------------
        Re-do kind inference (again)
	----------------------------

   [WARNING: interface file binary representation has
   (as usual) changed slightly; recompile your libraries!]

Inspired by the lambda-cube, for some time GHC has used
	type Kind = Type
That is, kinds were represented by the same data type as types.

But GHC also supports unboxed types and unboxed tuples, and these
complicate the kind system by requiring a sub-kind relationship.
Notably, an unboxed tuple is acceptable as the *result* of a
function but not as an *argument*.  So we have the following setup:

		 ?
		/ \
	       /   \
	      ??   (#)
	     /  \
            *   #

where	*    [LiftedTypeKind]   means a lifted type
	#    [UnliftedTypeKind] means an unlifted type
	(#)  [UbxTupleKind]     means unboxed tuple
	??   [ArgTypeKind]      is the lub of *,#
	?    [OpenTypeKind]	means any type at all

In particular:

  error :: forall a:?. String -> a
  (->)  :: ?? -> ? -> *
  (\(x::t) -> ...)	Here t::?? (i.e. not unboxed tuple)

All this has beome rather difficult to accommodate with Kind=Type, so this
commit splits the two.

  * Kind is a distinct type, defined in types/Kind.lhs

  * IfaceType.IfaceKind disappears: we just re-use Kind.Kind

  * TcUnify.unifyKind is a distinct unifier for kinds

  * TyCon no longer needs KindCon and SuperKindCon variants

  * TcUnify.zapExpectedType takes an expected Kind now, so that
    in TcPat.tcMonoPatBndr we can express that the bound variable
    must have an argTypeKind (??).

The big change is really that kind inference is much more systematic and
well behaved.  In particular, a kind variable can unify only with a
"simple kind", which is built from * and (->).  This deals neatly
with awkward questions about how we can combine sub-kinding with type
inference.

Lots of small consequential changes, especially to the kind-checking
plumbing in TcTyClsDecls.  (We played a bit fast and loose before, and
now we have to be more honest, in particular about how kind inference
works for type synonyms.  They can have kinds like (* -> #), so

This cures two long-standing SourceForge bugs

* 753777 (tcfail115.hs), which used erroneously to pass,
  but crashed in the code generator
      type T a = Int -> (# Int, Int #)
      f :: T a -> T a
      f t = \x -> case t x of r -> r

* 753780 (tc167.hs), which used erroneously to fail
      f :: (->) Int# Int#


Still, the result is not entirely satisfactory.  In particular

* The error message from tcfail115 is pretty obscure

* SourceForge bug 807249 (Instance match failure on openTypeKind)
  is not fixed.  Alas.

Improve type pretty-printer

Wibbles to pretty printing of types

Missing cases in isLiftedTypeKind etc

Pretty-printing wibble; fixes many tests

This commit does a long-overdue tidy-up

* Remove PprType (gets rid of one more bunch of hi-boot files)

* Put pretty-printing for types in TypeRep

* Make a specialised pretty-printer for Types, rather than
  converting to IfaceTypes and printing those

Enable crudePprType without DEBUG

-------------------------
		GHC heart/lung transplant
		-------------------------

This major commit changes the way that GHC deals with importing
types and functions defined in other modules, during renaming and
typechecking.  On the way I've changed or cleaned up numerous other
things, including many that I probably fail to mention here.

Major benefit: GHC should suck in many fewer interface files when
compiling (esp with -O).  (You can see this with -ddump-rn-stats.)

It's also some 1500 lines of code shorter than before.

**	So expect bugs!  I can do a 3-stage bootstrap, and run
**	the test suite, but you may be doing stuff I havn't tested.
** 	Don't update if you are relying on a working HEAD.


In particular, (a) External Core and (b) GHCi are very little tested.

	But please, please DO test this version!


	------------------------
		Big things
	------------------------

Interface files, version control, and importing declarations
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* There is a totally new data type for stuff that lives in interface files:
	Original names			IfaceType.IfaceExtName
	Types				IfaceType.IfaceType
	Declarations (type,class,id)	IfaceSyn.IfaceDecl
	Unfoldings			IfaceSyn.IfaceExpr
  (Previously we used HsSyn for type/class decls, and UfExpr for unfoldings.)
  The new data types are in iface/IfaceType and iface/IfaceSyn.  They are
  all instances of Binary, so they can be written into interface files.
  Previous engronkulation concering the binary instance of RdrName has
  gone away -- RdrName is not an instance of Binary any more.  Nor does
  Binary.lhs need to know about the ``current module'' which it used to,
  which made it specialised to GHC.

  A good feature of this is that the type checker for source code doesn't
  need to worry about the possibility that we might be typechecking interface
  file stuff.  Nor does it need to do renaming; we can typecheck direct from
  IfaceSyn, saving a whole pass (module TcIface)

* Stuff from interface files is sucked in *lazily*, rather than being eagerly
  sucked in by the renamer. Instead, we use unsafeInterleaveIO to capture
  a thunk for the unfolding of an imported function (say).  If that unfolding
  is every pulled on, TcIface will scramble over the unfolding, which may
  in turn pull in the interface files of things mentioned in the unfolding.

  The External Package State is held in a mutable variable so that it
  can be side-effected by this lazy-sucking-in process (which may happen
  way later, e.g. when the simplifier runs).   In effect, the EPS is a kind
  of lazy memo table, filled in as we suck things in.  Or you could think
  of it as a global symbol table, populated on demand.

* This lazy sucking is very cool, but it can lead to truly awful bugs. The
  intent is that updates to the symbol table happen atomically, but very bad
  things happen if you read the variable for the table, and then force a
  thunk which updates the table.  Updates can get lost that way. I regret
  this subtlety.

  One example of the way it showed up is that the top level of TidyPgm
  (which updates the global name cache) to be much more disciplined about
  those updates, since TidyPgm may itself force thunks which allocate new
  names.

* Version numbering in interface files has changed completely, fixing
  one major bug with ghc --make.  Previously, the version of A.f changed
  only if A.f's type and unfolding was textually different.  That missed
  changes to things that A.f's unfolding mentions; which was fixed by
  eagerly sucking in all of those things, and listing them in the module's
  usage list.  But that didn't work with --make, because they might have
  been already sucked in.

  Now, A.f's version changes if anything reachable from A.f (via interface
  files) changes.  A module with unchanged source code needs recompiling
  only if the versions of any of its free variables changes. [This isn't
  quite right for dictionary functions and rules, which aren't mentioned
  explicitly in the source.  There are extensive comments in module MkIface,
  where all version-handling stuff is done.]

* We don't need equality on HsDecls any more (because they aren't used in
  interface files).  Instead we have a specialised equality for IfaceSyn
  (eqIfDecl etc), which uses IfaceEq instead of Bool as its result type.
  See notes in IfaceSyn.

* The horrid bit of the renamer that tried to predict what instance decls
  would be needed has gone entirely.  Instead, the type checker simply
  sucks in whatever instance decls it needs, when it needs them.  Easy!

  Similarly, no need for 'implicitModuleFVs' and 'implicitTemplateHaskellFVs'
  etc.  Hooray!


Types and type checking
~~~~~~~~~~~~~~~~~~~~~~~
* Kind-checking of types is far far tidier (new module TcHsTypes replaces
  the badly-named TcMonoType).  Strangely, this was one of my
  original goals, because the kind check for types is the Right Place to
  do type splicing, but it just didn't fit there before.

* There's a new representation for newtypes in TypeRep.lhs.  Previously
  they were represented using "SourceTypes" which was a funny compromise.
  Now they have their own constructor in the Type datatype.  SourceType
  has turned back into PredType, which is what it used to be.

* Instance decl overlap checking done lazily.  Consider
	instance C Int b
	instance C a Int
  These were rejected before as overlapping, because when seeking
  (C Int Int) one couldn't tell which to use.  But there's no problem when
  seeking (C Bool Int); it can only be the second.

  So instead of checking for overlap when adding a new instance declaration,
  we check for overlap when looking up an Inst.  If we find more than one
  matching instance, we see if any of the candidates dominates the others
  (in the sense of being a substitution instance of all the others);
  and only if not do we report an error.



	------------------------
	     Medium things
	------------------------

* The TcRn monad is generalised a bit further.  It's now based on utils/IOEnv.lhs,
  the IO monad with an environment.  The desugarer uses the monad too,
  so that anything it needs can get faulted in nicely.

* Reduce the number of wired-in things; in particular Word and Integer
  are no longer wired in.  The latter required HsLit.HsInteger to get a
  Type argument.  The 'derivable type classes' data types (:+:, :*: etc)
  are not wired in any more either (see stuff about derivable type classes
  below).

* The PersistentComilerState is now held in a mutable variable
  in the HscEnv.  Previously (a) it was passed to and then returned by
  many top-level functions, which was painful; (b) it was invariably
  accompanied by the HscEnv.  This change tidies up top-level plumbing
  without changing anything important.

* Derivable type classes are treated much more like 'deriving' clauses.
  Previously, the Ids for the to/from functions lived inside the TyCon,
  but now the TyCon simply records their existence (with a simple boolean).
  Anyone who wants to use them must look them up in the environment.

  This in turn makes it easy to generate the to/from functions (done
  in types/Generics) using HsSyn (like TcGenDeriv for ordinary derivings)
  instead of CoreSyn, which in turn means that (a) we don't have to figure
  out all the type arguments etc; and (b) it'll be type-checked for us.
  Generally, the task of generating the code has become easier, which is
  good for Manuel, who wants to make it more sophisticated.

* A Name now says what its "parent" is. For example, the parent of a data
  constructor is its type constructor; the parent of a class op is its
  class.  This relationship corresponds exactly to the Avail data type;
  there may be other places we can exploit it.  (I made the change so that
  version comparison in interface files would be a bit easier; but in
  fact it tided up other things here and there (see calls to
  Name.nameParent).  For example, the declaration pool, of declararations
  read from interface files, but not yet used, is now keyed only by the 'main'
  name of the declaration, not the subordinate names.

* New types OccEnv and OccSet, with the usual operations.
  OccNames can be efficiently compared, because they have uniques, thanks
  to the hashing implementation of FastStrings.

* The GlobalRdrEnv is now keyed by OccName rather than RdrName.  Not only
  does this halve the size of the env (because we don't need both qualified
  and unqualified versions in the env), but it's also more efficient because
  we can use a UniqFM instead of a FiniteMap.

  Consequential changes to Provenance, which has moved to RdrName.

* External Core remains a bit of a hack, as it was before, done with a mixture
  of HsDecls (so that recursiveness and argument variance is still inferred),
  and IfaceExprs (for value declarations).  It's not thoroughly tested.


	------------------------
	     Minor things
	------------------------

* DataCon fields dcWorkId, dcWrapId combined into a single field
  dcIds, that is explicit about whether the data con is a newtype or not.
  MkId.mkDataConWorkId and mkDataConWrapId are similarly combined into
  MkId.mkDataConIds

* Choosing the boxing strategy is done for *source* type decls only, and
  hence is now in TcTyDecls, not DataCon.

* WiredIn names are distinguished by their n_sort field, not by their location,
  which was rather strange

* Define Maybes.mapCatMaybes :: (a -> Maybe b) -> [a] -> [b]
  and use it here and there

* Much better pretty-printing of interface files (--show-iface)

Many, many other small things.


	------------------------
	     File changes
	------------------------
* New iface/ subdirectory
* Much of RnEnv has moved to iface/IfaceEnv
* MkIface and BinIface have moved from main/ to iface/
* types/Variance has been absorbed into typecheck/TcTyDecls
* RnHiFiles and RnIfaces have vanished entirely.  Their
  work is done by iface/LoadIface
* hsSyn/HsCore has gone, replaced by iface/IfaceSyn
* typecheck/TcIfaceSig has gone, replaced by iface/TcIface
* typecheck/TcMonoType has been renamed to typecheck/TcHsType
* basicTypes/Var.hi-boot and basicTypes/Generics.hi-boot have gone altogether

-------------------------------------
	Remove all vestiges of usage analysis
	-------------------------------------

This commit removes a large blob of usage-analysis-related code, almost
all of which was commented out.

Sadly, it doesn't look as if Keith is going to have enough time to polish it
up, and in any case the actual performance benefits (so far as we can measure
them) turned out to be pretty modest (a few percent).

So, with regret, I'm chopping it all out.  It's still there in the repository
if anyone wants go hack on it.  And Tobias Gedell at Chalmers is implementing
a different analysis, via External Core.

Back out the function tycon kind change (big comment to explain why)

Give -> the correct kind!

Comments

Binary Interface Files - stage 1
--------------------------------

This commit changes the default interface file format from text to
binary, in order to improve compilation performace.

To view an interface file, use 'ghc --show-iface Foo.hi'.

utils/Binary.hs is the basic Binary I/O library, based on the nhc98
binary I/O library but much stripped-down and working in terms of
bytes rather than bits, and with some special features for GHC: it
remembers which Module is being emitted to avoid dumping too many
qualified names, and it keeps track of a "dictionary" of FastStrings
so that we don't dump the same FastString more than once into the
binary file.  I'll make a generic version of this for the libraries at
some point.

main/BinIface.hs contains most of the Binary instances.  Some
instances are in the same module as the data type (RdrName, Name,
OccName in particular).  Most instances were generated using a
modified version of DrIFT, which I'll commit later.  However, editing
them by hand isn't hard (certainly easier than modifying
ParseIface.y).

The first thing in a binary interface is the interface version, so
nice error messages will be generated if the binary format changes and
you still have old interfaces lying around.  The version also now
includes the "way" as an extra sanity check.

Other changes
-------------

I don't like the way FastStrings contain both hashed strings (with
O(1) comparison) and literal C strings (with O(n) comparison).  So as
a first step to separating these I made serveral "literal" type
strings into hashed strings.  SLIT() still generates a literal, and
now FSLIT() generates a hashed string.  With DEBUG on, you'll get a
warning if you try to compare any SLIT()s with anything, and the
compiler will fall over if you try to dump any literal C strings into
an interface file (usually indicating a use of SLIT() which should be
FSLIT()).

mkSysLocal no longer re-encodes its FastString argument each time it
is called.

I also fixed the -pgm options so that the argument can now optionally
be separted from the option.

Bugfix: PrelNames declared Names for several comparison primops, eg.
eqCharName, eqIntName etc. but these had different uniques from the
real primop names.  I've moved these to PrimOps and defined them using
mkPrimOpIdName instead, and deleted some for which we don't have real
primops (Manuel: please check that things still work for you after
this change).