Initial commit
Last manual parser version
First version to parse and generate non-trivial code
bootstrap: Functional for simple code, handles generic instantiation
bootstrap: Add support for optional arguments in function calls

We think that we will ultimately only accept optional arguments to be
called with 'foo a b argname=c', to make it quite explicit what is
happening here.

For now, however, this is just positional.

An optional argument introduced with the following syntax:

  fun foo a:U32 ?b:?.U32 = U32
    let bval = Optional b 0
    return a + bval

Optional arguments must be nullable references. When the argument is
omitted, null is passed instead. null can of course be passed
explicitly for the same effect.

A convenience function nlang.Optional is defined:

  (fun Optional T) ptr:?.T otherwise:T = T

and is used to assign a default value when the argument is omitted or
null is passed.
bootstrap: Preliminary support for tagged unions and pure enums

Pattern matching is not implemented, so it cannot really be used yet.
Add support for pattern matching of enums.

Had to do lots of changes at the same time.
Still missing support for expr deconstruction.
Support for 'not' unary operator cwriting
Fix parsing of from x import *
Enable GCC -Wall and fix warnings. Enforce let constness in generated C.
Check type of if/else conditions; random work
bootstrap: Deep rework and rewrite; syntax changes

Not supported by the bootstrap compiler, and unlikely to be soon:
- referencing temporaries (e.g. foo x &1). A full solution involves
  converting to SSA form, which will likely only do in the full
  compiler. Note: the lifetime of these references is not fully
  specified yet. Do we want them to be scoped references? Use cases? Or
  do we want them to have a more minimal lifetime?

	fun bar x:!U8 = !U8
	  return x
	let p = bar &1 -> Then we need a scoped reference.

  A scoped reference is certainly the more N thing to do.

- syntax for type reference literals in normal expression context (e.g.
  let alias = !U32 will not work, we support let alias = &!U32 though).
Re-enable typecheck caching (4x speedup)

definition(), is_meta_type calls could be cached as well.
nlang.vector: Vector.Set__ should me mutating
PatternDecl: For trivial patterns, do not create an intermediate variable

	let x = expr

Would create a temporary, as if it where
	let __gensym0__ = expr
	let x = __gensym0__

But in the case of
	let x:U32
	  x = foo

the generated C code would end up being
	U32 __gensym0__;
	U32 x = __gensym0__;

generating an uninitialized variable warning.
runtests: Run all tests in t/
bootstrap/ast: Simplify typecheck caching (not scope dependent)

With the current design, where generic typedefs are fully instantiated
(via deep copy), typecheck caching is not scope dependent.
runtests: Restrict tests to files passed as arguments, if any
bootstrap/parser: Accept numbers in any base, with Python's syntax
bootstrap/ast: Non-exhaustive If blocks are OK, but have type void

We previously would raise an error for non-exhaustive if blocks (our
detection was limited to lacking a else term).

This is overly restrictive. N is a mostly imperative language, we need
this form.

However, it is sometimes useful to use the result of an if block. While
this is not yet support by the rest of the parser, we will allow it by
typing ExprIf to non-void only when the if block is complete.