Before:
* << is left shift, not allowed to shift 1 bits out
* <<% is left shift, allowed to shift 1 bits out
* >> is right shift, allowed to shift 1 bits out
After:
* << is left shift, allowed to shift 1 bits out
* >> is right shift, allowed to shift 1 bits out
* @shlExact is left shift, not allowed to shift 1 bits out
* @shrExact is right shift, not allowed to shift 1 bits out
Closes#413
Old:
```
while (condition; expression) {}
```
New:
```
while (condition) : (expression) {}
```
This is in preparation to allow nullable and
error union types as the condition. See #357
implicit semicolon rules apply recursively to the "else" clause of if and try
if (a) {} else {} // implicit semicolon
if (a) {} else if (a) {} // implicit semicolon
if (a) {} else while (a) {} // implicit semicolon
closes#292
* if, try, while, for, comptime, defer are "greedy" with {} blocks,
meaning if their bodies are blocks, then no suffix operator is allowed
after the block. The {} block gets "built into" the containing statement,
like the body of a switch statement.
* the Expression syntactic element is no longer "greedy" with {} blocks,
meaning it's possible to have suffix operators after {} blocks without
needing the {} block to be an rhs operand first.
* Don't insert void statements all over the place. {} now stays as
{} instead of {{}}, and {;} becomes {} instead of {{};{}}.
* Ensure final statement is always the return value statement, or
the block is empty. This means {label:} becomes {label:{}}.
it outputs a number that is unique to each instance of the asm
statement in the entire compilation.
useful when creating local labels and referring to them multiple
times in a single template that generates multiple
assembler instructions
if and switch are implicitly inline if the condition/target
expression is known at compile time.
instead of:
```
inline if (condition) ...
inline switch (target) ...
```
one can use:
```
if (comptime condition) ...
switch (comptime target) ...
```
* comptime expression is a block expression as it should be
* fix var args when number of args passed is 0
* implement const value equality for structs
* fix indent when rendering container decl AST
* IR: prevent duplicate generation of code when it is partially
compile-time evaluated
* implement compile time struct field pointer evaluation
* fix compile time evaluation of slicing
* Rip out legacy code for generics
* put scope in instruction instead of AST nodes
* separate top level decl stuff from AST nodes
- remove the assumption that there is a 1:1 correspondence
between an output instruction and an AST node
- This way we won't have to clone AST nodes for generics.
Andrew Kelley
scurest
Josh Wolfe