add an IL with a dedicated pointer type

[zerbina]

Summary

Add the LPtr IL providing a dedicated pointer type and an Offset
operation for pointer arithmetic. Higher-level ILs as well as skully
and source2il are changed to use the new Ptr type.

Details

Idea

The idea behind a dedicated pointer type is to:

1. allow for better static error detection, once type checking for ILs
   is implemented
2. allow higher-level passes to defer decision making (i.e., regarding
   how a pointer is implemented)
3. keep the type for code generators that need it

Implementation

• add the LPtr providing the Ptr type and Nil and Offset
  expression. It extends the L0 IL and is the new basis for the
  L1 IL
• integrate the new IL and the new ptrToInt pass (LPtr -> L0)
  into the main executable and the REPL
• update the higher-level ILs to consider Ptr and Nil
• change the stack allocation pass to emit Offset instead of integer
  arithmetic
• change the aggregate-related passes, as well as the global-to-pointer
  pass, to use Ptr instead of lowering to UInt
• update the expected output of the modified existing tests
• add tests for the new ptrToInt pass

The IL uses a symbolic name (rather than a numeric one) so that the
existing ILs don't have to be renamed.

Usage of Offset is disallowed past the L2 IL for now, so that raw
pointer arithmetic is not exposed to higher-level ILs for now.

Source2IL

• add an internal-only tkPointer type
• replace the pointerType constant with using tkPointer directly
• translate tkPointer and procedure pointers to the IL Ptr type
• update the hand-written L30 code to not use pointer arithmetic

Skully

• translate MIR pointer-like types to Ptr
• use Nil for representing nil pointers
• adjust the cast translation, which needs to handle pointers no longer
  being arithmetic types

---

Notes For Reviewers

• based on the pointer-related changes from WIP: add an L3 -> LLVM IR translation pass #146
• review is likely easier by looking at each commit, one by one

[saem]

A couple of minor comments, nothing major.

On the topic of adding pointer and null, I wonder if some of the necessary changes would have been easier to catch with a push towards exhaustive cases?

[zerbina]

On the topic of adding pointer and null, I wonder if some of the necessary changes would have been easier to catch with a push towards exhaustive cases?

It would have been, yea, but enumerating all syntax is would be a lot of work, currently.

What's missing is the non-terminals from the IL grammars (e.g., type, path, expr, etc.) being available as sets, which would make using exhaustive case statements a lot more comfortable, overall. This is tricky, however, as the non-terminals (and thus the sets) are different based on which language level one is at.

---

Relatedly, whatever the experiment with a new IR will yield, one thing it has made obvious to me already is that the hierarchical, inheritance/extension-based language level design should be replaced with a compositional design, where there are atomic language features + capabilities that have dependencies on one another.