Annotations Overhaul

[jmeaster30]

I would like to have the annotation parser be part of the phase 1 parser so that we can have better parsing of annotations.

For example, it would improve functionality around online annotations for function parameters and even individual statement macros (like the hydro macros).

It would probably allow hydro macros to be specifically in expressions (which is phase 2 parsing I guess). The main issue with having a hydro macros is then all the hydro keywords have to become ocean keywords :(

TODO:

• [ ] Move annotation parser to phase 1 parsing to match new form
• [ ] Add ways to create annotations and block annotations
• [ ] Do semantic analysis

Unanswered Questions:

• [ ] How to tie a block comment to a function when we want but not when we don't want (think documentation annotations to functions they are documenting)

[jmeaster30]

This might be easier cause I made a thing that let's parser phase 1 send a whole ast node to parser phase 2 instead of just a list of tokens

[jmeaster30]

Actually I have an idea for annotations there are going to be 3 kinds

1. Basic annotation has no extra options for configuring

   @Trace

2. Inline annotation with options (note the multilines)

   @Operator(
   symbol: +,
   precedence: 10,
   order: infix
   )

   Or

   @Operator(+, 10, infix)

3. Block annotation

   @@ Documentation
   This function does really neat stuff
   @@

[jmeaster30]

Declaring an annotation:

@Annotation(
      name: Trace,
      scope: function
)
function trace_annotation(function_name: string, target_function: func(auto Arguments...)->(auto Returns...), annotation_parameters: AnnotationParameters, arguments: Arguments) -> (result: Returns...) { }

[jmeaster30]

For parameters in declaring an annotation it could be nice to just make a struct that holds the parameters:

union OperatorOrder {
    Prefix,
    Postfix,
    Infix,
}

pack OperatorParameters {
    symbol: string,
    precedence: u32,
    order: OperatorOrder
}

@Annotation (
    name: "Operator",
    scope: function,
    parameters: OperatorParameters
)
Blah blah blah

[jmeaster30]

Ordering of things will be as follows as a result

• phase 1 parsing
• go through usings and do full process on them (definitely need to track cyclical dependencies)
• basic type check of packs and unions without evaluating expressions
• typecheck the annotations with the packs/unions that were already resolved
• phase 2 parsing of expressions
• typecheck remaining expressions

This does make me think that the symbol table should be built into the ast so we can easily do multiple passes to get everything checked semantically

[jmeaster30]

Moved the parser to phase 1. Block annotations would still need to be parsed a little bit

[jmeaster30]

Renaming cause I want to have a central place to track the annotation overhaul stuff