Allow enum iteration about ponyc HOT 3 CLOSED

Like much of the sugaring we're doing, this raises the question of whether or not we should be doing this with hygienic macros. For example, a for loop could be a macro like this:

macro 
  "for" $idseq:idseq $type:(":" type | NONE) "in" $iter:seq "do"
    $body:seq 
    $else:("else" seq | NONE)
  "end" =
  (seq:scope
    (= (var $1 NONE) $iter)
    (while
      (call (dot (ref (id $1)) (id "has_next")) NONE NONE)
      (seq:scope
        (= (var $idseq $type) (call (dot (ref (id $1)) (id "next")) NONE NONE)
        $body
      )
      $else
    )
  )

That would allow rewriting directly to AST. Those nodes would have to be checked for validity, of course, before built-in sugaring but after parsing, since they could be nonsense.

The syntax above is obviously pseudocode, and might not work at all.

Macros would then have package scope, and we could indicate on the macro whether or not it should be picked up by an importer. In any case, an importer could only get macros if they imported a package without a qualifying identifier.

Macros would then be treated as elements of a parsing expression grammar, evaluated in the order defined, and the order of package import.

There is a very good chance that this is a terrible idea and we should never do this.

from ponyc.

With array literals, we can now do things like this:

primitive Black
primitive Blue
primitive Red
primitive Yellow

type Colour is (Black | Blue | Red | Yellow)

primitive ColourList
  fun tag apply(): Array[Colour] =>
    [Black, Blue, Red, Yellow]

for colour in ColourList().values() do
  ...
end

On the other hand, in expr_reference() we detect using a type alias name in an expression and reject it. We could instead transform it to an array literal. How exactly to transform it might be a bit tricky.

from ponyc.

Type alias names in expressions work now, so this all works.

from ponyc.