add comments ehehe

Backend/_smoke_test.py

@@ -1,132 +1,253 @@
+# AUTO: Imports a module used by this file.
 import sys, os
+# AUTO: Calls `sys.path.insert`.
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
+# AUTO: Imports names from another module.
 from lexer import lex
+# AUTO: Imports names from another module.
 from parser import LL1Parser
+# AUTO: Imports names from another module.
 from cfg import cfg, first_sets, predict_sets
+# AUTO: Imports names from another module.
 from semantic import validate_ast
+# AUTO: Imports names from another module.
 from interpreter import Interpreter
 
 
+# AUTO: Defines class `_Collector`.
 class _Collector:
+    # AUTO: Defines function `__init__`.
     def __init__(self): self.outputs = []
+    # AUTO: Defines function `emit`.
     def emit(self, event, data=None, **kw):
+        # AUTO: Checks this condition.
         if event == 'output' and data:
+            # AUTO: Appends a value to a list.
             self.outputs.append(data.get('output', ''))
 
 
+# AUTO: Sets `PROGRAMS`.
 PROGRAMS = [
+    # AUTO: Executes this statement.
     ('hello',   'root() { plant("hello"); reclaim; }',
+     # AUTO: Calls `function`.
      ['hello']),
+    # AUTO: Sets `('arith',   'root() { seed a`.
     ('arith',   'root() { seed a = ~5 + 3; plant("b={}", a); reclaim; }',
+     # AUTO: Sets `['b`.
      ['b=-2']),
+    # AUTO: Sets `('unary',   'root() { tree x`.
     ('unary',   'root() { tree x = 2.5; tree y = ~x; seed n = ~(2 + 3); plant("{} {}", y, n); reclaim; }',
+     # AUTO: Calls `function`.
      ['-2.5 -5']),
+    # AUTO: Executes this statement.
     ('strings', 'root() { vine hi = "Hi"; leaf mark = \'!\'; vine msg = hi ` mark; branch same = msg == "Hi!"; plant("{} {}", msg, same); reclaim; }',
+     # AUTO: Calls `function`.
      ['Hi! True']),
+    # AUTO: Sets `('float',   'root() { tree pi`.
     ('float',   'root() { tree pi = 3.14; tree r = 2.0; tree area = pi * r * r; plant("area={}", area); reclaim; }',
+     # AUTO: Sets `['area`.
      ['area=12.56']),
+    # AUTO: Adds into `('forloop', 'root() { seed s = 0; cultivate(seed i = 1; i <= 3; i++) { s`.
     ('forloop', 'root() { seed s = 0; cultivate(seed i = 1; i <= 3; i++) { s += i; } plant("sum={}", s); reclaim; }',
+     # AUTO: Sets `['sum`.
      ['sum=6']),
+    # AUTO: Sets `('assignexpr', 'root() { seed a`.
     ('assignexpr', 'root() { seed a = 0; seed b = 0; seed c = (a = b = 5) + 2; plant("a={} b={} c={}", a, b, c); reclaim; }',
+     # AUTO: Sets `['a`.
      ['a=5 b=5 c=7']),
+    # AUTO: Sets `('switch',  'root() { seed x`.
     ('switch',  'root() { seed x = 2; harvest(x) { variety 1: { plant("one"); prune; } variety 2: { plant("two"); prune; } soil: { plant("other"); } } reclaim; }',
+     # AUTO: Calls `function`.
      ['two']),
+    # AUTO: Adds into `('declfirst', 'root() { seed num = 5; plant("begin"); num`.
     ('declfirst', 'root() { seed num = 5; plant("begin"); num += 2; plant("num={}", num); reclaim; }',
+     # AUTO: Sets `['begin', 'num`.
      ['begin', 'num=7']),
+    # AUTO: Sets `('bundlevar', 'bundle Student { seed age; }; root() { bundle Student student; student.age`.
     ('bundlevar', 'bundle Student { seed age; }; root() { bundle Student student; student.age = 20; plant("age={}", student.age); reclaim; }',
+     # AUTO: Sets `['age`.
      ['age=20']),
+    # AUTO: Sets `('nestedreturn', 'root() { branch stop`.
     ('nestedreturn', 'root() { branch stop = frost; spring (stop) { reclaim; } plant("continued"); reclaim; }',
+     # AUTO: Calls `function`.
      ['continued']),
+    # AUTO: Sets `('arr_postfix', 'root() { seed arr[3]; arr[0]`.
     ('arr_postfix', 'root() { seed arr[3]; arr[0] = 1; arr[0]++; plant("v={}", arr[0]); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=2']),
+    # AUTO: Sets `('arr_prefix',  'root() { seed arr[3]; arr[0]`.
     ('arr_prefix',  'root() { seed arr[3]; arr[0] = 5; ++arr[0]; plant("v={}", arr[0]); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=6']),
+    # AUTO: Sets `('arr_postdec', 'root() { seed arr[3]; arr[0]`.
     ('arr_postdec', 'root() { seed arr[3]; arr[0] = 7; arr[0]--; plant("v={}", arr[0]); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=6']),
+    # AUTO: Sets `('struct_postinc', 'bundle P { seed a; }; root() { bundle P p; p.a`.
     ('struct_postinc', 'bundle P { seed a; }; root() { bundle P p; p.a = 1; p.a++; plant("v={}", p.a); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=2']),
+    # AUTO: Sets `('struct_preinc',  'bundle P { seed a; }; root() { bundle P p; p.a`.
     ('struct_preinc',  'bundle P { seed a; }; root() { bundle P p; p.a = 5; ++p.a; plant("v={}", p.a); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=6']),
+    # AUTO: Sets `('struct_postdec', 'bundle P { seed a; }; root() { bundle P p; p.a`.
     ('struct_postdec', 'bundle P { seed a; }; root() { bundle P p; p.a = 10; p.a--; plant("v={}", p.a); reclaim; }',
+     # AUTO: Sets `['v`.
      ['v=9']),
+    # AUTO: Sets `('arr_in_loop', 'root() { seed arr[3]; arr[0]`.
     ('arr_in_loop', 'root() { seed arr[3]; arr[0]=0; arr[1]=0; arr[2]=0; cultivate(seed i = 0; i < 3; i++) { arr[i]++; } plant("a={} b={} c={}", arr[0], arr[1], arr[2]); reclaim; }',
+     # AUTO: Sets `['a`.
      ['a=1 b=1 c=1']),
+    # AUTO: Multiplies into `('exp_assign_seed', 'root() { seed x = 2; x *`.
     ('exp_assign_seed', 'root() { seed x = 2; x **= 3; plant("{}", x); reclaim; }',
+     # AUTO: Calls `function`.
      ['8']),
+    # AUTO: Multiplies into `('exp_assign_chain', 'root() { seed x = 2; x *`.
     ('exp_assign_chain', 'root() { seed x = 2; x **= 3; x **= 2; plant("{}", x); reclaim; }',
+     # AUTO: Calls `function`.
      ['64']),
+    # AUTO: Multiplies into `('exp_assign_member', 'bundle P { seed v; }; root() { bundle P p; p.v = 5; p.v *`.
     ('exp_assign_member', 'bundle P { seed v; }; root() { bundle P p; p.v = 5; p.v **= 2; plant("{}", p.v); reclaim; }',
+     # AUTO: Calls `function`.
      ['25']),
+# AUTO: Closes the current grouped code/data.
 ]
 
+# AUTO: Sets `REJECTED_PROGRAMS`.
 REJECTED_PROGRAMS = [
+    # AUTO: Sets `('late_decl', 'root() { plant("begin"); seed num`.
     ('late_decl', 'root() { plant("begin"); seed num = 5; reclaim; }',
+     # AUTO: Calls `function`.
      'Local declarations must appear first in the block.'),
+    # AUTO: Sets `('late_nested', 'root() { branch ok`.
     ('late_nested', 'root() { branch ok = sunshine; spring (ok) { plant("begin"); seed num = 5; } reclaim; }',
+     # AUTO: Calls `function`.
      'Local declarations must appear first in the block.'),
+    # AUTO: Sets `('late_case', 'root() { seed n`.
     ('late_case', 'root() { seed n = 1; harvest (n) { variety 1: plant("begin"); seed late = 5; prune; } reclaim; }',
+     # AUTO: Calls `function`.
      'Local declarations must appear first in the block.'),
+    # AUTO: Executes this statement.
     ('bundle_no_var', 'bundle Student { seed age; }; root() { bundle Student; reclaim; }',
+     # AUTO: Calls `function`.
      'Expected: id'),
+    # AUTO: Executes this statement.
     ('bundle_leading_comma', 'bundle Student { seed age; }; root() { bundle Student, student; reclaim; }',
+     # AUTO: Calls `function`.
      'Expected: id'),
+    # AUTO: Executes this statement.
     ('bundle_multiple', 'bundle Student { seed age; }; root() { bundle Student first, second; reclaim; }',
+     # AUTO: Calls `function`.
      "Expected: ';'"),
+    # AUTO: Executes this statement.
     ('missing_root_reclaim', 'root() { }',
+     # AUTO: Calls `function`.
      "expected 'reclaim;' before '}'"),
+    # AUTO: Sets `('missing_final_reclaim', 'root() { branch stop`.
     ('missing_final_reclaim', 'root() { branch stop = sunshine; spring (stop) { reclaim; } }',
+     # AUTO: Calls `function`.
      "expected 'reclaim;' before '}'"),
+    # AUTO: Executes this statement.
     ('missing_function_reclaim', 'pollinate empty greet() { plant("hi"); } root() { reclaim; }',
+     # AUTO: Calls `function`.
      "expected 'reclaim;' before '}'"),
+    # AUTO: Executes this statement.
     ('array_decimal_size', 'root() { seed arr[2.5]; reclaim; }',
+     # AUTO: Calls `function`.
      "Expected: ']', intlit"),
+    # AUTO: Sets `('empty_initializer', 'root() { seed x`.
     ('empty_initializer', 'root() { seed x = ; reclaim; }',
+     # AUTO: Sets `"Missing value after '`.
      "Missing value after '=' operator."),
+    # AUTO: Sets `('string_case_literal', 'root() { seed x`.
     ('string_case_literal', 'root() { seed x = 1; harvest (x) { variety "a": { prune; } } reclaim; }',
+     # AUTO: Calls `function`.
      "Expected: chrlit, 'frost', intlit, 'sunshine'"),
+# AUTO: Closes the current grouped code/data.
 ]
 
 
+# AUTO: Defines function `run`.
 def run():
+    # AUTO: Sets `parser`.
     parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets,
+                       # AUTO: Sets `start_symbol`.
                        start_symbol='<program>', end_marker='EOF',
+                       # AUTO: Sets `skip_token_types`.
                        skip_token_types={'\n', 'comment', 'mcommentlit'})
+    # AUTO: Sets `ok`.
     ok = 0
+    # AUTO: Starts a loop over these values.
     for name, src, expected in PROGRAMS:
+        # AUTO: Sets `tokens, lex_errs`.
         tokens, lex_errs = lex(src)
+        # AUTO: Checks this condition.
         if lex_errs:
+            # AUTO: Executes this statement.
             print(f'{name:10s} LEX FAIL  {lex_errs[:1]}'); continue
+        # AUTO: Sets `pr`.
         pr = parser.parse_and_build(tokens)
+        # AUTO: Checks this condition.
         if not pr['success']:
+            # AUTO: Executes this statement.
             print(f'{name:10s} PARSE FAIL  {pr["errors"][:1]}'); continue
+        # AUTO: Sets `sr`.
         sr = validate_ast(pr['ast'], pr['symbol_table'])
+        # AUTO: Checks this condition.
         if not sr.get('success', True):
+            # AUTO: Executes this statement.
             print(f'{name:10s} SEM FAIL  {sr.get("errors", [])[:1]}'); continue
+        # AUTO: Sets `c`.
         c = _Collector()
+        # AUTO: Starts protected code that can catch errors.
         try:
+            # AUTO: Sets `Interpreter(socketio`.
             Interpreter(socketio=c).interpret(sr['ast'])
+            # AUTO: Executes this statement.
             status = 'OK' if c.outputs == expected else f'WRONG (expected {expected})'
+            # AUTO: Calls `print`.
             print(f'{name:10s} {status:30s} got {c.outputs}')
+            # AUTO: Checks this condition.
             if c.outputs == expected: ok += 1
+        # AUTO: Handles the matching error case.
         except Exception as e:
+            # AUTO: Calls `print`.
             print(f'{name:10s} RUN FAIL  {e}')
 
+    # AUTO: Sets `reject_ok`.
     reject_ok = 0
+    # AUTO: Starts a loop over these values.
     for name, src, expected_error in REJECTED_PROGRAMS:
+        # AUTO: Sets `tokens, lex_errs`.
         tokens, lex_errs = lex(src)
+        # AUTO: Checks this condition.
         if lex_errs:
+            # AUTO: Executes this statement.
             print(f'{name:10s} LEX FAIL  {lex_errs[:1]}'); continue
+        # AUTO: Sets `pr`.
         pr = parser.parse_and_build(tokens)
+        # AUTO: Sets `message`.
         message = pr.get('errors', [''])[0] if not pr['success'] else ''
+        # AUTO: Sets `status`.
         status = 'OK' if expected_error in message else f'WRONG (expected rejection containing {expected_error!r})'
+        # AUTO: Calls `print`.
         print(f'{name:10s} {status:30s} got {message!r}')
+        # AUTO: Checks this condition.
         if expected_error in message:
+            # AUTO: Adds into `reject_ok`.
             reject_ok += 1
+    # AUTO: Calls `print`.
     print()
+    # AUTO: Calls `print`.
     print(f'PASS: {ok}/{len(PROGRAMS)} valid, {reject_ok}/{len(REJECTED_PROGRAMS)} rejected')
+    # AUTO: Returns this result to the caller.
     return ok == len(PROGRAMS) and reject_ok == len(REJECTED_PROGRAMS)
 
 
+# AUTO: Checks this condition.
 if __name__ == '__main__':
+    # AUTO: Calls `sys.exit`.
     sys.exit(0 if run() else 1)

Backend/ai/__init__.py

@@ -1,2 +1,3 @@
 
+# AUTO: Imports names from another module.
 from .fallback import fallback_reply  # noqa: F401

Backend/cfg/__init__.py

@@ -1,9 +1,17 @@
 
+# AUTO: Imports names from another module.
 from .grammar import (  # noqa: F401
+    # AUTO: Executes this statement.
     cfg,
+    # AUTO: Executes this statement.
     first_sets,
+    # AUTO: Executes this statement.
     predict_sets,
+    # AUTO: Executes this statement.
     compute_first,
+    # AUTO: Executes this statement.
     compute_follow,
+    # AUTO: Executes this statement.
     compute_predict,
+# AUTO: Closes the current grouped code/data.
 )

Backend/cfg/grammar.py

@@ -1,665 +1,1225 @@
+"""System CFG and LL(1) helper-set generation for GrowALanguage.
+
+The parser imports cfg, first_sets, and predict_sets from this file. The grammar
+is written as productions, then FIRST/FOLLOW/PREDICT sets are computed from it.
+"""
+
+# AUTO: Imports a module used by this file.
 import sys
+# AUTO: Imports names from another module.
 from collections import defaultdict
 
+# AUTO: Checks this condition.
 if sys.platform == 'win32':
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `sys.stdout.reconfigure(encoding`.
         sys.stdout.reconfigure(encoding='utf-8')
+    # AUTO: Executes this statement.
     except:
+        # AUTO: Does nothing for this required block.
         pass
 
+# AUTO: Sets `EPSILON`.
 EPSILON = "λ"
 
 
+# AUTO: Defines function `compute_first`.
 def compute_first(cfg):
+    # GUIDE: FIRST(A) answers what token can begin strings derived from A.
+    # AUTO: Sets `first`.
     first = defaultdict(set)
+    # AUTO: Sets `epsilon`.
     epsilon = EPSILON
 
+    # AUTO: Starts a loop over these values.
     for lhs, productions in cfg.items():
+        # AUTO: Starts a loop over these values.
         for prod in productions:
+            # AUTO: Checks this condition.
             if not prod:
+                # AUTO: Skips to the next loop iteration.
                 continue
+            # AUTO: Checks this condition.
             if prod[0] == epsilon:
+                # AUTO: Calls `first[lhs].add`.
                 first[lhs].add(epsilon)
+            # AUTO: Checks the next alternate condition.
             elif prod[0] not in cfg:
+                # AUTO: Calls `first[lhs].add`.
                 first[lhs].add(prod[0])
 
+    # AUTO: Sets `changed`.
     changed = True
+    # AUTO: Repeats while this condition is true.
     while changed:
+        # AUTO: Sets `changed`.
         changed = False
+        # AUTO: Starts a loop over these values.
         for lhs, productions in cfg.items():
+            # AUTO: Starts a loop over these values.
             for prod in productions:
+                # AUTO: Sets `before`.
                 before = len(first[lhs])
 
+                # AUTO: Starts a loop over these values.
                 for symbol in prod:
+                    # AUTO: Checks this condition.
                     if symbol in cfg:
+                        # AUTO: Sets `first[lhs] |`.
                         first[lhs] |= (first[symbol] - {epsilon})
+                        # AUTO: Checks this condition.
                         if epsilon not in first[symbol]:
+                            # AUTO: Stops the nearest loop.
                             break
+                    # AUTO: Runs when previous condition did not pass.
                     else:
+                        # AUTO: Checks this condition.
                         if symbol != epsilon:
+                            # AUTO: Calls `first[lhs].add`.
                             first[lhs].add(symbol)
+                        # AUTO: Stops the nearest loop.
                         break
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Calls `first[lhs].add`.
                     first[lhs].add(epsilon)
 
+                # AUTO: Checks this condition.
                 if len(first[lhs]) > before:
+                    # AUTO: Sets `changed`.
                     changed = True
 
+    # AUTO: Returns this result to the caller.
     return first
 
 
+# AUTO: Defines function `compute_follow`.
 def compute_follow(cfg, first):
+    # GUIDE: FOLLOW(A) answers what token can appear immediately after A.
+    # AUTO: Sets `follow`.
     follow = defaultdict(set)
+    # AUTO: Sets `epsilon`.
     epsilon = EPSILON
 
+    # AUTO: Sets `start_symbol`.
     start_symbol = next(iter(cfg))
+    # AUTO: Calls `follow[start_symbol].add`.
     follow[start_symbol].add("EOF")
 
+    # AUTO: Sets `changed`.
     changed = True
+    # AUTO: Repeats while this condition is true.
     while changed:
+        # AUTO: Sets `changed`.
         changed = False
+        # AUTO: Starts a loop over these values.
         for lhs, productions in cfg.items():
+            # AUTO: Starts a loop over these values.
             for prod in productions:
+                # AUTO: Starts a loop over these values.
                 for i, symbol in enumerate(prod):
+                    # AUTO: Checks this condition.
                     if symbol in cfg:
+                        # AUTO: Sets `before`.
                         before = len(follow[symbol])
 
+                        # AUTO: Sets `j`.
                         j = i + 1
+                        # AUTO: Repeats while this condition is true.
                         while j < len(prod):
+                            # AUTO: Sets `next_symbol`.
                             next_symbol = prod[j]
+                            # AUTO: Checks this condition.
                             if next_symbol in cfg:
+                                # AUTO: Sets `follow[symbol] |`.
                                 follow[symbol] |= (first[next_symbol] - {epsilon})
+                                # AUTO: Checks this condition.
                                 if epsilon not in first[next_symbol]:
+                                    # AUTO: Stops the nearest loop.
                                     break
+                            # AUTO: Runs when previous condition did not pass.
                             else:
+                                # AUTO: Checks this condition.
                                 if next_symbol != epsilon:
+                                    # AUTO: Calls `follow[symbol].add`.
                                     follow[symbol].add(next_symbol)
+                                # AUTO: Stops the nearest loop.
                                 break
+                            # AUTO: Adds into `j`.
                             j += 1
+                        # AUTO: Runs when previous condition did not pass.
                         else:
+                            # AUTO: Sets `follow[symbol] |`.
                             follow[symbol] |= follow[lhs]
 
+                        # AUTO: Checks this condition.
                         if len(follow[symbol]) > before:
+                            # AUTO: Sets `changed`.
                             changed = True
 
+    # AUTO: Returns this result to the caller.
     return follow
 
 
+# AUTO: Defines function `compute_predict`.
 def compute_predict(cfg, first, follow):
+    # GUIDE: PREDICT chooses a production using one lookahead token.
+    # AUTO: Sets `predict`.
     predict = {}
+    # AUTO: Sets `epsilon`.
     epsilon = EPSILON
 
+    # AUTO: Starts a loop over these values.
     for lhs, productions in cfg.items():
+        # AUTO: Starts a loop over these values.
         for prod in productions:
+            # AUTO: Sets `key`.
             key = (lhs, tuple(prod))
+            # AUTO: Sets `predict[key]`.
             predict[key] = set()
 
+            # AUTO: Checks this condition.
             if not prod or (len(prod) == 1 and prod[0] == epsilon):
+                # AUTO: Sets `predict[key]`.
                 predict[key] = follow[lhs].copy()
+                # AUTO: Skips to the next loop iteration.
                 continue
 
+            # AUTO: Sets `first_set`.
             first_set = set()
+            # AUTO: Starts a loop over these values.
             for symbol in prod:
+                # AUTO: Checks this condition.
                 if symbol in cfg:
+                    # AUTO: Sets `first_set |`.
                     first_set |= (first[symbol] - {epsilon})
+                    # AUTO: Checks this condition.
                     if epsilon not in first[symbol]:
+                        # AUTO: Stops the nearest loop.
                         break
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Checks this condition.
                     if symbol != epsilon:
+                        # AUTO: Calls `first_set.add`.
                         first_set.add(symbol)
+                    # AUTO: Stops the nearest loop.
                     break
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Calls `first_set.add`.
                 first_set.add(epsilon)
 
+            # AUTO: Checks this condition.
             if epsilon in first_set:
+                # AUTO: Sets `predict[key]`.
                 predict[key] = (first_set - {epsilon}) | follow[lhs]
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Sets `predict[key]`.
                 predict[key] = first_set
 
+    # AUTO: Returns this result to the caller.
     return predict
 
 
+# GUIDE: Actual grammar used by parser.py; terminals match lexer token.type values.
+# AUTO: Sets `cfg`.
 cfg = {
+    # AUTO: Executes this statement.
     "<program>": [
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "<global_declaration>",
+            # AUTO: Executes this statement.
             "<function_definition>",
+            # AUTO: Executes this statement.
             "root",
+            # AUTO: Executes this statement.
             "(",
+            # AUTO: Executes this statement.
             ")",
+            # AUTO: Executes this statement.
             "{",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<body_statement>",
+            # AUTO: Executes this statement.
             "reclaim",
+            # AUTO: Executes this statement.
             ";",
+            # AUTO: Executes this statement.
             "}",
+        # AUTO: Closes the current grouped code/data.
         ]
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<global_declaration>": [
+        # AUTO: Executes this statement.
         ["bundle", "id", "<bundle_or_var>", "<global_declaration>"],
+        # AUTO: Executes this statement.
         ["<data_type>", "id", "<array_dec>", "<var_value>", ";", "<global_declaration>"],
+        # AUTO: Sets `["fertile", "<data_type>", "id", "`.
         ["fertile", "<data_type>", "id", "=", "<init_val>", "<const_next>", ";", "<global_declaration>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<bundle_or_var>": [
+        # AUTO: Executes this statement.
         ["{", "<bundle_members>", "}", ";"],
+        # AUTO: Executes this statement.
         ["<bundle_mem_dec>", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<local_declaration>": [
+        # AUTO: Executes this statement.
         ["<var_dec>", ";", "<local_declaration>"],
+        # AUTO: Executes this statement.
         ["<const_dec>", ";", "<local_declaration>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<data_type>": [
+        # AUTO: Executes this statement.
         ["seed"],
+        # AUTO: Executes this statement.
         ["tree"],
+        # AUTO: Executes this statement.
         ["leaf"],
+        # AUTO: Executes this statement.
         ["branch"],
+        # AUTO: Executes this statement.
         ["vine"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<const_dec>": [
+        # AUTO: Sets `["fertile", "<data_type>", "id", "`.
         ["fertile", "<data_type>", "id", "=", "<init_val>", "<const_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<const_next>": [
+        # AUTO: Sets `[",", "id", "`.
         [",", "id", "=", "<init_val>", "<const_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<var_dec>": [
+        # AUTO: Executes this statement.
         ["<data_type>", "id", "<array_dec>", "<var_value>"],
+        # AUTO: Executes this statement.
         ["bundle", "id", "<bundle_mem_dec>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<bundle_mem_dec>": [
+        # AUTO: Executes this statement.
         ["id", "<array_dec>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<var_value>": [
+        # AUTO: Sets `["`.
         ["=", "<init_val>", "<var_value_next>"],
+        # AUTO: Executes this statement.
         ["<var_value_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<var_value_next>": [
+        # AUTO: Executes this statement.
         [",", "id", "<array_dec>", "<var_value>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<init_val>": [
+        # AUTO: Executes this statement.
         ["<array_init_opt>"],
+        # AUTO: Executes this statement.
         ["water", "(", "<water_arg>", ")"],
+        # AUTO: Executes this statement.
         ["<expression>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<array_dec>": [
+        # AUTO: Executes this statement.
         ["[", "<array_dim_opt>", "]", "<array_dec>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<array_dim_opt>": [
+        # AUTO: Executes this statement.
         ["intlit"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<array_init_opt>": [
+        # AUTO: Executes this statement.
         ["{", "<init_vals>", "}"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<init_vals>": [
+        # AUTO: Executes this statement.
         ["<init_val_item>", "<init_vals_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<init_vals_next>": [
+        # AUTO: Executes this statement.
         [",", "<init_val_item>", "<init_vals_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<init_val_item>": [
+        # AUTO: Executes this statement.
         ["{", "<init_vals>", "}"],
+        # AUTO: Executes this statement.
         ["<expression>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<bundle_members>": [
+        # AUTO: Executes this statement.
         ["<data_type>", "id", ";", "<bundle_members>"],
+        # AUTO: Executes this statement.
         ["id", "id", ";", "<bundle_members>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<function_definition>": [
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "pollinate",
+            # AUTO: Executes this statement.
             "<return_type>",
+            # AUTO: Executes this statement.
             "id",
+            # AUTO: Executes this statement.
             "(",
+            # AUTO: Executes this statement.
             "<parameters>",
+            # AUTO: Executes this statement.
             ")",
+            # AUTO: Executes this statement.
             "{",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<body_statement>",
+            # AUTO: Executes this statement.
             "reclaim",
+            # AUTO: Executes this statement.
             "<reclaim_value>",
+            # AUTO: Executes this statement.
             "}",
+            # AUTO: Executes this statement.
             "<function_definition>",
+        # AUTO: Closes the current grouped code/data.
         ],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<return_type>": [
+        # AUTO: Executes this statement.
         ["<data_type>"],
+        # AUTO: Executes this statement.
         ["empty"],
+        # AUTO: Executes this statement.
         ["id"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<parameters>": [
+        # AUTO: Executes this statement.
         [EPSILON],
+        # AUTO: Executes this statement.
         ["<param>", "<param_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<param>": [
+        # AUTO: Executes this statement.
         ["<data_type>", "id", "<param_array>"],
+        # AUTO: Executes this statement.
         ["id", "id"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<param_array>": [
+        # AUTO: Executes this statement.
         [EPSILON],
+        # AUTO: Executes this statement.
         ["[", "]"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<param_next>": [
+        # AUTO: Executes this statement.
         [EPSILON],
+        # AUTO: Executes this statement.
         [",", "<param>", "<param_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<reclaim_value>": [
+        # AUTO: Executes this statement.
         ["<expression>", ";"],
+        # AUTO: Executes this statement.
         [";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<body_statement>": [
+        # AUTO: Executes this statement.
         ["<non_reclaim_stmt>", "<body_statement>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<non_reclaim_stmt>": [
+        # AUTO: Executes this statement.
         ["id", "<id_stmt>"],
+        # AUTO: Executes this statement.
         ["<inc_dec_op>", "id", "<id_next>", ";"],
+        # AUTO: Executes this statement.
         ["<io_stmt>"],
+        # AUTO: Executes this statement.
         ["<conditional_stmt>"],
+        # AUTO: Executes this statement.
         ["<loop_stmt>"],
+        # AUTO: Executes this statement.
         ["<switch_stmt>"],
+        # AUTO: Executes this statement.
         ["<control_stmt>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<statement>": [
+        # AUTO: Executes this statement.
         ["<simple_stmt>", "<statement>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<simple_stmt>": [
+        # AUTO: Executes this statement.
         ["<non_reclaim_stmt>"],
+        # AUTO: Executes this statement.
         ["reclaim", "<reclaim_value>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<id_stmt>": [
+        # AUTO: Executes this statement.
         ["<id_next>", "<id_stmt_tail>"],
+        # AUTO: Executes this statement.
         ["(", "<arguments>", ")", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<id_stmt_tail>": [
+        # AUTO: Executes this statement.
         ["<assign_op>", "<assign_rhs>", ";"],
+        # AUTO: Executes this statement.
         ["<inc_dec_op>", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<assign_rhs>": [
+        # AUTO: Executes this statement.
         ["water", "(", "<water_arg>", ")"],
+        # AUTO: Executes this statement.
         ["<expression>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<assign_op>": [
+        # AUTO: Sets `["`.
         ["="],
+        # AUTO: Adds into `["`.
         ["+="],
+        # AUTO: Subtracts from `["`.
         ["-="],
+        # AUTO: Multiplies into `["`.
         ["*="],
+        # AUTO: Divides into `["`.
         ["/="],
+        # AUTO: Sets `["%`.
         ["%="],
+        # AUTO: Multiplies into `["*`.
         ["**="],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<id_next>": [
+        # AUTO: Executes this statement.
         ["<array_access>", "<post_array_access>"],
+        # AUTO: Executes this statement.
         ["<struct_access>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<array_access>": [
+        # AUTO: Executes this statement.
         ["[", "<expression>", "]", "<array_access_more>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<array_access_more>": [
+        # AUTO: Executes this statement.
         ["[", "<expression>", "]", "<array_access_more>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<struct_access>": [
+        # AUTO: Executes this statement.
         [".", "id", "<struct_access_more>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<struct_access_more>": [
+        # AUTO: Executes this statement.
         [".", "id", "<struct_access_more>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<post_array_access>": [
+        # AUTO: Executes this statement.
         [".", "id", "<post_array_access>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<io_stmt>": [
+        # AUTO: Executes this statement.
         ["plant", "(", "<arguments>", ")", ";"],
+        # AUTO: Executes this statement.
         ["water", "(", "<water_arg>", ")", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<water_arg>": [
+        # AUTO: Executes this statement.
         ["<data_type>"],
+        # AUTO: Executes this statement.
         ["id", "<water_id_tail>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<water_id_tail>": [
+        # AUTO: Executes this statement.
         ["[", "<expression>", "]", "<water_id_tail>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<arguments>": [
+        # AUTO: Executes this statement.
         ["<expression>", "<arg_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<arg_next>": [
+        # AUTO: Executes this statement.
         [",", "<expression>", "<arg_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<conditional_stmt>": [
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "spring",
+            # AUTO: Executes this statement.
             "(",
+            # AUTO: Executes this statement.
             "<expression>",
+            # AUTO: Executes this statement.
             ")",
+            # AUTO: Executes this statement.
             "{",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<statement>",
+            # AUTO: Executes this statement.
             "}",
+            # AUTO: Executes this statement.
             "<elseif_chain>",
+            # AUTO: Executes this statement.
             "<else_opt>",
+        # AUTO: Closes the current grouped code/data.
         ]
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<elseif_chain>": [
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "bud",
+            # AUTO: Executes this statement.
             "(",
+            # AUTO: Executes this statement.
             "<expression>",
+            # AUTO: Executes this statement.
             ")",
+            # AUTO: Executes this statement.
             "{",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<statement>",
+            # AUTO: Executes this statement.
             "}",
+            # AUTO: Executes this statement.
             "<elseif_chain>",
+        # AUTO: Closes the current grouped code/data.
         ],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<else_opt>": [
+        # AUTO: Executes this statement.
         ["wither", "{", "<local_declaration>", "<statement>", "}"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<loop_stmt>": [
+        # AUTO: Executes this statement.
         ["grow", "(", "<expression>", ")", "{", "<local_declaration>", "<statement>", "}"],
         
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "cultivate",
+            # AUTO: Executes this statement.
             "(",
+            # AUTO: Executes this statement.
             "<for_init>",
+            # AUTO: Executes this statement.
             ";",
+            # AUTO: Executes this statement.
             "<expression>",
+            # AUTO: Executes this statement.
             ";",
+            # AUTO: Executes this statement.
             "<for_update>",
+            # AUTO: Executes this statement.
             ")",
+            # AUTO: Executes this statement.
             "{",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<statement>",
+            # AUTO: Executes this statement.
             "}",
+        # AUTO: Closes the current grouped code/data.
         ],
         
+        # AUTO: Executes this statement.
         ["tend", "{", "<local_declaration>", "<statement>", "}", "grow", "(", "<expression>", ")", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<for_init>": [
+        # AUTO: Executes this statement.
         ["<data_type>", "id", "<array_dec>", "<var_value>"],
+        # AUTO: Executes this statement.
         ["id", "<id_next>", "<assign_op>", "<expression>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<for_update>": [
+        # AUTO: Executes this statement.
         ["id", "<id_next>", "<for_update_tail>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<for_update_tail>": [
+        # AUTO: Executes this statement.
         ["<inc_dec_op>"],
+        # AUTO: Executes this statement.
         ["<assign_op>", "<expression>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<inc_dec_op>": [
+        # AUTO: Executes this statement.
         ["++"],
+        # AUTO: Executes this statement.
         ["--"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<switch_stmt>": [
+        # AUTO: Executes this statement.
         ["harvest", "(", "<expression>", ")", "{", "<case_list>", "<default_opt>", "}"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<case_list>": [
+        # AUTO: Executes this statement.
         [
+            # AUTO: Executes this statement.
             "variety",
+            # AUTO: Executes this statement.
             "<case_literal>",
+            # AUTO: Executes this statement.
             ":",
+            # AUTO: Executes this statement.
             "<local_declaration>",
+            # AUTO: Executes this statement.
             "<case_statements>",
+            # AUTO: Executes this statement.
             "<case_list>",
+        # AUTO: Closes the current grouped code/data.
         ],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<case_literal>": [
+        # AUTO: Executes this statement.
         ["intlit"],
+        # AUTO: Executes this statement.
         ["chrlit"],
+        # AUTO: Executes this statement.
         ["sunshine"],
+        # AUTO: Executes this statement.
         ["frost"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<case_statements>": [
+        # AUTO: Executes this statement.
         ["<case_statement>", "<case_statements>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
     
+    # AUTO: Executes this statement.
     "<case_statement>": [
+        # AUTO: Executes this statement.
         ["id", "<id_stmt>"],
+        # AUTO: Executes this statement.
         ["<inc_dec_op>", "id", "<id_next>", ";"],
+        # AUTO: Executes this statement.
         ["<io_stmt>"],
+        # AUTO: Executes this statement.
         ["<conditional_stmt>"],
+        # AUTO: Executes this statement.
         ["<loop_stmt>"],
+        # AUTO: Executes this statement.
         ["<switch_stmt>"],
+        # AUTO: Executes this statement.
         ["{", "<local_declaration>", "<statement>", "}"],
+        # AUTO: Executes this statement.
         ["prune", ";"],
+        # AUTO: Executes this statement.
         ["skip", ";"],
+        # AUTO: Executes this statement.
         ["reclaim", "<reclaim_value>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<default_opt>": [
+        # AUTO: Executes this statement.
         ["soil", ":", "<local_declaration>", "<case_statements>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<control_stmt>": [
+        # AUTO: Executes this statement.
         ["prune", ";"],
+        # AUTO: Executes this statement.
         ["skip", ";"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
 
+    # AUTO: Executes this statement.
     "<expression>": [
+        # AUTO: Executes this statement.
         ["<assignment_expression>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<assignment_expression>": [
+        # AUTO: Executes this statement.
         ["<logic_or>", "<assignment_expression_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<assignment_expression_next>": [
+        # AUTO: Executes this statement.
         ["<assign_op>", "<assignment_expression>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<logic_or>": [
+        # AUTO: Executes this statement.
         ["<logic_and>", "<logic_or_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<logic_or_next>": [
+        # AUTO: Executes this statement.
         ["||", "<logic_and>", "<logic_or_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<logic_and>": [
+        # AUTO: Executes this statement.
         ["<relational>", "<logic_and_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<logic_and_next>": [
+        # AUTO: Executes this statement.
         ["&&", "<relational>", "<logic_and_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<relational>": [
+        # AUTO: Executes this statement.
         ["<arithmetic>", "<relational_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<relational_next>": [
+        # AUTO: Executes this statement.
         ["<relational_op>", "<arithmetic>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<relational_op>": [
+        # AUTO: Executes this statement.
         [">"],
+        # AUTO: Executes this statement.
         ["<"],
+        # AUTO: Executes this statement.
         [">="],
+        # AUTO: Executes this statement.
         ["<="],
+        # AUTO: Executes this statement.
         ["=="],
+        # AUTO: Executes this statement.
         ["!="],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<arithmetic>": [
+        # AUTO: Executes this statement.
         ["<term>", "<arithmetic_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<arithmetic_next>": [
+        # AUTO: Executes this statement.
         ["+", "<term>", "<arithmetic_next>"],
+        # AUTO: Executes this statement.
         ["-", "<term>", "<arithmetic_next>"],
+        # AUTO: Executes this statement.
         ["`", "<term>", "<arithmetic_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
 
+    # AUTO: Executes this statement.
     "<term>": [
+        # AUTO: Executes this statement.
         ["<power>", "<term_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<term_next>": [
+        # AUTO: Executes this statement.
         ["*", "<power>", "<term_next>"],
+        # AUTO: Executes this statement.
         ["/", "<power>", "<term_next>"],
+        # AUTO: Executes this statement.
         ["%", "<power>", "<term_next>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<power>": [
+        # AUTO: Executes this statement.
         ["<factor>", "<power_next>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<power_next>": [
+        # AUTO: Executes this statement.
         ["**", "<power>"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<factor>": [
+        # AUTO: Executes this statement.
         ["(", "<paren_expr>"],
+        # AUTO: Executes this statement.
         ["<unary_op>", "<factor>"],
+        # AUTO: Executes this statement.
         ["id", "<factor_id_next>"],
+        # AUTO: Executes this statement.
         ["<literal>"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<literal>": [
+        # AUTO: Executes this statement.
         ["intlit"],
+        # AUTO: Executes this statement.
         ["dblit"],
+        # AUTO: Executes this statement.
         ["chrlit"],
+        # AUTO: Executes this statement.
         ["stringlit"],
+        # AUTO: Executes this statement.
         ["sunshine"],
+        # AUTO: Executes this statement.
         ["frost"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<paren_expr>": [
+        # AUTO: Executes this statement.
         ["<data_type>", ")", "<factor>"],
+        # AUTO: Executes this statement.
         ["<expression>", ")"],
+    # AUTO: Closes the current grouped code/data.
     ],
     
+    # AUTO: Executes this statement.
     "<unary_op>": [
+        # AUTO: Executes this statement.
         ["~"],
+        # AUTO: Executes this statement.
         ["!"],
+    # AUTO: Closes the current grouped code/data.
     ],
 
+    # AUTO: Executes this statement.
     "<factor_id_next>": [
+        # AUTO: Executes this statement.
         ["<array_access>", "<post_array_access>"],
+        # AUTO: Executes this statement.
         ["<struct_access>"],
+        # AUTO: Executes this statement.
         ["(", "<arguments>", ")"],
+        # AUTO: Executes this statement.
         [EPSILON],
+    # AUTO: Closes the current grouped code/data.
     ],
+# AUTO: Closes the current grouped code/data.
 }
 
 
+# GUIDE: Build the LL(1) helper sets once at import time.
+# AUTO: Sets `first_sets`.
 first_sets = compute_first(cfg)
+# AUTO: Sets `follow_sets`.
 follow_sets = compute_follow(cfg, first_sets)
+# AUTO: Sets `predict_sets`.
 predict_sets = compute_predict(cfg, first_sets, follow_sets)
 
 
+# AUTO: Checks this condition.
 if __name__ == '__main__':
+    # AUTO: Sets `print("`.
     print("=" * 80)
+    # AUTO: Calls `print`.
     print("FIRST SETS")
+    # AUTO: Sets `print("`.
     print("=" * 80)
+    # AUTO: Calls `print`.
     print("Shows which terminals can appear first in each non-terminal")
+    # AUTO: Calls `print`.
     print()
+    # AUTO: Starts a loop over these values.
     for nt in first_sets:
+        # AUTO: Sets `print(f"First({nt})`.
         print(f"First({nt}) = {{ {', '.join(sorted(first_sets[nt]))} }}")
 
+    # AUTO: Sets `print("\n" + "`.
     print("\n" + "=" * 80)
+    # AUTO: Calls `print`.
     print("FOLLOW SETS")
+    # AUTO: Sets `print("`.
     print("=" * 80)
+    # AUTO: Calls `print`.
     print("Shows which terminals can appear after each non-terminal")
+    # AUTO: Calls `print`.
     print()
+    # AUTO: Starts a loop over these values.
     for nt in follow_sets:
+        # AUTO: Sets `print(f"Follow({nt})`.
         print(f"Follow({nt}) = {{ {', '.join(sorted(follow_sets[nt]))} }}")
 
+    # AUTO: Sets `print("\n" + "`.
     print("\n" + "=" * 80)
+    # AUTO: Calls `print`.
     print("PREDICT SETS")
+    # AUTO: Sets `print("`.
     print("=" * 80)
+    # AUTO: Calls `print`.
     print("Shows which terminal triggers each production rule")
+    # AUTO: Calls `print`.
     print()
+    # AUTO: Starts a loop over these values.
     for (lhs, prod), pset in predict_sets.items():
+        # AUTO: Sets `prod_str`.
         prod_str = " ".join(prod)
+        # AUTO: Sets `print(f"Predict({lhs} -> {prod_str})`.
         print(f"Predict({lhs} -> {prod_str}) = {{ {', '.join(sorted(pset))} }}")
 
+    # AUTO: Sets `print("\n" + "`.
     print("\n" + "=" * 80)

Backend/icg/__init__.py

@@ -1,2 +1,3 @@
 
+# AUTO: Imports names from another module.
 from .generator import generate_icg, ICGenerator, TACInstruction  # noqa: F401

Backend/icg/generator.py

@@ -1,989 +1,1822 @@
+# AUTO: Imports names from another module.
 from __future__ import annotations
+# AUTO: Imports names from another module.
 from dataclasses import dataclass
+# AUTO: Imports names from another module.
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 
+# AUTO: Attaches this decorator to the next function/class.
 @dataclass
+# AUTO: Defines class `_Tok`.
 class _Tok:
+    # AUTO: Executes this statement.
     type: str
+    # AUTO: Executes this statement.
     value: str
+    # AUTO: Executes this statement.
     line: int
+    # AUTO: Sets `col: int`.
     col: int = 0
 
 
+# AUTO: Defines function `_as_tok`.
 def _as_tok(raw: Any) -> _Tok:
+    # AUTO: Checks this condition.
     if isinstance(raw, dict):
+        # AUTO: Returns this result to the caller.
         return _Tok(
+            # AUTO: Sets `type`.
             type=str(raw.get("type", "")),
+            # AUTO: Sets `value`.
             value=str(raw.get("value", "")),
+            # AUTO: Sets `line`.
             line=int(raw.get("line", 0) or 0),
+            # AUTO: Sets `col`.
             col=int(raw.get("col", 0) or 0),
+        # AUTO: Closes the current grouped code/data.
         )
+    # AUTO: Returns this result to the caller.
     return _Tok(
+        # AUTO: Sets `type`.
         type=str(getattr(raw, "type", "")),
+        # AUTO: Sets `value`.
         value=str(getattr(raw, "value", "")),
+        # AUTO: Sets `line`.
         line=int(getattr(raw, "line", 0) or 0),
+        # AUTO: Sets `col`.
         col=int(getattr(raw, "col", 0) or 0),
+    # AUTO: Closes the current grouped code/data.
     )
 
 
+# AUTO: Attaches this decorator to the next function/class.
 @dataclass
+# AUTO: Defines class `TACInstruction`.
 class TACInstruction:
+    # AUTO: Executes this statement.
     op: str
+    # AUTO: Sets `arg1: Optional[str]`.
     arg1: Optional[str] = None
+    # AUTO: Sets `arg2: Optional[str]`.
     arg2: Optional[str] = None
+    # AUTO: Sets `result: Optional[str]`.
     result: Optional[str] = None
 
+    # AUTO: Defines function `__str__`.
     def __str__(self) -> str:
+        # AUTO: Checks this condition.
         if self.op == "LABEL":
+            # AUTO: Returns this result to the caller.
             return f"{self.result}:"
+        # AUTO: Checks this condition.
         if self.op == "GOTO":
+            # AUTO: Returns this result to the caller.
             return f"goto {self.result}"
+        # AUTO: Checks this condition.
         if self.op == "IF":
+            # AUTO: Returns this result to the caller.
             return f"if {self.arg1} goto {self.result}"
+        # AUTO: Checks this condition.
         if self.op == "IFFALSE":
+            # AUTO: Returns this result to the caller.
             return f"ifFalse {self.arg1} goto {self.result}"
+        # AUTO: Checks this condition.
         if self.op == "PARAM":
+            # AUTO: Returns this result to the caller.
             return f"param {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "CALL":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = call {self.arg1}, {self.arg2}"
+        # AUTO: Checks this condition.
         if self.op == "RETURN":
+            # AUTO: Returns this result to the caller.
             return f"return {self.arg1 or ''}"
+        # AUTO: Checks this condition.
         if self.op == "PRINT":
+            # AUTO: Returns this result to the caller.
             return f"print {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "READ":
+            # AUTO: Returns this result to the caller.
             return f"read {self.result}"
+        # AUTO: Checks this condition.
         if self.op == "FUNC":
+            # AUTO: Returns this result to the caller.
             return f"func {self.arg1}:"
+        # AUTO: Checks this condition.
         if self.op == "ENDFUNC":
+            # AUTO: Returns this result to the caller.
             return f"endfunc"
+        # AUTO: Checks this condition.
         if self.op == "DECLARE":
+            # AUTO: Returns this result to the caller.
             return f"declare {self.result} : {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "ARRAY_DECLARE":
+            # AUTO: Returns this result to the caller.
             return f"declare {self.result}[{self.arg2}] : {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "ARRAY_STORE":
+            # AUTO: Returns this result to the caller.
             return f"{self.result}[{self.arg2}] = {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "ARRAY_LOAD":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = {self.arg1}[{self.arg2}]"
+        # AUTO: Checks this condition.
         if self.op == "STRUCT_STORE":
+            # AUTO: Returns this result to the caller.
             return f"{self.arg1}.{self.arg2} = {self.result}"
+        # AUTO: Checks this condition.
         if self.op == "STRUCT_LOAD":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = {self.arg1}.{self.arg2}"
+        # AUTO: Checks this condition.
         if self.op == "CONST":
+            # AUTO: Returns this result to the caller.
             return f"const {self.result} : {self.arg1} = {self.arg2}"
+        # AUTO: Checks this condition.
         if self.op == "INC":
+            # AUTO: Returns this result to the caller.
             return f"{self.arg1} = {self.arg1} + 1"
+        # AUTO: Checks this condition.
         if self.op == "DEC":
+            # AUTO: Returns this result to the caller.
             return f"{self.arg1} = {self.arg1} - 1"
+        # AUTO: Checks this condition.
         if self.arg2 is not None:
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = {self.arg1} {self.op} {self.arg2}"
+        # AUTO: Checks this condition.
         if self.op == "=":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = {self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "UNARY_MINUS":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = -{self.arg1}"
+        # AUTO: Checks this condition.
         if self.op == "NOT":
+            # AUTO: Returns this result to the caller.
             return f"{self.result} = !{self.arg1}"
+        # AUTO: Returns this result to the caller.
         return f"{self.op} {self.arg1 or ''} {self.arg2 or ''} {self.result or ''}".strip()
 
+    # AUTO: Defines function `to_dict`.
     def to_dict(self) -> dict:
+        # AUTO: Returns this result to the caller.
         return {
+            # AUTO: Executes this statement.
             "op": self.op,
+            # AUTO: Executes this statement.
             "arg1": self.arg1,
+            # AUTO: Executes this statement.
             "arg2": self.arg2,
+            # AUTO: Executes this statement.
             "result": self.result,
+            # AUTO: Calls `str`.
             "text": str(self),
+        # AUTO: Closes the current grouped code/data.
         }
 
 
+# AUTO: Sets `GAL_TYPE_MAP`.
 GAL_TYPE_MAP = {
+    # AUTO: Executes this statement.
     "seed": "int",
+    # AUTO: Executes this statement.
     "tree": "float",
+    # AUTO: Executes this statement.
     "leaf": "char",
+    # AUTO: Executes this statement.
     "branch": "bool",
+    # AUTO: Executes this statement.
     "vine": "string",
+    # AUTO: Executes this statement.
     "empty": "void",
+# AUTO: Closes the current grouped code/data.
 }
 
+# AUTO: Sets `DATA_TYPE_TOKENS`.
 DATA_TYPE_TOKENS = set(GAL_TYPE_MAP.keys())
 
+# AUTO: Adds into `ASSIGN_OPS = {"=", "`.
 ASSIGN_OPS = {"=", "+=", "-=", "*=", "/=", "%="}
 
 
+# AUTO: Defines class `ICGenerator`.
 class ICGenerator:
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, tokens: List[Any]):
+        # AUTO: Sets `self.tokens: List[_Tok]`.
         self.tokens: List[_Tok] = self._prepare(tokens)
+        # AUTO: Sets `self.pos: int`.
         self.pos: int = 0
+        # AUTO: Sets `self.code: List[TACInstruction]`.
         self.code: List[TACInstruction] = []
+        # AUTO: Sets `self.errors: List[str]`.
         self.errors: List[str] = []
+        # AUTO: Sets `self._temp_counter: int`.
         self._temp_counter: int = 0
+        # AUTO: Sets `self._label_counter: int`.
         self._label_counter: int = 0
 
 
+    # AUTO: Defines function `_prepare`.
     def _prepare(self, raw_tokens: List[Any]) -> List[_Tok]:
+        # AUTO: Sets `toks: List[_Tok]`.
         toks: List[_Tok] = []
+        # AUTO: Starts a loop over these values.
         for t in raw_tokens:
+            # AUTO: Sets `tv`.
             tv = _as_tok(t)
+            # AUTO: Checks this condition.
             if tv.type in ("\n", "comment", "mcommentlit"):
+                # AUTO: Skips to the next loop iteration.
                 continue
+            # AUTO: Appends a value to a list.
             toks.append(tv)
+        # AUTO: Checks this condition.
         if not toks or toks[-1].type != "EOF":
+            # AUTO: Sets `last_line`.
             last_line = toks[-1].line if toks else 1
+            # AUTO: Appends a value to a list.
             toks.append(_Tok("EOF", "EOF", last_line))
+        # AUTO: Returns this result to the caller.
         return toks
 
+    # AUTO: Defines function `_peek`.
     def _peek(self) -> _Tok:
+        # AUTO: Checks this condition.
         if self.pos < len(self.tokens):
+            # AUTO: Returns this result to the caller.
             return self.tokens[self.pos]
+        # AUTO: Returns this result to the caller.
         return _Tok("EOF", "EOF", 0)
 
+    # AUTO: Defines function `_advance`.
     def _advance(self) -> _Tok:
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if self.pos < len(self.tokens):
+            # AUTO: Adds into `self.pos`.
             self.pos += 1
+        # AUTO: Returns this result to the caller.
         return tok
 
+    # AUTO: Defines function `_expect`.
     def _expect(self, token_type: str) -> _Tok:
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if tok.type != token_type:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"ICG Line {tok.line}: expected '{token_type}', got '{tok.type}'"
+            # AUTO: Closes the current grouped code/data.
             )
+            # AUTO: Returns this result to the caller.
             return tok
+        # AUTO: Returns this result to the caller.
         return self._advance()
 
+    # AUTO: Defines function `_match`.
     def _match(self, token_type: str) -> bool:
+        # AUTO: Checks this condition.
         if self._peek().type == token_type:
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Returns this result to the caller.
             return True
+        # AUTO: Returns this result to the caller.
         return False
 
+    # AUTO: Defines function `_new_temp`.
     def _new_temp(self) -> str:
+        # AUTO: Sets `name`.
         name = f"t{self._temp_counter}"
+        # AUTO: Adds into `self._temp_counter`.
         self._temp_counter += 1
+        # AUTO: Returns this result to the caller.
         return name
 
+    # AUTO: Defines function `_new_label`.
     def _new_label(self) -> str:
+        # AUTO: Sets `name`.
         name = f"L{self._label_counter}"
+        # AUTO: Adds into `self._label_counter`.
         self._label_counter += 1
+        # AUTO: Returns this result to the caller.
         return name
 
+    # AUTO: Defines function `_emit`.
     def _emit(self, op: str, arg1: Optional[str] = None,
+              # AUTO: Sets `arg2: Optional[str]`.
               arg2: Optional[str] = None, result: Optional[str] = None):
+        # AUTO: Appends a value to a list.
         self.code.append(TACInstruction(op, arg1, arg2, result))
 
+    # AUTO: Defines function `_is_data_type`.
     def _is_data_type(self, tok: _Tok) -> bool:
+        # AUTO: Returns this result to the caller.
         return tok.type in DATA_TYPE_TOKENS
 
 
+    # AUTO: Defines function `generate`.
     def generate(self) -> Tuple[List[TACInstruction], List[str]]:
+        # AUTO: Starts protected code that can catch errors.
         try:
+            # AUTO: Calls `self._program`.
             self._program()
+        # AUTO: Handles the matching error case.
         except Exception as exc:
+            # AUTO: Appends a value to a list.
             self.errors.append(f"ICG internal error: {exc}")
+        # AUTO: Returns this result to the caller.
         return self.code, self.errors
 
+    # AUTO: Defines function `_program`.
     def _program(self):
+        # AUTO: Calls `self._global_declaration`.
         self._global_declaration()
+        # AUTO: Calls `self._function_definition`.
         self._function_definition()
 
+        # AUTO: Calls `self._expect`.
         self._expect("root")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
+        # AUTO: Calls `self._expect`.
         self._expect(")")
+        # AUTO: Calls `self._expect`.
         self._expect("{")
+        # AUTO: Calls `self._emit`.
         self._emit("FUNC", "root")
 
+        # AUTO: Calls `self._declaration`.
         self._declaration()
+        # AUTO: Calls `self._statement`.
         self._statement()
 
+        # AUTO: Calls `self._expect`.
         self._expect("reclaim")
+        # AUTO: Calls `self._expect`.
         self._expect(";")
+        # AUTO: Calls `self._emit`.
         self._emit("RETURN")
 
+        # AUTO: Calls `self._expect`.
         self._expect("}")
+        # AUTO: Calls `self._emit`.
         self._emit("ENDFUNC")
 
 
+    # AUTO: Defines function `_global_declaration`.
     def _global_declaration(self):
+        # AUTO: Repeats while this condition is true.
         while True:
+            # AUTO: Sets `tok`.
             tok = self._peek()
+            # AUTO: Checks this condition.
             if tok.type == "bundle":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `name_tok`.
                 name_tok = self._expect("id")
+                # AUTO: Sets `nxt`.
                 nxt = self._peek()
+                # AUTO: Checks this condition.
                 if nxt.type == "{":
+                    # AUTO: Calls `self._advance`.
                     self._advance()
+                    # AUTO: Calls `self._bundle_members`.
                     self._bundle_members()
+                    # AUTO: Calls `self._expect`.
                     self._expect("}")
+                    # AUTO: Calls `self._expect`.
                     self._expect(";")
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Calls `self._bundle_mem_dec`.
                     self._bundle_mem_dec()
+                    # AUTO: Calls `self._expect`.
                     self._expect(";")
+                # AUTO: Calls `self._global_declaration`.
                 self._global_declaration()
+                # AUTO: Returns this result to the caller.
                 return
 
+            # AUTO: Checks the next alternate condition.
             elif self._is_data_type(tok):
+                # AUTO: Sets `dtype`.
                 dtype = self._advance()
+                # AUTO: Sets `id_tok`.
                 id_tok = self._expect("id")
+                # AUTO: Sets `arr_dims`.
                 arr_dims = self._array_dec()
+                # AUTO: Checks this condition.
                 if arr_dims:
+                    # AUTO: Starts a loop over these values.
                     for dim in arr_dims:
+                        # AUTO: Calls `self._emit`.
                         self._emit("ARRAY_DECLARE", GAL_TYPE_MAP.get(dtype.type, dtype.type),
+                                   # AUTO: Executes this statement.
                                    dim, id_tok.value)
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Calls `self._emit`.
                     self._emit("DECLARE", GAL_TYPE_MAP.get(dtype.type, dtype.type),
+                               # AUTO: Executes this statement.
                                None, id_tok.value)
+                # AUTO: Calls `self._var_value`.
                 self._var_value(id_tok.value)
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
+                # AUTO: Calls `self._global_declaration`.
                 self._global_declaration()
+                # AUTO: Returns this result to the caller.
                 return
 
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "fertile":
+                # AUTO: Calls `self._const_dec`.
                 self._const_dec()
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
+                # AUTO: Calls `self._global_declaration`.
                 self._global_declaration()
+                # AUTO: Returns this result to the caller.
                 return
 
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Returns this result to the caller.
                 return
 
 
+    # AUTO: Defines function `_declaration`.
     def _declaration(self):
+        # AUTO: Repeats while this condition is true.
         while True:
+            # AUTO: Sets `tok`.
             tok = self._peek()
+            # AUTO: Checks this condition.
             if self._is_data_type(tok) or tok.type == "bundle":
+                # AUTO: Calls `self._var_dec`.
                 self._var_dec()
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "fertile":
+                # AUTO: Calls `self._const_dec`.
                 self._const_dec()
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Stops the nearest loop.
                 break
 
+    # AUTO: Defines function `_var_dec`.
     def _var_dec(self):
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if tok.type == "bundle":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `id_tok`.
             id_tok = self._expect("id")
+            # AUTO: Calls `self._bundle_mem_dec`.
             self._bundle_mem_dec()
+            # AUTO: Returns this result to the caller.
             return
 
+        # AUTO: Sets `dtype`.
         dtype = self._advance()
+        # AUTO: Sets `id_tok`.
         id_tok = self._expect("id")
+        # AUTO: Sets `arr_dims`.
         arr_dims = self._array_dec()
+        # AUTO: Checks this condition.
         if arr_dims:
+            # AUTO: Starts a loop over these values.
             for dim in arr_dims:
+                # AUTO: Calls `self._emit`.
                 self._emit("ARRAY_DECLARE", GAL_TYPE_MAP.get(dtype.type, dtype.type),
+                           # AUTO: Executes this statement.
                            dim, id_tok.value)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Calls `self._emit`.
             self._emit("DECLARE", GAL_TYPE_MAP.get(dtype.type, dtype.type), None, id_tok.value)
+        # AUTO: Calls `self._var_value`.
         self._var_value(id_tok.value)
 
+    # AUTO: Defines function `_const_dec`.
     def _const_dec(self):
+        # AUTO: Calls `self._expect`.
         self._expect("fertile")
+        # AUTO: Sets `dtype`.
         dtype = self._advance()
+        # AUTO: Sets `id_tok`.
         id_tok = self._expect("id")
+        # AUTO: Sets `self._expect("`.
         self._expect("=")
+        # AUTO: Sets `val`.
         val = self._init_val()
+        # AUTO: Calls `self._emit`.
         self._emit("CONST", GAL_TYPE_MAP.get(dtype.type, dtype.type), val, id_tok.value)
+        # AUTO: Calls `self._const_next`.
         self._const_next(dtype)
 
+    # AUTO: Defines function `_const_next`.
     def _const_next(self, dtype_tok: _Tok):
+        # AUTO: Repeats while this condition is true.
         while self._match(","):
+            # AUTO: Sets `id_tok`.
             id_tok = self._expect("id")
+            # AUTO: Sets `self._expect("`.
             self._expect("=")
+            # AUTO: Sets `val`.
             val = self._init_val()
+            # AUTO: Calls `self._emit`.
             self._emit("CONST", GAL_TYPE_MAP.get(dtype_tok.type, dtype_tok.type), val, id_tok.value)
 
+    # AUTO: Defines function `_var_value`.
     def _var_value(self, var_name: str):
+        # AUTO: Checks this condition.
         if self._peek().type == "=":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `val`.
             val = self._init_val()
+            # AUTO: Sets `self._emit("`.
             self._emit("=", val, None, var_name)
+            # AUTO: Calls `self._var_value_next`.
             self._var_value_next()
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Calls `self._var_value_next`.
             self._var_value_next()
 
+    # AUTO: Defines function `_var_value_next`.
     def _var_value_next(self):
+        # AUTO: Checks this condition.
         if self._match(","):
+            # AUTO: Sets `id_tok`.
             id_tok = self._expect("id")
+            # AUTO: Sets `arr_dims`.
             arr_dims = self._array_dec()
+            # AUTO: Checks this condition.
             if arr_dims:
+                # AUTO: Starts a loop over these values.
                 for dim in arr_dims:
+                    # AUTO: Calls `self._emit`.
                     self._emit("ARRAY_DECLARE", "int", dim, id_tok.value)
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Calls `self._emit`.
                 self._emit("DECLARE", "int", None, id_tok.value)
+            # AUTO: Calls `self._var_value`.
             self._var_value(id_tok.value)
 
+    # AUTO: Defines function `_init_val`.
     def _init_val(self) -> str:
+        # AUTO: Checks this condition.
         if self._peek().type == "{":
+            # AUTO: Returns this result to the caller.
             return self._array_init()
+        # AUTO: Returns this result to the caller.
         return self._expression()
 
+    # AUTO: Defines function `_array_init`.
     def _array_init(self) -> str:
+        # AUTO: Calls `self._expect`.
         self._expect("{")
+        # AUTO: Sets `tmp`.
         tmp = self._new_temp()
+        # AUTO: Sets `idx`.
         idx = 0
+        # AUTO: Checks this condition.
         if self._peek().type != "}":
+            # AUTO: Sets `val`.
             val = self._init_val_item()
+            # AUTO: Calls `self._emit`.
             self._emit("ARRAY_STORE", val, str(idx), tmp)
+            # AUTO: Adds into `idx`.
             idx += 1
+            # AUTO: Repeats while this condition is true.
             while self._match(","):
+                # AUTO: Sets `val`.
                 val = self._init_val_item()
+                # AUTO: Calls `self._emit`.
                 self._emit("ARRAY_STORE", val, str(idx), tmp)
+                # AUTO: Adds into `idx`.
                 idx += 1
+        # AUTO: Calls `self._expect`.
         self._expect("}")
+        # AUTO: Returns this result to the caller.
         return tmp
 
+    # AUTO: Defines function `_init_val_item`.
     def _init_val_item(self) -> str:
+        # AUTO: Checks this condition.
         if self._peek().type == "{":
+            # AUTO: Returns this result to the caller.
             return self._array_init()
+        # AUTO: Returns this result to the caller.
         return self._expression()
 
 
+    # AUTO: Defines function `_array_dec`.
     def _array_dec(self) -> List[str]:
+        # AUTO: Sets `dims: List[str]`.
         dims: List[str] = []
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "[":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Checks this condition.
             if self._peek().type == "intlit":
+                # AUTO: Appends a value to a list.
                 dims.append(self._advance().value)
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Appends a value to a list.
                 dims.append("0")
+            # AUTO: Calls `self._expect`.
             self._expect("]")
+        # AUTO: Returns this result to the caller.
         return dims
 
+    # AUTO: Defines function `_bundle_members`.
     def _bundle_members(self):
+        # AUTO: Repeats while this condition is true.
         while self._is_data_type(self._peek()):
+            # AUTO: Sets `dtype`.
             dtype = self._advance()
+            # AUTO: Sets `id_tok`.
             id_tok = self._expect("id")
+            # AUTO: Calls `self._expect`.
             self._expect(";")
 
+    # AUTO: Defines function `_bundle_mem_dec`.
     def _bundle_mem_dec(self):
+        # AUTO: Sets `id_tok`.
         id_tok = self._expect("id")
+        # AUTO: Sets `arr_dims`.
         arr_dims = self._array_dec()
+        # AUTO: Checks this condition.
         if arr_dims:
+            # AUTO: Starts a loop over these values.
             for dim in arr_dims:
+                # AUTO: Calls `self._emit`.
                 self._emit("ARRAY_DECLARE", "bundle", dim, id_tok.value)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Calls `self._emit`.
             self._emit("DECLARE", "bundle", None, id_tok.value)
 
 
+    # AUTO: Defines function `_function_definition`.
     def _function_definition(self):
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "pollinate":
+            # AUTO: Calls `self._advance`.
             self._advance()
 
+            # AUTO: Checks this condition.
             if self._peek().type == "empty":
+                # AUTO: Sets `ret_type`.
                 ret_type = self._advance().type
+            # AUTO: Checks the next alternate condition.
             elif self._is_data_type(self._peek()):
+                # AUTO: Sets `ret_type`.
                 ret_type = self._advance().type
+            # AUTO: Checks the next alternate condition.
             elif self._peek().type == "id":
+                # AUTO: Sets `ret_type`.
                 ret_type = self._advance().value
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Sets `ret_type`.
                 ret_type = "void"
 
+            # AUTO: Sets `func_name`.
             func_name = self._expect("id")
+            # AUTO: Calls `self._expect`.
             self._expect("(")
 
+            # AUTO: Sets `params`.
             params = self._parameters()
 
+            # AUTO: Calls `self._expect`.
             self._expect(")")
+            # AUTO: Calls `self._expect`.
             self._expect("{")
 
+            # AUTO: Calls `self._emit`.
             self._emit("FUNC", func_name.value)
+            # AUTO: Starts a loop over these values.
             for ptype, pname, *rest in params:
+                # AUTO: Sets `is_array`.
                 is_array = rest[0] if rest else False
+                # AUTO: Checks this condition.
                 if is_array:
+                    # AUTO: Calls `self._emit`.
                     self._emit("ARRAY_DECLARE", GAL_TYPE_MAP.get(ptype, ptype), "param", pname)
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Calls `self._emit`.
                     self._emit("DECLARE", GAL_TYPE_MAP.get(ptype, ptype), None, pname)
 
+            # AUTO: Calls `self._declaration`.
             self._declaration()
+            # AUTO: Calls `self._statement`.
             self._statement()
 
+            # AUTO: Calls `self._expect`.
             self._expect("reclaim")
+            # AUTO: Checks this condition.
             if self._peek().type == ";":
+                # AUTO: Calls `self._emit`.
                 self._emit("RETURN")
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Sets `val`.
                 val = self._expression()
+                # AUTO: Calls `self._emit`.
                 self._emit("RETURN", val)
+            # AUTO: Calls `self._expect`.
             self._expect(";")
 
+            # AUTO: Calls `self._expect`.
             self._expect("}")
+            # AUTO: Calls `self._emit`.
             self._emit("ENDFUNC")
 
+    # AUTO: Defines function `_parameters`.
     def _parameters(self):
+        # AUTO: Sets `params`.
         params = []
+        # AUTO: Checks this condition.
         if self._is_data_type(self._peek()) or self._peek().type == "id":
+            # AUTO: Sets `p`.
             p = self._param()
+            # AUTO: Appends a value to a list.
             params.append(p)
+            # AUTO: Repeats while this condition is true.
             while self._match(","):
+                # AUTO: Sets `p`.
                 p = self._param()
+                # AUTO: Appends a value to a list.
                 params.append(p)
+        # AUTO: Returns this result to the caller.
         return params
 
+    # AUTO: Defines function `_param`.
     def _param(self) -> Tuple[str, str]:
+        # AUTO: Sets `dtype`.
         dtype = self._advance()
+        # AUTO: Sets `id_tok`.
         id_tok = self._expect("id")
+        # AUTO: Executes this statement.
         type_name = dtype.value if dtype.type == "id" else dtype.type
+        # AUTO: Sets `is_array`.
         is_array = False
+        # AUTO: Checks this condition.
         if self._peek().type == "[":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Calls `self._expect`.
             self._expect("]")
+            # AUTO: Sets `is_array`.
             is_array = True
+        # AUTO: Returns this result to the caller.
         return (type_name, id_tok.value, is_array)
 
 
+    # AUTO: Defines function `_statement`.
     def _statement(self, allow_reclaim: bool = False):
+        # AUTO: Sets `stopping_tokens`.
         stopping_tokens = {"}", "EOF", "variety", "soil", "prune"}
+        # AUTO: Repeats while this condition is true.
         while self._peek().type not in stopping_tokens:
+            # AUTO: Sets `tok`.
             tok = self._peek()
+            # AUTO: Checks this condition.
             if tok.type == "reclaim":
+                # AUTO: Checks this condition.
                 if not allow_reclaim:
+                    # AUTO: Returns this result to the caller.
                     return
+                # AUTO: Calls `self._return_stmt`.
                 self._return_stmt()
+                # AUTO: Skips to the next loop iteration.
                 continue
+            # AUTO: Checks this condition.
             if self._is_data_type(tok) or tok.type == "bundle" or tok.type == "fertile":
+                # AUTO: Checks this condition.
                 if tok.type == "fertile":
+                    # AUTO: Calls `self._const_dec`.
                     self._const_dec()
+                    # AUTO: Calls `self._expect`.
                     self._expect(";")
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Calls `self._var_dec`.
                     self._var_dec()
+                    # AUTO: Calls `self._expect`.
                     self._expect(";")
+                # AUTO: Skips to the next loop iteration.
                 continue
+            # AUTO: Calls `self._simple_stmt`.
             self._simple_stmt()
 
+    # AUTO: Defines function `_return_stmt`.
     def _return_stmt(self):
+        # AUTO: Calls `self._expect`.
         self._expect("reclaim")
+        # AUTO: Checks this condition.
         if self._peek().type == ";":
+            # AUTO: Calls `self._emit`.
             self._emit("RETURN")
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Calls `self._emit`.
             self._emit("RETURN", self._expression())
+        # AUTO: Calls `self._expect`.
         self._expect(";")
 
+    # AUTO: Defines function `_simple_stmt`.
     def _simple_stmt(self):
+        # AUTO: Sets `tok`.
         tok = self._peek()
 
+        # AUTO: Checks this condition.
         if tok.type == "id":
+            # AUTO: Calls `self._id_stmt`.
             self._id_stmt()
+        # AUTO: Checks the next alternate condition.
         elif tok.type in ("water", "plant"):
+            # AUTO: Calls `self._io_stmt`.
             self._io_stmt()
+        # AUTO: Checks the next alternate condition.
         elif tok.type == "spring":
+            # AUTO: Calls `self._conditional_stmt`.
             self._conditional_stmt()
+        # AUTO: Checks the next alternate condition.
         elif tok.type in ("grow", "cultivate", "tend"):
+            # AUTO: Calls `self._loop_stmt`.
             self._loop_stmt()
+        # AUTO: Checks the next alternate condition.
         elif tok.type == "harvest":
+            # AUTO: Calls `self._switch_stmt`.
             self._switch_stmt()
+        # AUTO: Checks the next alternate condition.
         elif tok.type in ("prune", "skip"):
+            # AUTO: Calls `self._control_stmt`.
             self._control_stmt()
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Appends a value to a list.
             self.errors.append(f"ICG Line {tok.line}: unexpected token '{tok.type}'")
+            # AUTO: Calls `self._advance`.
             self._advance()
 
 
+    # AUTO: Defines function `_id_stmt`.
     def _id_stmt(self):
+        # AUTO: Sets `id_tok`.
         id_tok = self._advance()
+        # AUTO: Sets `tok`.
         tok = self._peek()
 
+        # AUTO: Checks this condition.
         if tok.type == "(":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `args`.
             args = self._arguments()
+            # AUTO: Calls `self._expect`.
             self._expect(")")
+            # AUTO: Calls `self._expect`.
             self._expect(";")
+            # AUTO: Starts a loop over these values.
             for a in args:
+                # AUTO: Calls `self._emit`.
                 self._emit("PARAM", a)
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit("CALL", id_tok.value, str(len(args)), tmp)
+            # AUTO: Returns this result to the caller.
             return
 
+        # AUTO: Checks this condition.
         if tok.type in ("++", "--"):
+            # AUTO: Sets `op_tok`.
             op_tok = self._advance()
+            # AUTO: Calls `self._expect`.
             self._expect(";")
+            # AUTO: Calls `self._emit`.
             self._emit("INC" if op_tok.type == "++" else "DEC", id_tok.value)
+            # AUTO: Returns this result to the caller.
             return
 
+        # AUTO: Sets `lhs`.
         lhs = id_tok.value
+        # AUTO: Sets `lhs`.
         lhs = self._resolve_lhs(lhs)
 
+        # AUTO: Checks this condition.
         if self._peek().type in ASSIGN_OPS:
+            # AUTO: Sets `op_tok`.
             op_tok = self._advance()
+            # AUTO: Sets `rhs`.
             rhs = self._expression()
+            # AUTO: Calls `self._expect`.
             self._expect(";")
 
+            # AUTO: Checks this condition.
             if op_tok.type == "=":
+                # AUTO: Sets `self._emit("`.
                 self._emit("=", rhs, None, lhs)
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Sets `base_op`.
                 base_op = op_tok.type[0]
+                # AUTO: Sets `tmp`.
                 tmp = self._new_temp()
+                # AUTO: Calls `self._emit`.
                 self._emit(base_op, lhs, rhs, tmp)
+                # AUTO: Sets `self._emit("`.
                 self._emit("=", tmp, None, lhs)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Appends a value to a list.
             self.errors.append(f"ICG Line {tok.line}: unexpected token after id '{id_tok.value}'")
+            # AUTO: Repeats while this condition is true.
             while self._peek().type not in (";", "}", "EOF"):
+                # AUTO: Calls `self._advance`.
                 self._advance()
+            # AUTO: Calls `self._match`.
             self._match(";")
 
+    # AUTO: Defines function `_resolve_lhs`.
     def _resolve_lhs(self, base: str) -> str:
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if tok.type == "[":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `idx`.
             idx = self._expression()
+            # AUTO: Calls `self._expect`.
             self._expect("]")
+            # AUTO: Repeats while this condition is true.
             while self._peek().type == "[":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `idx2`.
                 idx2 = self._expression()
+                # AUTO: Calls `self._expect`.
                 self._expect("]")
+                # AUTO: Sets `tmp`.
                 tmp = self._new_temp()
+                # AUTO: Calls `self._emit`.
                 self._emit("*", idx, idx2, tmp)
+                # AUTO: Sets `idx`.
                 idx = tmp
+            # AUTO: Returns this result to the caller.
             return f"{base}[{idx}]"
+        # AUTO: Checks the next alternate condition.
         elif tok.type == ".":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `member`.
             member = self._expect("id")
+            # AUTO: Sets `chain`.
             chain = f"{base}.{member.value}"
+            # AUTO: Repeats while this condition is true.
             while self._peek().type == ".":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `m2`.
                 m2 = self._expect("id")
+                # AUTO: Sets `chain`.
                 chain = f"{chain}.{m2.value}"
+            # AUTO: Returns this result to the caller.
             return chain
+        # AUTO: Returns this result to the caller.
         return base
 
 
+    # AUTO: Defines function `_io_stmt`.
     def _io_stmt(self):
+        # AUTO: Sets `io_tok`.
         io_tok = self._advance()
+        # AUTO: Calls `self._expect`.
         self._expect("(")
+        # AUTO: Sets `args`.
         args = self._arguments()
+        # AUTO: Calls `self._expect`.
         self._expect(")")
+        # AUTO: Calls `self._expect`.
         self._expect(";")
 
+        # AUTO: Checks this condition.
         if io_tok.type == "plant":
+            # AUTO: Starts a loop over these values.
             for a in args:
+                # AUTO: Calls `self._emit`.
                 self._emit("PRINT", a)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Starts a loop over these values.
             for a in args:
+                # AUTO: Calls `self._emit`.
                 self._emit("READ", None, None, a)
 
 
+    # AUTO: Defines function `_conditional_stmt`.
     def _conditional_stmt(self):
+        # AUTO: Calls `self._expect`.
         self._expect("spring")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
+        # AUTO: Sets `cond`.
         cond = self._expression()
+        # AUTO: Calls `self._expect`.
         self._expect(")")
 
+        # AUTO: Sets `false_label`.
         false_label = self._new_label()
+        # AUTO: Sets `end_label`.
         end_label = self._new_label()
 
+        # AUTO: Calls `self._emit`.
         self._emit("IFFALSE", cond, None, false_label)
 
+        # AUTO: Calls `self._expect`.
         self._expect("{")
+        # AUTO: Sets `self._statement(allow_reclaim`.
         self._statement(allow_reclaim=True)
+        # AUTO: Calls `self._expect`.
         self._expect("}")
 
+        # AUTO: Calls `self._emit`.
         self._emit("GOTO", None, None, end_label)
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, false_label)
 
+        # AUTO: Calls `self._elseif_chain`.
         self._elseif_chain(end_label)
 
+        # AUTO: Checks this condition.
         if self._peek().type == "wither":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Calls `self._expect`.
             self._expect("{")
+            # AUTO: Sets `self._statement(allow_reclaim`.
             self._statement(allow_reclaim=True)
+            # AUTO: Calls `self._expect`.
             self._expect("}")
 
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, end_label)
 
+    # AUTO: Defines function `_elseif_chain`.
     def _elseif_chain(self, end_label: str):
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "bud":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Calls `self._expect`.
             self._expect("(")
+            # AUTO: Sets `cond`.
             cond = self._expression()
+            # AUTO: Calls `self._expect`.
             self._expect(")")
 
+            # AUTO: Sets `next_label`.
             next_label = self._new_label()
+            # AUTO: Calls `self._emit`.
             self._emit("IFFALSE", cond, None, next_label)
 
+            # AUTO: Calls `self._expect`.
             self._expect("{")
+            # AUTO: Sets `self._statement(allow_reclaim`.
             self._statement(allow_reclaim=True)
+            # AUTO: Calls `self._expect`.
             self._expect("}")
 
+            # AUTO: Calls `self._emit`.
             self._emit("GOTO", None, None, end_label)
+            # AUTO: Calls `self._emit`.
             self._emit("LABEL", None, None, next_label)
 
 
+    # AUTO: Defines function `_loop_stmt`.
     def _loop_stmt(self):
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if tok.type == "grow":
+            # AUTO: Calls `self._while_loop`.
             self._while_loop()
+        # AUTO: Checks the next alternate condition.
         elif tok.type == "cultivate":
+            # AUTO: Calls `self._for_loop`.
             self._for_loop()
+        # AUTO: Checks the next alternate condition.
         elif tok.type == "tend":
+            # AUTO: Calls `self._do_while_loop`.
             self._do_while_loop()
 
+    # AUTO: Defines function `_while_loop`.
     def _while_loop(self):
+        # AUTO: Calls `self._expect`.
         self._expect("grow")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
 
+        # AUTO: Sets `start_label`.
         start_label = self._new_label()
+        # AUTO: Sets `end_label`.
         end_label = self._new_label()
 
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, start_label)
+        # AUTO: Sets `cond`.
         cond = self._expression()
+        # AUTO: Calls `self._expect`.
         self._expect(")")
 
+        # AUTO: Calls `self._emit`.
         self._emit("IFFALSE", cond, None, end_label)
 
+        # AUTO: Calls `self._expect`.
         self._expect("{")
+        # AUTO: Sets `self._statement(allow_reclaim`.
         self._statement(allow_reclaim=True)
+        # AUTO: Calls `self._expect`.
         self._expect("}")
 
+        # AUTO: Calls `self._emit`.
         self._emit("GOTO", None, None, start_label)
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, end_label)
 
+    # AUTO: Defines function `_for_loop`.
     def _for_loop(self):
+        # AUTO: Calls `self._expect`.
         self._expect("cultivate")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
 
+        # AUTO: Calls `self._for_init`.
         self._for_init()
+        # AUTO: Calls `self._expect`.
         self._expect(";")
 
+        # AUTO: Sets `start_label`.
         start_label = self._new_label()
+        # AUTO: Sets `end_label`.
         end_label = self._new_label()
+        # AUTO: Sets `update_label`.
         update_label = self._new_label()
 
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, start_label)
 
+        # AUTO: Sets `cond`.
         cond = self._expression()
+        # AUTO: Calls `self._emit`.
         self._emit("IFFALSE", cond, None, end_label)
 
+        # AUTO: Calls `self._expect`.
         self._expect(";")
 
+        # AUTO: Sets `update_instrs: List[TACInstruction]`.
         update_instrs: List[TACInstruction] = []
+        # AUTO: Sets `saved_code`.
         saved_code = self.code
+        # AUTO: Sets `self.code`.
         self.code = update_instrs
+        # AUTO: Calls `self._for_update`.
         self._for_update()
+        # AUTO: Sets `self.code`.
         self.code = saved_code
 
+        # AUTO: Calls `self._expect`.
         self._expect(")")
+        # AUTO: Calls `self._expect`.
         self._expect("{")
+        # AUTO: Sets `self._statement(allow_reclaim`.
         self._statement(allow_reclaim=True)
+        # AUTO: Calls `self._expect`.
         self._expect("}")
 
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, update_label)
+        # AUTO: Calls `self.code.extend`.
         self.code.extend(update_instrs)
+        # AUTO: Calls `self._emit`.
         self._emit("GOTO", None, None, start_label)
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, end_label)
 
+    # AUTO: Defines function `_for_init`.
     def _for_init(self):
+        # AUTO: Sets `tok`.
         tok = self._peek()
+        # AUTO: Checks this condition.
         if self._is_data_type(tok):
+            # AUTO: Calls `self._var_dec`.
             self._var_dec()
+        # AUTO: Checks the next alternate condition.
         elif tok.type == "id":
+            # AUTO: Sets `id_tok`.
             id_tok = self._advance()
+            # AUTO: Sets `lhs`.
             lhs = self._resolve_lhs(id_tok.value)
+            # AUTO: Checks this condition.
             if self._peek().type in ASSIGN_OPS:
+                # AUTO: Sets `op_tok`.
                 op_tok = self._advance()
+                # AUTO: Sets `rhs`.
                 rhs = self._expression()
+                # AUTO: Checks this condition.
                 if op_tok.type == "=":
+                    # AUTO: Sets `self._emit("`.
                     self._emit("=", rhs, None, lhs)
+                # AUTO: Runs when previous condition did not pass.
                 else:
+                    # AUTO: Sets `base_op`.
                     base_op = op_tok.type[0]
+                    # AUTO: Sets `tmp`.
                     tmp = self._new_temp()
+                    # AUTO: Calls `self._emit`.
                     self._emit(base_op, lhs, rhs, tmp)
+                    # AUTO: Sets `self._emit("`.
                     self._emit("=", tmp, None, lhs)
 
+    # AUTO: Defines function `_for_update`.
     def _for_update(self):
+        # AUTO: Checks this condition.
         if self._peek().type == "id":
+            # AUTO: Sets `id_tok`.
             id_tok = self._advance()
+            # AUTO: Sets `tok`.
             tok = self._peek()
+            # AUTO: Checks this condition.
             if tok.type in ("++", "--"):
+                # AUTO: Sets `op`.
                 op = self._advance()
+                # AUTO: Calls `self._emit`.
                 self._emit("INC" if op.type == "++" else "DEC", id_tok.value)
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Sets `lhs`.
                 lhs = self._resolve_lhs(id_tok.value)
+                # AUTO: Checks this condition.
                 if self._peek().type in ASSIGN_OPS:
+                    # AUTO: Sets `op_tok`.
                     op_tok = self._advance()
+                    # AUTO: Sets `rhs`.
                     rhs = self._expression()
+                    # AUTO: Checks this condition.
                     if op_tok.type == "=":
+                        # AUTO: Sets `self._emit("`.
                         self._emit("=", rhs, None, lhs)
+                    # AUTO: Runs when previous condition did not pass.
                     else:
+                        # AUTO: Sets `base_op`.
                         base_op = op_tok.type[0]
+                        # AUTO: Sets `tmp`.
                         tmp = self._new_temp()
+                        # AUTO: Calls `self._emit`.
                         self._emit(base_op, lhs, rhs, tmp)
+                        # AUTO: Sets `self._emit("`.
                         self._emit("=", tmp, None, lhs)
 
+    # AUTO: Defines function `_do_while_loop`.
     def _do_while_loop(self):
+        # AUTO: Calls `self._expect`.
         self._expect("tend")
+        # AUTO: Calls `self._expect`.
         self._expect("{")
 
+        # AUTO: Sets `start_label`.
         start_label = self._new_label()
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, start_label)
 
+        # AUTO: Sets `self._statement(allow_reclaim`.
         self._statement(allow_reclaim=True)
+        # AUTO: Calls `self._expect`.
         self._expect("}")
 
+        # AUTO: Calls `self._expect`.
         self._expect("grow")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
+        # AUTO: Sets `cond`.
         cond = self._expression()
+        # AUTO: Calls `self._expect`.
         self._expect(")")
+        # AUTO: Calls `self._expect`.
         self._expect(";")
 
+        # AUTO: Calls `self._emit`.
         self._emit("IF", cond, None, start_label)
 
 
+    # AUTO: Defines function `_switch_stmt`.
     def _switch_stmt(self):
+        # AUTO: Calls `self._expect`.
         self._expect("harvest")
+        # AUTO: Calls `self._expect`.
         self._expect("(")
+        # AUTO: Sets `expr`.
         expr = self._expression()
+        # AUTO: Calls `self._expect`.
         self._expect(")")
+        # AUTO: Calls `self._expect`.
         self._expect("{")
 
+        # AUTO: Sets `end_label`.
         end_label = self._new_label()
+        # AUTO: Calls `self._case_list`.
         self._case_list(expr, end_label)
+        # AUTO: Calls `self._default_opt`.
         self._default_opt(end_label)
 
+        # AUTO: Calls `self._expect`.
         self._expect("}")
+        # AUTO: Calls `self._emit`.
         self._emit("LABEL", None, None, end_label)
 
+    # AUTO: Defines function `_case_list`.
     def _case_list(self, switch_expr: str, end_label: str):
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "variety":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `case_val`.
             case_val = self._expression()
+            # AUTO: Calls `self._expect`.
             self._expect(":")
 
+            # AUTO: Sets `next_label`.
             next_label = self._new_label()
+            # AUTO: Sets `body_label`.
             body_label = self._new_label()
+            # AUTO: Sets `cmp_tmp`.
             cmp_tmp = self._new_temp()
 
+            # AUTO: Calls `self._emit`.
             self._emit("==", switch_expr, case_val, cmp_tmp)
+            # AUTO: Calls `self._emit`.
             self._emit("IFFALSE", cmp_tmp, None, next_label)
+            # AUTO: Calls `self._emit`.
             self._emit("LABEL", None, None, body_label)
 
+            # AUTO: Calls `self._declaration`.
             self._declaration()
+            # AUTO: Calls `self._case_statements`.
             self._case_statements()
 
+            # AUTO: Checks this condition.
             if self._peek().type == "prune":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
 
+            # AUTO: Calls `self._emit`.
             self._emit("GOTO", None, None, end_label)
+            # AUTO: Calls `self._emit`.
             self._emit("LABEL", None, None, next_label)
 
+    # AUTO: Defines function `_case_statements`.
     def _case_statements(self):
+        # AUTO: Repeats while this condition is true.
         while self._peek().type not in ("variety", "soil", "}", "prune", "EOF"):
+            # AUTO: Sets `tok`.
             tok = self._peek()
+            # AUTO: Checks this condition.
             if tok.type == "id":
+                # AUTO: Calls `self._id_stmt`.
                 self._id_stmt()
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "water":
+                # AUTO: Calls `self._io_stmt`.
                 self._io_stmt()
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "plant":
+                # AUTO: Calls `self._io_stmt`.
                 self._io_stmt()
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "skip":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Calls `self._expect`.
                 self._expect(";")
+            # AUTO: Checks the next alternate condition.
             elif tok.type == "reclaim":
+                # AUTO: Calls `self._return_stmt`.
                 self._return_stmt()
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Stops the nearest loop.
                 break
 
+    # AUTO: Defines function `_default_opt`.
     def _default_opt(self, end_label: str):
+        # AUTO: Checks this condition.
         if self._peek().type == "soil":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Calls `self._expect`.
             self._expect(":")
+            # AUTO: Calls `self._declaration`.
             self._declaration()
+            # AUTO: Calls `self._case_statements`.
             self._case_statements()
 
 
+    # AUTO: Defines function `_control_stmt`.
     def _control_stmt(self):
+        # AUTO: Sets `tok`.
         tok = self._advance()
+        # AUTO: Calls `self._expect`.
         self._expect(";")
+        # AUTO: Checks this condition.
         if tok.type == "prune":
+            # AUTO: Calls `self._emit`.
             self._emit("GOTO", None, None, "BREAK")
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Calls `self._emit`.
             self._emit("GOTO", None, None, "CONTINUE")
 
 
+    # AUTO: Defines function `_expression`.
     def _expression(self) -> str:
+        # AUTO: Sets `left`.
         left = self._logic_or()
+        # AUTO: Checks this condition.
         if self._peek().type not in ASSIGN_OPS:
+            # AUTO: Returns this result to the caller.
             return left
 
+        # AUTO: Sets `op_tok`.
         op_tok = self._advance()
+        # AUTO: Sets `right`.
         right = self._expression()
+        # AUTO: Checks this condition.
         if op_tok.type == "=":
+            # AUTO: Sets `self._emit("`.
             self._emit("=", right, None, left)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit(op_tok.type[0], left, right, tmp)
+            # AUTO: Sets `self._emit("`.
             self._emit("=", tmp, None, left)
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_logic_or`.
     def _logic_or(self) -> str:
+        # AUTO: Sets `left`.
         left = self._logic_and()
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "||":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `right`.
             right = self._logic_and()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit("||", left, right, tmp)
+            # AUTO: Sets `left`.
             left = tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_logic_and`.
     def _logic_and(self) -> str:
+        # AUTO: Sets `left`.
         left = self._relational()
+        # AUTO: Repeats while this condition is true.
         while self._peek().type == "&&":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `right`.
             right = self._relational()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit("&&", left, right, tmp)
+            # AUTO: Sets `left`.
             left = tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_relational`.
     def _relational(self) -> str:
+        # AUTO: Sets `left`.
         left = self._arithmetic()
+        # AUTO: Checks this condition.
         if self._peek().type in (">", "<", ">=", "<=", "==", "!="):
+            # AUTO: Sets `op`.
             op = self._advance().type
+            # AUTO: Sets `right`.
             right = self._arithmetic()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit(op, left, right, tmp)
+            # AUTO: Returns this result to the caller.
             return tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_arithmetic`.
     def _arithmetic(self) -> str:
+        # AUTO: Sets `left`.
         left = self._term()
+        # AUTO: Repeats while this condition is true.
         while self._peek().type in ("+", "-"):
+            # AUTO: Sets `op`.
             op = self._advance().type
+            # AUTO: Sets `right`.
             right = self._term()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit(op, left, right, tmp)
+            # AUTO: Sets `left`.
             left = tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_term`.
     def _term(self) -> str:
+        # AUTO: Sets `left`.
         left = self._power()
+        # AUTO: Repeats while this condition is true.
         while self._peek().type in ("*", "/", "%"):
+            # AUTO: Sets `op`.
             op = self._advance().type
+            # AUTO: Sets `right`.
             right = self._power()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit(op, left, right, tmp)
+            # AUTO: Sets `left`.
             left = tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_power`.
     def _power(self) -> str:
+        # AUTO: Sets `left`.
         left = self._factor()
+        # AUTO: Checks this condition.
         if self._peek().type == "**":
+            # AUTO: Sets `op`.
             op = self._advance().type
+            # AUTO: Sets `right`.
             right = self._power()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Calls `self._emit`.
             self._emit(op, left, right, tmp)
+            # AUTO: Returns this result to the caller.
             return tmp
+        # AUTO: Returns this result to the caller.
         return left
 
+    # AUTO: Defines function `_factor`.
     def _factor(self) -> str:
+        # AUTO: Sets `tok`.
         tok = self._peek()
 
+        # AUTO: Checks this condition.
         if tok.type == "(":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Sets `val`.
             val = self._expression()
+            # AUTO: Calls `self._expect`.
             self._expect(")")
+            # AUTO: Returns this result to the caller.
             return val
 
+        # AUTO: Checks this condition.
         if tok.type in ("~", "!"):
+            # AUTO: Sets `op`.
             op = self._advance()
+            # AUTO: Sets `inner`.
             inner = self._factor()
+            # AUTO: Sets `tmp`.
             tmp = self._new_temp()
+            # AUTO: Checks this condition.
             if op.type == "~":
+                # AUTO: Calls `self._emit`.
                 self._emit("UNARY_MINUS", inner, None, tmp)
+            # AUTO: Runs when previous condition did not pass.
             else:
+                # AUTO: Calls `self._emit`.
                 self._emit("NOT", inner, None, tmp)
+            # AUTO: Returns this result to the caller.
             return tmp
 
+        # AUTO: Checks this condition.
         if tok.type == "id":
+            # AUTO: Sets `id_tok`.
             id_tok = self._advance()
+            # AUTO: Sets `nxt`.
             nxt = self._peek()
 
+            # AUTO: Checks this condition.
             if nxt.type == "(":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `args`.
                 args = self._arguments()
+                # AUTO: Calls `self._expect`.
                 self._expect(")")
+                # AUTO: Starts a loop over these values.
                 for a in args:
+                    # AUTO: Calls `self._emit`.
                     self._emit("PARAM", a)
+                # AUTO: Sets `tmp`.
                 tmp = self._new_temp()
+                # AUTO: Calls `self._emit`.
                 self._emit("CALL", id_tok.value, str(len(args)), tmp)
+                # AUTO: Returns this result to the caller.
                 return tmp
 
+            # AUTO: Checks this condition.
             if nxt.type == "[":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `idx`.
                 idx = self._expression()
+                # AUTO: Calls `self._expect`.
                 self._expect("]")
+                # AUTO: Repeats while this condition is true.
                 while self._peek().type == "[":
+                    # AUTO: Calls `self._advance`.
                     self._advance()
+                    # AUTO: Sets `idx2`.
                     idx2 = self._expression()
+                    # AUTO: Calls `self._expect`.
                     self._expect("]")
+                    # AUTO: Sets `tmp`.
                     tmp = self._new_temp()
+                    # AUTO: Calls `self._emit`.
                     self._emit("*", idx, idx2, tmp)
+                    # AUTO: Sets `idx`.
                     idx = tmp
+                # AUTO: Sets `location`.
                 location = f"{id_tok.value}[{idx}]"
+                # AUTO: Checks this condition.
                 if self._peek().type in ASSIGN_OPS:
+                    # AUTO: Returns this result to the caller.
                     return location
+                # AUTO: Sets `tmp`.
                 tmp = self._new_temp()
+                # AUTO: Calls `self._emit`.
                 self._emit("ARRAY_LOAD", id_tok.value, idx, tmp)
+                # AUTO: Returns this result to the caller.
                 return tmp
 
+            # AUTO: Checks this condition.
             if nxt.type == ".":
+                # AUTO: Calls `self._advance`.
                 self._advance()
+                # AUTO: Sets `member`.
                 member = self._expect("id")
+                # AUTO: Sets `chain`.
                 chain = member.value
+                # AUTO: Repeats while this condition is true.
                 while self._peek().type == ".":
+                    # AUTO: Calls `self._advance`.
                     self._advance()
+                    # AUTO: Sets `m2`.
                     m2 = self._expect("id")
+                    # AUTO: Sets `chain`.
                     chain = f"{chain}.{m2.value}"
+                # AUTO: Sets `location`.
                 location = f"{id_tok.value}.{chain}"
+                # AUTO: Checks this condition.
                 if self._peek().type in ASSIGN_OPS:
+                    # AUTO: Returns this result to the caller.
                     return location
+                # AUTO: Sets `tmp`.
                 tmp = self._new_temp()
+                # AUTO: Calls `self._emit`.
                 self._emit("STRUCT_LOAD", id_tok.value, chain, tmp)
+                # AUTO: Returns this result to the caller.
                 return tmp
 
+            # AUTO: Returns this result to the caller.
             return id_tok.value
 
+        # AUTO: Checks this condition.
         if tok.type == "intlit":
+            # AUTO: Returns this result to the caller.
             return self._advance().value
+        # AUTO: Checks this condition.
         if tok.type == "dblit":
+            # AUTO: Returns this result to the caller.
             return self._advance().value
+        # AUTO: Checks this condition.
         if tok.type == "chrlit":
+            # AUTO: Returns this result to the caller.
             return self._advance().value
+        # AUTO: Checks this condition.
         if tok.type == "stringlit":
+            # AUTO: Returns this result to the caller.
             return self._advance().value
+        # AUTO: Checks this condition.
         if tok.type == "sunshine":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Returns this result to the caller.
             return "true"
+        # AUTO: Checks this condition.
         if tok.type == "frost":
+            # AUTO: Calls `self._advance`.
             self._advance()
+            # AUTO: Returns this result to the caller.
             return "false"
 
+        # AUTO: Appends a value to a list.
         self.errors.append(f"ICG Line {tok.line}: unexpected token in expression: '{tok.type}'")
+        # AUTO: Calls `self._advance`.
         self._advance()
+        # AUTO: Returns this result to the caller.
         return "???"
 
 
+    # AUTO: Defines function `_arguments`.
     def _arguments(self) -> List[str]:
+        # AUTO: Sets `args: List[str]`.
         args: List[str] = []
+        # AUTO: Checks this condition.
         if self._peek().type in (")", "EOF"):
+            # AUTO: Returns this result to the caller.
             return args
+        # AUTO: Appends a value to a list.
         args.append(self._expression())
+        # AUTO: Repeats while this condition is true.
         while self._match(","):
+            # AUTO: Appends a value to a list.
             args.append(self._expression())
+        # AUTO: Returns this result to the caller.
         return args
 
 
+# AUTO: Defines function `generate_icg`.
 def generate_icg(tokens: List[Any]) -> Dict[str, Any]:
+    # AUTO: Sets `gen`.
     gen = ICGenerator(tokens)
+    # AUTO: Sets `code, errors`.
     code, errors = gen.generate()
 
+    # AUTO: Sets `tac_dicts`.
     tac_dicts = [instr.to_dict() for instr in code]
+    # AUTO: Sets `tac_text`.
     tac_text = "\n".join(str(instr) for instr in code)
 
+    # AUTO: Returns this result to the caller.
     return {
+        # AUTO: Executes this statement.
         "success": len(errors) == 0,
+        # AUTO: Executes this statement.
         "tac": tac_dicts,
+        # AUTO: Executes this statement.
         "tac_text": tac_text,
+        # AUTO: Executes this statement.
         "errors": errors,
+    # AUTO: Closes the current grouped code/data.
     }

Backend/interpreter/__init__.py

@@ -1,8 +1,15 @@
 
+# AUTO: Imports names from another module.
 from .interpreter import Interpreter  # noqa: F401
+# AUTO: Imports names from another module.
 from .errors import (  # noqa: F401 - convenience re-exports
+    # AUTO: Executes this statement.
     InterpreterError,
+    # AUTO: Executes this statement.
     _CancelledError,
+    # AUTO: Executes this statement.
     InterpreterInputRequest,
+    # AUTO: Executes this statement.
     ReturnValue,
+# AUTO: Closes the current grouped code/data.
 )

Backend/interpreter/errors.py

@@ -1,34 +1,55 @@
+# AUTO: Imports a module used by this file.
 import re
 
+# AUTO: Sets `_REDUNDANT_PREFIX`.
 _REDUNDANT_PREFIX = re.compile(r'^(Runtime Error|Semantic Error|Type Mismatch|Syntax Error)\s*:?\s*', re.IGNORECASE)
 
 
+# AUTO: Defines class `ReturnValue`.
 class ReturnValue(Exception):
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, value):
+        # AUTO: Sets `self.value`.
         self.value = value
 
 
+# AUTO: Defines class `_CancelledError`.
 class _CancelledError(Exception):
+    # AUTO: Does nothing for this required block.
     pass
 
 
+# AUTO: Defines class `InterpreterError`.
 class InterpreterError(Exception):
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, message, line):
+        # AUTO: Calls `super`.
         super().__init__(message)
+        # AUTO: Sets `clean`.
         clean = _REDUNDANT_PREFIX.sub('', str(message)).strip()
+        # AUTO: Checks this condition.
         if line is not None and str(line) != "":
+            # AUTO: Sets `self.message`.
             self.message = f"RUNTIME error line {line}: {clean}"
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Sets `self.message`.
             self.message = clean
 
+    # AUTO: Defines function `__str__`.
     def __str__(self):
+        # AUTO: Returns this result to the caller.
         return self.message
 
 
+# AUTO: Defines class `InterpreterInputRequest`.
 class InterpreterInputRequest(Exception):
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, prompt, line):
+        # AUTO: Sets `self.prompt`.
         self.prompt = prompt
+        # AUTO: Sets `self.line`.
         self.line = line

Backend/lexer/__init__.py

@@ -1,7 +1,12 @@
 
+# AUTO: Imports names from another module.
 from .scanner import Lexer, lex
 
+# AUTO: Imports names from another module.
 from shared.tokens import *  # noqa: F401,F403  - TT_* constants
+# AUTO: Imports names from another module.
 from shared.tokens import Token, get_token_description  # noqa: F401  - explicit
+# AUTO: Imports names from another module.
 from lexer.positions import Position  # noqa: F401
+# AUTO: Imports names from another module.
 from lexer.errors import LexicalError  # noqa: F401

Backend/lexer/delimiters.py

@@ -1,60 +1,127 @@
+"""Character groups used by the scanner to validate token boundaries.
+
+A delimiter set is not a token by itself. It means "after reading this token,
+the next character must be one of these characters, otherwise report a lexical
+delimiter error."
+"""
+
+# LINE: ZERO is separated because some numeric rules treat 0 specially.
 ZERO = '0'
+# LINE: DIGIT contains non-zero digits.
 DIGIT = '123456789'
+# LINE: ZERODIGIT means any numeric digit 0-9.
 ZERODIGIT = ZERO + DIGIT
 
+# LINE: Lowercase letters accepted by identifiers/reserved words.
 LOW_ALPHA = 'abcdefghijklmnopqrstuvwxyz'
+# LINE: Uppercase letters accepted by identifiers/reserved words.
 UPPER_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+# LINE: ALPHA combines all letters.
 ALPHA = LOW_ALPHA + UPPER_ALPHA
+# LINE: ALPHANUM is what identifiers can continue with.
 ALPHANUM = ALPHA + ZERODIGIT + '_'
 
+# LINE: Common whitespace characters.
 WHITESPACE = ' \t\n'
+# LINE: EOF marker used inside delimiter sets.
 EOF = None
 
+# GUIDE: Named delimiter sets describe common token-boundary situations.
+# LINE: Characters allowed after a statement-ending context.
 statement_end_delim = set(ALPHA + WHITESPACE + '}') | {EOF}
+# LINE: Characters allowed after an opening parenthesis.
 open_paren_delim = set(ALPHA + ZERODIGIT + WHITESPACE + '"' + "'" + '~' + '!' + '(' + ')')
+# LINE: Characters allowed after a closing parenthesis.
 close_paren_delim = set(WHITESPACE) | {';', '{', ')', ',', '+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|', ']'}
+# AUTO: Sets `open_bracket_delim`.
 open_bracket_delim = set(ALPHA + ZERODIGIT + WHITESPACE + '~' + '!' + '(' + '"' + "'")
+# AUTO: Sets `close_bracket_delim`.
 close_bracket_delim = set(WHITESPACE) | {';', ',', ')', ']', '[', '.', '=', '+', '-', '*', '/', '%', '>', '<', '!', '&', '|'}
+# AUTO: Sets `block_start_delim`.
 block_start_delim = set(ALPHA + ZERODIGIT + WHITESPACE + '}/{"\'~!(')
+# AUTO: Sets `block_end_delim`.
 block_end_delim = set(ALPHA + ZERODIGIT + WHITESPACE + '};,)]')
+# AUTO: Sets `case_colon_delim`.
 case_colon_delim = set(ALPHA + WHITESPACE + '}/')
+# AUTO: Sets `after_comma_delim`.
 after_comma_delim = set(ALPHA + ZERODIGIT + WHITESPACE + '"' + "'" + '~' + '!' + '(' + '{')
+# AUTO: Sets `space_delim`.
 space_delim = {' ', '\t', '\n'}
+# AUTO: Sets `period_delim`.
 period_delim = {'.'}
+# AUTO: Sets `underscore_delim`.
 underscore_delim = {'_'}
+# AUTO: Sets `open_brack_delim`.
 open_brack_delim = {'['}
+# AUTO: Sets `close_brack_delim`.
 close_brack_delim = {']'}
+# AUTO: Sets `comma_delim`.
 comma_delim = {','}
+
+# GUIDE: Numbered delimiter sets are legacy FSM groups used by scanner.py branches.
+# LINE: Each delimN is a valid-next-character set, not a token.
 delim1 = {'}'}
+# AUTO: Sets `delim2`.
 delim2 = {':'}
+# AUTO: Sets `delim3`.
 delim3 = {'{'}
+# AUTO: Sets `delim4`.
 delim4 = {':', '('}
+# AUTO: Sets `delim5`.
 delim5 = {'('}
+# AUTO: Sets `delim6`.
 delim6 = {';', ',', '=', '>', '<', '!', '}', ')', '('}
+# AUTO: Sets `delim7`.
 delim7 = {'('}
+# AUTO: Sets `delim8`.
 delim8 = {';'}
+# AUTO: Sets `delim9`.
 delim9 = set(ALPHA + '(' + ',' + ';' + ')')
+# AUTO: Sets `delim10`.
 delim10 = {';', ')'}
+# AUTO: Sets `delim11`.
 delim11 = set(LOW_ALPHA + ZERODIGIT + ']~')
+# AUTO: Sets `delim12`.
 delim12 = set(ALPHA + ZERODIGIT + ']' + '~')
+# AUTO: Sets `delim13`.
 delim13 = {';', ')', '['}
+# AUTO: Sets `delim14`.
 delim14 = set(ALPHA + ZERODIGIT + '"' + "'" + '{')
+# AUTO: Sets `delim15`.
 delim15 = {'\n', ';', '}', ','}
+# AUTO: Sets `delim16`.
 delim16 = set(ALPHANUM + ')' + '"' + '!' + '(' + '[' + '\'')
+# AUTO: Sets `delim17`.
 delim17 = {'}', ';', ',', '+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|'}
+# AUTO: Sets `delim18`.
 delim18 = {';', '{', ')', '&', '|', '+', '-', '*', '/', '%'}
+# AUTO: Sets `delim19`.
 delim19 = {';', ',', '}', ')', '=', '>', '<', '!'}
+# AUTO: Sets `delim20`.
 delim20 = set(ALPHA + ZERODIGIT + '"' + "'" + '{')
+# AUTO: Sets `delim21`.
 delim21 = set(ALPHA + ZERODIGIT + WHITESPACE + '~!("\'')
+# AUTO: Sets `delim22`.
 delim22 = {',', ';', '(', ')', '{', '[', ']'}
+# AUTO: Sets `delim23`.
 delim23 = {';', ',', '}', ']', ')', ':', '+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|', '`'}
+# LINE: delim24 is used after binary/assignment operators like +, +=, ==.
 delim24 = set(ZERODIGIT + ALPHA + '~!("\'' + WHITESPACE)
+# LINE: delim25 is used after ++/-- so postfix/prefix boundaries are accepted.
 delim25 = set(ALPHANUM + ';) \t\n')
+# AUTO: Sets `delim26`.
 delim26 = set(ZERODIGIT + ALPHA + '~(' + '"\'' + ' \t\n')
+# LINE: idf_delim tells lexer what can legally appear after an identifier.
 idf_delim = {' ', ',', ';', '(', ')', '{', '}', '[', ']', ':', '+', '-', '*', '/', '%',
+             # AUTO: Sets `'>', '<', '`.
              '>', '<', '=', '\t', '\n', '.', '"', "'", '&', '|', '`'}
+# LINE: whlnum_delim tells lexer what can legally appear after an integer.
 whlnum_delim = {';', ' ', ',', '}', ']', ')', ':', '+', '-', '*', '/', '%', '=', '>', '<',
+                # AUTO: Executes this statement.
                 '!', '&', '|', '\t', '\n'}
+# LINE: decim_delim tells lexer what can legally appear after a double literal.
 decim_delim = {'}', ';', ',', '+', '-', '*', '/', '%', '=', '>', '<', '!', '&', '|', ' ',
+               # AUTO: Executes this statement.
                '\t', '\n', ')', ']'}
+# LINE: comment_delim is used around comment scanning boundaries.
 comment_delim = set(ALPHANUM + ';+-*/%}{()' + '\n')

Backend/lexer/errors.py

@@ -1,11 +1,18 @@
 
 
+# AUTO: Defines class `LexicalError`.
 class LexicalError:
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, pos, details):
+        # AUTO: Sets `self.pos`.
         self.pos = pos
+        # AUTO: Sets `self.details`.
         self.details = details
 
+    # AUTO: Defines function `as_string`.
     def as_string(self):
+        # AUTO: Sets `self.details`.
         self.details = self.details.replace('\n', '\\n')
+        # AUTO: Returns this result to the caller.
         return f"LEXICAL error line {self.pos.ln} col {self.pos.col} {self.details}"

Backend/lexer/positions.py

@@ -1,21 +1,35 @@
 
 
+# AUTO: Defines class `Position`.
 class Position:
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, index, ln, col=0):
+        # AUTO: Sets `self.index`.
         self.index = index
+        # AUTO: Sets `self.ln`.
         self.ln = ln
+        # AUTO: Sets `self.col`.
         self.col = col
 
+    # AUTO: Defines function `advance`.
     def advance(self, current_char):
+        # AUTO: Adds into `self.index`.
         self.index += 1
+        # AUTO: Adds into `self.col`.
         self.col += 1
 
+        # AUTO: Checks this condition.
         if current_char == '\n':
+            # AUTO: Adds into `self.ln`.
             self.ln += 1
+            # AUTO: Sets `self.col`.
             self.col = 0
 
+        # AUTO: Returns this result to the caller.
         return self
 
+    # AUTO: Defines function `copy`.
     def copy(self):
+        # AUTO: Returns this result to the caller.
         return Position(self.index, self.ln, self.col)

Backend/parser/__init__.py

@@ -1,2 +1,3 @@
 
+# AUTO: Imports names from another module.
 from .parser import LL1Parser  # noqa: F401  - main public class

Backend/semantic/__init__.py

@@ -1,3 +1,5 @@
 
+# AUTO: Imports names from another module.
 from .symbol_table import SymbolTable  # noqa: F401
+# AUTO: Imports names from another module.
 from .analyzer import ASTValidator, validate_ast  # noqa: F401

Backend/semantic/analyzer.py

@@ -1,194 +1,365 @@
+"""Final AST validation pass for GAL.
+
+builder.py already catches many declaration/type issues while creating the AST.
+This validator walks the finished AST and checks rules that are easier to see
+from the tree structure, such as prune/skip placement.
+"""
+
+# AUTO: Imports names from another module.
 from semantic.errors import SemanticError
 
 
+# AUTO: Defines class `ASTValidator`.
 class ASTValidator:
 
+    # AUTO: Defines function `__init__`.
     def __init__(self):
+        # GUIDE: Context counters tell checks if they are inside a loop,
+        # switch, or function while walking nested AST nodes.
+        # AUTO: Sets `self.errors`.
         self.errors = []
+        # AUTO: Sets `self.warnings`.
         self.warnings = []
+        # AUTO: Sets `self._in_loop`.
         self._in_loop = 0
+        # AUTO: Sets `self._in_switch`.
         self._in_switch = 0
+        # AUTO: Sets `self._in_function`.
         self._in_function = False
+        # AUTO: Sets `self._current_func_type`.
         self._current_func_type = None
 
 
+    # AUTO: Defines function `validate`.
     def validate(self, ast, symbol_table_data):
+        # Start walking from the ProgramNode. Every checker can add messages
+        # into self.errors; no errors means semantic validation succeeds.
+        # LINE: Begin recursive semantic walk from the AST root.
         self._walk(ast)
+        # LINE: Return validation result plus errors/warnings/symbol table.
         return {
+            # LINE: success is true only when no semantic errors were collected.
             "success": len(self.errors) == 0,
+            # AUTO: Executes this statement.
             "errors": self.errors,
+            # AUTO: Executes this statement.
             "warnings": self.warnings,
+            # AUTO: Executes this statement.
             "symbol_table": symbol_table_data,
+            # AUTO: Executes this statement.
             "ast": ast,
+        # AUTO: Closes the current grouped code/data.
         }
 
 
+    # AUTO: Defines function `_walk`.
     def _walk(self, node):
+        # GUIDE: Dynamic dispatch; Program calls _check_Program, Break calls
+        # _check_Break, and unknown node types simply recurse into children.
+        # LINE: Nothing to check for missing/empty AST node.
         if node is None:
+            # AUTO: Returns this result to the caller.
             return
+        # LINE: Find checker method based on node type, like _check_Break.
         handler = getattr(self, f'_check_{node.node_type}', None)
+        # LINE: If checker exists, run that specific semantic rule.
         if handler:
+            # AUTO: Calls `handler`.
             handler(node)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # LINE: Otherwise keep walking through this node's children.
             for child in getattr(node, 'children', []):
+                # AUTO: Calls `self._walk`.
                 self._walk(child)
 
 
+    # AUTO: Defines function `_check_Program`.
     def _check_Program(self, node):
+        # LINE: ProgramNode validates by checking each top-level child.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_VariableDeclaration`.
     def _check_VariableDeclaration(self, node):
+        # LINE: VariableDeclaration must at least contain type and name.
         if len(node.children) < 2:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: Malformed variable declaration.")
+        # LINE: Continue validating initializer/children.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_VariableDeclarationList`.
     def _check_VariableDeclarationList(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_SturdyDeclaration`.
     def _check_SturdyDeclaration(self, node):
+        # AUTO: Checks this condition.
         if len(node.children) < 3:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: Fertile declaration must have type, name, and value.")
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_FunctionDeclaration`.
     def _check_FunctionDeclaration(self, node):
+        # LINE: FunctionDeclaration must have a function name in node.value.
         if not node.value:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: Function declaration missing name.")
+        # LINE: Save previous function context before entering this function.
         prev_in_func = self._in_function
+        # AUTO: Sets `prev_func_type`.
         prev_func_type = self._current_func_type
+        # LINE: Mark validator as currently inside a function.
         self._in_function = True
+        # AUTO: Checks this condition.
         if node.children:
+            # LINE: First child stores return type.
             self._current_func_type = node.children[0].value
+        # LINE: Validate parameters/body/children inside the function.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
+        # LINE: Restore previous context after leaving function.
         self._in_function = prev_in_func
+        # AUTO: Sets `self._current_func_type`.
         self._current_func_type = prev_func_type
 
+    # AUTO: Defines function `_check_FunctionCall`.
     def _check_FunctionCall(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Assignment`.
     def _check_Assignment(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_AssignmentList`.
     def _check_AssignmentList(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_BinaryOp`.
     def _check_BinaryOp(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_UnaryOp`.
     def _check_UnaryOp(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Block`.
     def _check_Block(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_IfStatement`.
     def _check_IfStatement(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_ElseIfStatement`.
     def _check_ElseIfStatement(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_ElseStatement`.
     def _check_ElseStatement(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_ForLoop`.
     def _check_ForLoop(self, node):
+        # Enter loop context so prune/skip inside this block are legal.
+        # LINE: Increase loop depth before checking cultivate body.
         self._in_loop += 1
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
+        # Leave loop context after all nested children are checked.
+        # LINE: Decrease loop depth after cultivate body is checked.
         self._in_loop -= 1
 
+    # AUTO: Defines function `_check_WhileLoop`.
     def _check_WhileLoop(self, node):
+        # Same context rule as cultivate: grow allows prune/skip inside.
+        # LINE: Increase loop depth before checking grow body.
         self._in_loop += 1
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
+        # LINE: Decrease loop depth after grow body.
         self._in_loop -= 1
 
+    # AUTO: Defines function `_check_DoWhileLoop`.
     def _check_DoWhileLoop(self, node):
+        # AUTO: Adds into `self._in_loop`.
         self._in_loop += 1
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
+        # AUTO: Subtracts from `self._in_loop`.
         self._in_loop -= 1
 
+    # AUTO: Defines function `_check_Switch`.
     def _check_Switch(self, node):
+        # LINE: harvest/variety context allows prune inside switch cases.
         self._in_switch += 1
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
+        # LINE: Leave switch context after all cases are checked.
         self._in_switch -= 1
 
+    # AUTO: Defines function `_check_Break`.
     def _check_Break(self, node):
+        # prune is valid only while the walker is inside a loop or harvest.
+        # LINE: If no loop/switch context, prune is illegal.
         if self._in_loop == 0 and self._in_switch == 0:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: 'prune' used outside a loop or switch.")
 
+    # AUTO: Defines function `_check_Continue`.
     def _check_Continue(self, node):
+        # skip is valid only while the walker is inside a loop.
+        # LINE: If no loop context, skip is illegal.
         if self._in_loop == 0:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: 'skip' used outside a loop.")
 
+    # AUTO: Defines function `_check_Return`.
     def _check_Return(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_PrintStatement`.
     def _check_PrintStatement(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Condition`.
     def _check_Condition(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Update`.
     def _check_Update(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_List`.
     def _check_List(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_ListAccess`.
     def _check_ListAccess(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_TypeCast`.
     def _check_TypeCast(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_MemberAccess`.
     def _check_MemberAccess(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_BundleDefinition`.
     def _check_BundleDefinition(self, node):
+        # AUTO: Checks this condition.
         if not node.bundle_name:
+            # AUTO: Appends a value to a list.
             self.errors.append(
+                # AUTO: Executes this statement.
                 f"SEMANTIC error line {node.line}: Bundle definition missing name.")
 
+    # AUTO: Defines function `_check_Append`.
     def _check_Append(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Insert`.
     def _check_Insert(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+    # AUTO: Defines function `_check_Remove`.
     def _check_Remove(self, node):
+        # AUTO: Starts a loop over these values.
         for child in node.children:
+            # AUTO: Calls `self._walk`.
             self._walk(child)
 
+# AUTO: Defines function `validate_ast`.
 def validate_ast(ast, symbol_table_data):
+    # LINE: Create a fresh validator for this compile/run.
     validator = ASTValidator()
+    # LINE: Run validator and return its result.
     return validator.validate(ast, symbol_table_data)

Backend/semantic/errors.py

@@ -1,13 +1,22 @@
+# AUTO: Imports a module used by this file.
 import re
 
+# AUTO: Sets `_REDUNDANT_PREFIX`.
 _REDUNDANT_PREFIX = re.compile(r'^(Semantic Error|Syntax Error|Type Mismatch|Runtime Error)\s*:?\s*', re.IGNORECASE)
 
 
+# AUTO: Defines class `SemanticError`.
 class SemanticError(Exception):
+    # AUTO: Defines function `__init__`.
     def __init__(self, message, line):
+        # AUTO: Calls `super`.
         super().__init__(message)
+        # AUTO: Sets `clean`.
         clean = _REDUNDANT_PREFIX.sub('', str(message)).strip()
+        # AUTO: Sets `self.message`.
         self.message = f"SEMANTIC error line {line}: {clean}"
 
+    # AUTO: Defines function `__str__`.
     def __str__(self):
+        # AUTO: Returns this result to the caller.
         return self.message

Backend/semantic/symbol_table.py

@@ -1,101 +1,173 @@
 
 
+# AUTO: Defines class `SymbolTable`.
 class SymbolTable:
+    # AUTO: Defines function `__init__`.
     def __init__(self):
+        # AUTO: Sets `self.variables`.
         self.variables = {}
+        # AUTO: Sets `self.global_variables`.
         self.global_variables = {}
+        # AUTO: Sets `self.functions`.
         self.functions = {}
+        # AUTO: Sets `self.scopes`.
         self.scopes = [{}]
+        # AUTO: Sets `self.current_func_name`.
         self.current_func_name = None
+        # AUTO: Sets `self.function_variables`.
         self.function_variables = {}
+        # AUTO: Sets `self.bundle_types`.
         self.bundle_types = {}
 
+    # AUTO: Defines function `declare_variable`.
     def declare_variable(self, name, type_, value=None, is_list=False, is_fertile=False):
+        # AUTO: Sets `scope`.
         scope = self.scopes[-1]
+        # AUTO: Sets `current_func`.
         current_func = self.current_func_name
     
 
+        # AUTO: Checks this condition.
         if name in self.functions:
+            # AUTO: Returns this result to the caller.
             return f"Semantic Error: Variable '{name}' already declared as a function."
 
+        # AUTO: Checks this condition.
         if current_func:
+            # AUTO: Checks this condition.
             if current_func not in self.function_variables:
+                # AUTO: Sets `self.function_variables[current_func]`.
                 self.function_variables[current_func] = set()
 
+            # AUTO: Checks this condition.
             if name in self.function_variables[current_func]:
+                # AUTO: Returns this result to the caller.
                 return f"Semantic Error: Variable '{name}' already declared in this function."
 
+            # AUTO: Calls `self.function_variables[current_func].add`.
             self.function_variables[current_func].add(name)
 
+        # AUTO: Checks this condition.
         if self.current_func_name:
             
+            # AUTO: Sets `scope[name]`.
             scope[name] = {
+                # AUTO: Executes this statement.
                 "type": type_,  
+                # AUTO: Executes this statement.
                 "value": value,
+                # AUTO: Executes this statement.
                 "is_list": is_list,
+                # AUTO: Executes this statement.
                 "is_fertile": is_fertile
+            # AUTO: Closes the current grouped code/data.
             }
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Checks this condition.
             if name in self.global_variables:
+                # AUTO: Returns this result to the caller.
                 return f"Semantic Error: Variable '{name}' already declared."
             
+            # AUTO: Sets `self.variables[name]`.
             self.variables[name] = {
+                # AUTO: Executes this statement.
                 "type": type_,
+                # AUTO: Executes this statement.
                 "value": value,
+                # AUTO: Executes this statement.
                 "is_list": is_list,
+                # AUTO: Executes this statement.
                 "is_fertile": is_fertile
+            # AUTO: Closes the current grouped code/data.
             }
         
 
+    # AUTO: Defines function `lookup_variable`.
     def lookup_variable(self, name):
+        # AUTO: Starts a loop over these values.
         for i, scope in enumerate(reversed(self.scopes)):
+            # AUTO: Checks this condition.
             if name in scope:
+                # AUTO: Returns this result to the caller.
                 return scope[name]
         
+        # AUTO: Checks this condition.
         if name in self.variables:
+            # AUTO: Returns this result to the caller.
             return self.variables[name]
 
+        # AUTO: Returns this result to the caller.
         return f"Semantic Error: Variable '{name}' used before declaration."
     
+    # AUTO: Defines function `set_variable`.
     def set_variable(self, name, value):
+        # AUTO: Sets `current_scope`.
         current_scope = self.scopes[-1]
 
+        # AUTO: Checks this condition.
         if name in current_scope:
+            # AUTO: Sets `current_scope[name]["value"]`.
             current_scope[name]["value"] = value
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Returns this result to the caller.
             return f"Semantic Error: Variable '{name}' not declared in the current scope."
 
+    # AUTO: Defines function `declare_function`.
     def declare_function(self, name, return_type, params, node=None):
+        # AUTO: Checks this condition.
         if name in self.functions:
+            # AUTO: Returns this result to the caller.
             return f"Semantic Error: Function '{name}' already declared."
+        # AUTO: Sets `self.functions[name]`.
         self.functions[name] = {"return_type": return_type, "params": params, "node": node}
 
+    # AUTO: Defines function `lookup_function`.
     def lookup_function(self, name):
+        # AUTO: Checks this condition.
         if name in self.functions:
+            # AUTO: Returns this result to the caller.
             return self.functions[name]
+        # AUTO: Returns this result to the caller.
         return f"Semantic Error: Function '{name}' is not defined."
     
 
+    # AUTO: Defines function `enter_scope`.
     def enter_scope(self):
+        # AUTO: Appends a value to a list.
         self.scopes.append({})
         
 
+    # AUTO: Defines function `exit_scope`.
     def exit_scope(self):
+        # AUTO: Checks this condition.
         if len(self.scopes) > 1:
+            # AUTO: Removes and returns an item.
             self.scopes.pop()
         
+        # AUTO: Checks this condition.
         if self.current_func_name:
+            # AUTO: Sets `current_func`.
             current_func = self.current_func_name
 
+            # AUTO: Checks this condition.
             if current_func in self.function_variables:
+                # AUTO: Calls `self.function_variables[current_func].clear`.
                 self.function_variables[current_func].clear()
 
 
+    # AUTO: Defines function `debug_scopes`.
     def debug_scopes(self):
+        # AUTO: Calls `print`.
         print("\n====== SYMBOL TABLE DEBUG ======")
+        # AUTO: Calls `print`.
         print("🔹 Local Scopes (Stacked from Global to Inner Scope):")
+        # AUTO: Starts a loop over these values.
         for i, scope in enumerate(self.scopes):
+            # AUTO: Calls `print`.
             print(f"  Scope {i}: {scope}")
+        # AUTO: Calls `print`.
         print("================================\n")
 
 

Backend/server.py

@@ -1,597 +1,1095 @@
+"""HTTP and Socket.IO entry point for the GAL compiler.
 
-# WARNING SUPPRESSION + EVENTLET BOOTSTRAP
+Pipeline from the UI:
+source code -> lexer -> LL(1) parser/AST builder -> semantic validator -> interpreter.
+"""
+
+# Eventlet must be patched before Flask-SocketIO starts using sockets.
+# AUTO: Imports a module used by this file.
 import warnings
+# AUTO: Sets `warnings.filterwarnings("ignore", message`.
 warnings.filterwarnings("ignore", message=".*RLock.*were not greened.*")
 
+# AUTO: Imports a module used by this file.
 import eventlet
+# AUTO: Calls `eventlet.monkey_patch`.
 eventlet.monkey_patch()
 
+# AUTO: Imports names from another module.
 from flask import Flask, request, jsonify, send_from_directory
+# AUTO: Imports names from another module.
 from flask_cors import CORS
+# AUTO: Imports names from another module.
 from flask_socketio import SocketIO, emit
+# AUTO: Imports a module used by this file.
 import os
+# AUTO: Imports names from another module.
 from google import genai
+# AUTO: Imports names from another module.
 from lexer import lex, get_token_description
+# AUTO: Imports names from another module.
 from parser import LL1Parser
+# AUTO: Imports names from another module.
 from cfg import cfg, first_sets, predict_sets
+# AUTO: Imports names from another module.
 from parser.builder import analyze_semantics
+# AUTO: Imports names from another module.
 from semantic import validate_ast
+# AUTO: Imports names from another module.
 from icg import generate_icg
+# AUTO: Imports names from another module.
 from interpreter import Interpreter, InterpreterError, _CancelledError
+# AUTO: Imports names from another module.
 from ai import fallback_reply
 
 
+# AUTO: Defines function `_display_value`.
 def _display_value(val):
+    # AUTO: Checks this condition.
     if val is None:
+        # AUTO: Returns this result to the caller.
         return ''
+    # AUTO: Sets `s`.
     s = str(val)
+    # AUTO: Sets `s`.
     s = s.replace('\n', '\\n')
+    # AUTO: Sets `s`.
     s = s.replace('\t', '\\t')
+    # AUTO: Sets `s`.
     s = s.replace('\r', '\\r')
+    # AUTO: Returns this result to the caller.
     return s
 
 
+# AUTO: Sets `app`.
 app = Flask(__name__, static_folder='../UI', static_url_path='')
+# AUTO: Calls `CORS`.
 CORS(app)
+# AUTO: Sets `socketio`.
 socketio = SocketIO(app, cors_allowed_origins="*")
 
+# AUTO: Sets `interpreters`.
 interpreters = {}
 
 
+# AUTO: Defines class `SessionEmitter`.
 class SessionEmitter:
+    # AUTO: Defines function `__init__`.
     def __init__(self, sio, sid):
+        # AUTO: Sets `self._sio`.
         self._sio = sio
+        # AUTO: Sets `self._sid`.
         self._sid = sid
 
+    # AUTO: Defines function `emit`.
     def emit(self, event, data=None, **kwargs):
+        # AUTO: Sets `self._sio.emit(event, data, to`.
         self._sio.emit(event, data, to=self._sid, **kwargs)
 
 
+# AUTO: Sets `parser`.
 parser = LL1Parser(
+    # AUTO: Sets `cfg`.
     cfg=cfg,
+    # AUTO: Sets `predict_sets`.
     predict_sets=predict_sets,
+    # AUTO: Sets `first_sets`.
     first_sets=first_sets,
+    # AUTO: Sets `start_symbol`.
     start_symbol="<program>",
+    # AUTO: Sets `end_marker`.
     end_marker="EOF",
+    # AUTO: Sets `skip_token_types`.
     skip_token_types={'\n', 'comment', 'mcommentlit'}
+# AUTO: Closes the current grouped code/data.
 )
 
+
+# GUIDE: Browser/cache setup for local testing.
+# AUTO: Attaches this decorator to the next function/class.
 @app.after_request
+# AUTO: Defines function `add_no_cache`.
 def add_no_cache(response):
+    # AUTO: Sets `response.headers['Cache-Control']`.
     response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
+    # AUTO: Sets `response.headers['Pragma']`.
     response.headers['Pragma'] = 'no-cache'
+    # AUTO: Sets `response.headers['Expires']`.
     response.headers['Expires'] = '0'
+    # AUTO: Returns this result to the caller.
     return response
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/')
+# AUTO: Defines function `index`.
 def index():
+    # AUTO: Returns this result to the caller.
     return send_from_directory('../UI', 'index.html')
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/images/<path:filename>')
+# AUTO: Defines function `serve_images`.
 def serve_images(filename):
+    # AUTO: Returns this result to the caller.
     return send_from_directory('../images', filename)
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/<path:path>')
+# AUTO: Defines function `serve_static`.
 def serve_static(path):
+    # AUTO: Returns this result to the caller.
     return send_from_directory('../UI', path)
 
 
+# GUIDE: Lexer stage endpoint used by the lexeme table and Lexer run mode.
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/lex', methods=['POST'])
+# AUTO: Defines function `lexer_endpoint`.
 def lexer_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `data`.
         data = request.get_json()
         
+        # AUTO: Checks this condition.
         if not data or 'source_code' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'error': 'Missing source_code in request body'
+            # AUTO: Closes the current grouped code/data.
             }), 400
         
+        # AUTO: Sets `source_code`.
         source_code = data['source_code']
         
+        # AUTO: Sets `tokens, errors`.
         tokens, errors = lex(source_code)
         
+        # AUTO: Sets `token_list`.
         token_list = []
+        # AUTO: Starts a loop over these values.
         for token in tokens:
+            # AUTO: Appends a value to a list.
             token_list.append({
+                # AUTO: Executes this statement.
                 'type': token.type,
+                # AUTO: Calls `_display_value`.
                 'value': _display_value(token.value),
+                # AUTO: Executes this statement.
                 'line': token.line,
+                # AUTO: Calls `getattr`.
                 'col': getattr(token, 'col', 0),
+                # AUTO: Calls `get_token_description`.
                 'description': get_token_description(token.type, token.value)
+            # AUTO: Closes the current grouped code/data.
             })
         
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'tokens': token_list,
+            # AUTO: Executes this statement.
             'errors': errors
+        # AUTO: Closes the current grouped code/data.
         })
     
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'error': f'Server error: {str(e)}'
+        # AUTO: Closes the current grouped code/data.
         }), 500
 
+# GUIDE: Syntax stage endpoint; tokenizes first, then checks tokens with CFG.
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/parse', methods=['POST'])
+# AUTO: Defines function `parser_endpoint`.
 def parser_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `data`.
         data = request.get_json()
         
+        # AUTO: Checks this condition.
         if not data or 'source_code' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'error': 'Missing source_code in request body'
+            # AUTO: Closes the current grouped code/data.
             }), 400
         
+        # AUTO: Sets `source_code`.
         source_code = data['source_code']
         
+        # AUTO: Sets `tokens, lex_errors`.
         tokens, lex_errors = lex(source_code)
         
+        # AUTO: Sets `token_list`.
         token_list = []
+        # AUTO: Starts a loop over these values.
         for token in tokens:
+            # AUTO: Appends a value to a list.
             token_list.append({
+                # AUTO: Executes this statement.
                 'type': token.type,
+                # AUTO: Calls `_display_value`.
                 'value': _display_value(token.value),
+                # AUTO: Executes this statement.
                 'line': token.line,
+                # AUTO: Calls `getattr`.
                 'col': getattr(token, 'col', 0),
+                # AUTO: Calls `get_token_description`.
                 'description': get_token_description(token.type, token.value)
+            # AUTO: Closes the current grouped code/data.
             })
         
+        # AUTO: Checks this condition.
         if lex_errors:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': lex_errors,
+                # AUTO: Executes this statement.
                 'stage': ['lexical'],
+                # AUTO: Executes this statement.
                 'lexical_errors': True,
+                # AUTO: Executes this statement.
                 'syntax_errors': False
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # AUTO: Sets `parse_success, parse_errors`.
         parse_success, parse_errors = parser.parse(tokens)
         
+        # AUTO: Sets `stages`.
         stages = []
+        # AUTO: Checks this condition.
         if parse_errors:
+            # AUTO: Appends a value to a list.
             stages.append('syntax')
         
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'success': parse_success,
+            # AUTO: Executes this statement.
             'tokens': token_list,
+            # AUTO: Executes this statement.
             'errors': parse_errors,
+            # AUTO: Executes this statement.
             'stage': stages if stages else ['success'],
+            # AUTO: Executes this statement.
             'lexical_errors': False,
+            # AUTO: Executes this statement.
             'syntax_errors': len(parse_errors) > 0
+        # AUTO: Closes the current grouped code/data.
         })
     
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'error': f'Server error: {str(e)}'
+        # AUTO: Closes the current grouped code/data.
         }), 500
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/health', methods=['GET'])
+# AUTO: Defines function `health_check`.
 def health_check():
+    # AUTO: Returns this result to the caller.
     return jsonify({
+        # AUTO: Executes this statement.
         'status': 'healthy',
+        # AUTO: Executes this statement.
         'message': 'GAL Compiler Server is running'
+    # AUTO: Closes the current grouped code/data.
     })
 
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/semantic', methods=['POST'])
+# AUTO: Defines function `semantic_endpoint`.
 def semantic_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `data`.
         data = request.get_json()
         
+        # AUTO: Checks this condition.
         if not data or 'source_code' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'error': 'Missing source_code in request body'
+            # AUTO: Closes the current grouped code/data.
             }), 400
         
+        # AUTO: Sets `source_code`.
         source_code = data['source_code']
         
+        # AUTO: Sets `tokens, lex_errors`.
         tokens, lex_errors = lex(source_code)
         
+        # AUTO: Sets `token_list`.
         token_list = []
+        # AUTO: Starts a loop over these values.
         for token in tokens:
+            # AUTO: Appends a value to a list.
             token_list.append({
+                # AUTO: Executes this statement.
                 'type': token.type,
+                # AUTO: Calls `_display_value`.
                 'value': _display_value(token.value),
+                # AUTO: Executes this statement.
                 'line': token.line,
+                # AUTO: Calls `getattr`.
                 'col': getattr(token, 'col', 0),
+                # AUTO: Calls `get_token_description`.
                 'description': get_token_description(token.type, token.value)
+            # AUTO: Closes the current grouped code/data.
             })
         
+        # AUTO: Checks this condition.
         if lex_errors:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': lex_errors,
+                # AUTO: Executes this statement.
                 'warnings': [],
+                # AUTO: Executes this statement.
                 'stage': 'lexical'
+            # AUTO: Closes the current grouped code/data.
             })
         
+        # AUTO: Sets `parse_result`.
         parse_result = parser.parse_and_build(tokens)
         
+        # AUTO: Checks this condition.
         if not parse_result['success']:
+            # AUTO: Sets `error_stage`.
             error_stage = parse_result.get('error_stage', 'syntax')
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': parse_result['errors'],
+                # AUTO: Executes this statement.
                 'warnings': [],
+                # AUTO: Executes this statement.
                 'stage': error_stage
+            # AUTO: Closes the current grouped code/data.
             })
         
+        # AUTO: Sets `semantic_result`.
         semantic_result = validate_ast(parse_result['ast'], parse_result['symbol_table'])
         
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'success': semantic_result['success'],
+            # AUTO: Executes this statement.
             'tokens': token_list,
+            # AUTO: Executes this statement.
             'errors': semantic_result['errors'],
+            # AUTO: Executes this statement.
             'warnings': semantic_result['warnings'],
+            # AUTO: Executes this statement.
             'symbol_table': semantic_result['symbol_table'],
+            # AUTO: Executes this statement.
             'stage': 'semantic'
+        # AUTO: Closes the current grouped code/data.
         })
     
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'error': f'Server error: {str(e)}'
+        # AUTO: Closes the current grouped code/data.
         }), 500
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/icg', methods=['POST'])
+# AUTO: Defines function `icg_endpoint`.
 def icg_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `data`.
         data = request.get_json()
 
+        # AUTO: Checks this condition.
         if not data or 'source_code' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'error': 'Missing source_code in request body'
+            # AUTO: Closes the current grouped code/data.
             }), 400
 
+        # AUTO: Sets `source_code`.
         source_code = data['source_code']
 
+        # AUTO: Sets `tokens, lex_errors`.
         tokens, lex_errors = lex(source_code)
 
+        # AUTO: Sets `token_list`.
         token_list = []
+        # AUTO: Starts a loop over these values.
         for token in tokens:
+            # AUTO: Appends a value to a list.
             token_list.append({
+                # AUTO: Executes this statement.
                 'type': token.type,
+                # AUTO: Calls `_display_value`.
                 'value': _display_value(token.value),
+                # AUTO: Executes this statement.
                 'line': token.line,
+                # AUTO: Calls `getattr`.
                 'col': getattr(token, 'col', 0),
+                # AUTO: Calls `get_token_description`.
                 'description': get_token_description(token.type, token.value)
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # AUTO: Checks this condition.
         if lex_errors:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': lex_errors,
+                # AUTO: Executes this statement.
                 'stage': 'lexical'
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # AUTO: Sets `parse_result`.
         parse_result = parser.parse_and_build(tokens)
+        # AUTO: Checks this condition.
         if not parse_result['success']:
+            # AUTO: Sets `error_stage`.
             error_stage = parse_result.get('error_stage', 'syntax')
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': parse_result['errors'],
+                # AUTO: Executes this statement.
                 'stage': error_stage
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # AUTO: Sets `semantic_result`.
         semantic_result = validate_ast(parse_result['ast'], parse_result['symbol_table'])
+        # AUTO: Checks this condition.
         if not semantic_result['success']:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'tokens': token_list,
+                # AUTO: Executes this statement.
                 'errors': semantic_result['errors'],
+                # AUTO: Executes this statement.
                 'warnings': semantic_result['warnings'],
+                # AUTO: Executes this statement.
                 'stage': 'semantic'
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # AUTO: Sets `icg_result`.
         icg_result = generate_icg(tokens)
 
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'success': icg_result['success'],
+            # AUTO: Executes this statement.
             'tokens': token_list,
+            # AUTO: Executes this statement.
             'tac': icg_result['tac'],
+            # AUTO: Executes this statement.
             'tac_text': icg_result['tac_text'],
+            # AUTO: Executes this statement.
             'errors': icg_result['errors'],
+            # AUTO: Calls `semantic_result.get`.
             'warnings': semantic_result.get('warnings', []),
+            # AUTO: Executes this statement.
             'stage': 'icg'
+        # AUTO: Closes the current grouped code/data.
         })
 
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # AUTO: Returns this result to the caller.
         return jsonify({
+            # AUTO: Executes this statement.
             'error': f'Server error: {str(e)}'
+        # AUTO: Closes the current grouped code/data.
         }), 500
 
 
+# AUTO: Defines class `OutputCollector`.
 class OutputCollector:
+    # AUTO: Defines function `__init__`.
     def __init__(self):
+        # AUTO: Sets `self.outputs`.
         self.outputs = []
+        # AUTO: Sets `self.needs_input`.
         self.needs_input = False
 
+    # AUTO: Defines function `emit`.
     def emit(self, event, data=None, **kwargs):
+        # AUTO: Checks this condition.
         if event == 'output' and data:
+            # AUTO: Appends a value to a list.
             self.outputs.append(data.get('output', ''))
+        # AUTO: Checks the next alternate condition.
         elif event == 'input_required':
+            # AUTO: Sets `self.needs_input`.
             self.needs_input = True
+            # AUTO: Stops this flow by raising an error.
             raise _InputNeeded()
 
 
+# AUTO: Defines class `_InputNeeded`.
 class _InputNeeded(Exception):
+    # AUTO: Does nothing for this required block.
     pass
 
 
+# GUIDE: Full non-interactive compiler pipeline from source code to output.
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/run', methods=['POST'])
+# AUTO: Defines function `run_endpoint`.
 def run_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # LINE: Read JSON request body sent by the frontend.
         data = request.get_json()
+        # LINE: Reject request if editor source code is missing.
         if not data or 'source_code' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({'error': 'Missing source_code in request body'}), 400
 
+        # LINE: Store the full editor text in source_code.
         source_code = data['source_code']
 
+        # LINE: Stage 1, scan source code into lexer tokens.
         tokens, lex_errors = lex(source_code)
+        # LINE: Stop pipeline if lexer found invalid characters/delimiters.
         if lex_errors:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': 'lexical',
+                # AUTO: Executes this statement.
                 'output': [],
+                # AUTO: Executes this statement.
                 'errors': lex_errors
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # LINE: Stage 2, parse tokens and build AST if syntax is valid.
         parse_result = parser.parse_and_build(tokens)
+        # LINE: Stop pipeline if syntax or builder semantic checks failed.
         if not parse_result['success']:
+            # AUTO: Sets `error_stage`.
             error_stage = parse_result.get('error_stage', 'syntax')
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': error_stage,
+                # AUTO: Executes this statement.
                 'output': [],
+                # AUTO: Executes this statement.
                 'errors': [str(e) for e in parse_result['errors']]
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # LINE: Stage 3, validate AST semantic rules.
         semantic_result = validate_ast(parse_result['ast'], parse_result['symbol_table'])
+        # LINE: Stop pipeline if semantic analyzer found errors.
         if not semantic_result['success']:
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': 'semantic',
+                # AUTO: Executes this statement.
                 'output': [],
+                # AUTO: Executes this statement.
                 'errors': [str(e) for e in semantic_result['errors']]
+            # AUTO: Closes the current grouped code/data.
             })
 
+        # LINE: Get the validated AST for execution.
         ast = semantic_result['ast']
 
+        # LINE: Collector captures plant() output for non-socket /api/run.
         collector = OutputCollector()
+        # LINE: Create interpreter and give it the collector as output target.
         interp = Interpreter(socketio=collector)
+        # AUTO: Starts protected code that can catch errors.
         try:
+            # LINE: Stage 4, execute ProgramNode through interpreter.
             interp.interpret(ast)
+            # LINE: Return successful runtime output to frontend.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': True,
+                # AUTO: Executes this statement.
                 'stage': 'execution',
+                # AUTO: Executes this statement.
                 'output': collector.outputs,
+                # AUTO: Executes this statement.
                 'errors': []
+            # AUTO: Closes the current grouped code/data.
             })
+        # AUTO: Handles the matching error case.
         except _InputNeeded:
+            # LINE: Non-interactive endpoint cannot continue if water() needs input.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': 'execution',
+                # AUTO: Executes this statement.
                 'output': collector.outputs,
+                # AUTO: Executes this statement.
                 'errors': ['Program requires interactive input (water())'],
+                # AUTO: Executes this statement.
                 'needs_input': True
+            # AUTO: Closes the current grouped code/data.
             })
+        # AUTO: Handles the matching error case.
         except InterpreterError as e:
+            # LINE: Runtime error from interpreter, such as division by zero.
             collector.outputs.append(f'Runtime Error: {e}')
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': 'execution',
+                # AUTO: Executes this statement.
                 'output': collector.outputs,
+                # AUTO: Executes this statement.
                 'errors': [str(e)]
+            # AUTO: Closes the current grouped code/data.
             })
+        # AUTO: Handles the matching error case.
         except Exception as e:
+            # LINE: Unexpected server/interpreter exception.
             collector.outputs.append(f'Internal Error: {e}')
+            # AUTO: Returns this result to the caller.
             return jsonify({
+                # AUTO: Executes this statement.
                 'success': False,
+                # AUTO: Executes this statement.
                 'stage': 'execution',
+                # AUTO: Executes this statement.
                 'output': collector.outputs,
+                # AUTO: Executes this statement.
                 'errors': [str(e)]
+            # AUTO: Closes the current grouped code/data.
             })
 
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # LINE: Last-resort server error response.
         return jsonify({'error': f'Server error: {str(e)}'}), 500
 
 
+# AUTO: Attaches this decorator to the next function/class.
 @socketio.on('connect')
+# AUTO: Defines function `handle_connect`.
 def handle_connect():
+    # AUTO: Does nothing for this required block.
     pass
 
+# AUTO: Attaches this decorator to the next function/class.
 @socketio.on('disconnect')
+# AUTO: Defines function `handle_disconnect`.
 def handle_disconnect():
+    # AUTO: Sets `sid`.
     sid = request.sid
+    # AUTO: Removes and returns an item.
     interpreters.pop(sid, None)
 
+# AUTO: Attaches this decorator to the next function/class.
 @socketio.on('run_code')
+# AUTO: Defines function `handle_run_code`.
 def handle_run_code(data):
+    # LINE: sid identifies the browser session running this code.
     sid = request.sid
+    # LINE: Read current editor source from Socket.IO payload.
     source_code = data.get('source_code', '')
 
+    # LINE: Stage 1, lex source code.
     tokens, lex_errors = lex(source_code)
+    # LINE: Send lexical errors directly to the terminal output.
     if lex_errors:
+        # AUTO: Starts a loop over these values.
         for err in lex_errors:
+            # AUTO: Calls `emit`.
             emit('output', {'output': f'Lexical Error: {err}'})
+        # AUTO: Calls `emit`.
         emit('execution_complete', {'success': False, 'stage': 'lexical'})
+        # AUTO: Returns this result to the caller.
         return
 
+    # LINE: Notify frontend that lexical stage passed.
     emit('stage_complete', {'stage': 'lexical', 'success': True})
 
+    # LINE: Stage 2, parse and build AST.
     parse_result = parser.parse_and_build(tokens)
+    # LINE: Stop if syntax/builder failed.
     if not parse_result['success']:
+        # AUTO: Sets `error_stage`.
         error_stage = parse_result.get('error_stage', 'syntax')
+        # AUTO: Starts a loop over these values.
         for err in parse_result['errors']:
+            # AUTO: Calls `emit`.
             emit('output', {'output': f'{err}'})
+        # AUTO: Calls `emit`.
         emit('execution_complete', {'success': False, 'stage': error_stage})
+        # AUTO: Returns this result to the caller.
         return
 
+    # LINE: Notify frontend that syntax stage passed.
     emit('stage_complete', {'stage': 'syntax', 'success': True})
 
+    # LINE: Stage 3, semantic validation.
     semantic_result = validate_ast(parse_result['ast'], parse_result['symbol_table'])
+    # LINE: Stop if semantic validation failed.
     if not semantic_result['success']:
+        # AUTO: Starts a loop over these values.
         for err in semantic_result['errors']:
+            # AUTO: Calls `emit`.
             emit('output', {'output': f'{err}'})
+        # AUTO: Calls `emit`.
         emit('execution_complete', {'success': False, 'stage': 'semantic'})
+        # AUTO: Returns this result to the caller.
         return
 
+    # LINE: Notify frontend that semantic stage passed.
     emit('stage_complete', {'stage': 'semantic', 'success': True})
 
+    # LINE: Save validated AST before execution.
     ast = semantic_result['ast']
 
+    # LINE: Cancel any previous interpreter still waiting/running for this session.
     old_interp = interpreters.get(sid)
+    # AUTO: Checks this condition.
     if old_interp and hasattr(old_interp, '_cancelled'):
+        # AUTO: Sets `old_interp._cancelled`.
         old_interp._cancelled = True
+        # AUTO: Starts a loop over these values.
         for evt in list(old_interp.input_events.values()):
+            # AUTO: Starts protected code that can catch errors.
             try:
+                # AUTO: Calls `evt.send`.
                 evt.send(None)
+            # AUTO: Handles the matching error case.
             except (AttributeError, AssertionError):
+                # AUTO: Starts protected code that can catch errors.
                 try:
+                    # AUTO: Calls `evt.set`.
                     evt.set()
+                # AUTO: Handles the matching error case.
                 except Exception:
+                    # AUTO: Does nothing for this required block.
                     pass
 
+    # Runs in the background so water() can pause and receive browser input.
+    # AUTO: Defines function `run_interpreter`.
     def run_interpreter():
+        # AUTO: Starts protected code that can catch errors.
         try:
+            # LINE: Emitter sends plant()/water() events to this browser session only.
             session_emitter = SessionEmitter(socketio, sid)
+            # LINE: Create one interpreter instance for this run.
             interp = Interpreter(socketio=session_emitter)
+            # LINE: Runtime cancellation flag used when rerunning code.
             interp._cancelled = False
+            # LINE: Store interpreter so capture_input can find it later.
             interpreters[sid] = interp
+            # LINE: Execute the validated AST.
             interp.interpret(ast)
+            # LINE: Tell UI execution completed if run was not cancelled.
             if not interp._cancelled:
+                # AUTO: Sets `socketio.emit('execution_complete', {'success': True, 'stage': 'execution'}, to`.
                 socketio.emit('execution_complete', {'success': True, 'stage': 'execution'}, to=sid)
+        # AUTO: Handles the matching error case.
         except _CancelledError:
+            # AUTO: Does nothing for this required block.
             pass
+        # AUTO: Handles the matching error case.
         except InterpreterError as e:
+            # LINE: Send runtime errors to the output panel.
             if not getattr(interp, '_cancelled', False):
+                # AUTO: Sets `socketio.emit('output', {'output': f'Runtime Error: {e}'}, to`.
                 socketio.emit('output', {'output': f'Runtime Error: {e}'}, to=sid)
+                # AUTO: Sets `socketio.emit('execution_complete', {'success': False, 'stage': 'execution'}, to`.
                 socketio.emit('execution_complete', {'success': False, 'stage': 'execution'}, to=sid)
+        # AUTO: Handles the matching error case.
         except Exception as e:
+            # LINE: Send unexpected internal errors to the output panel.
             if not getattr(interp, '_cancelled', False):
+                # AUTO: Sets `socketio.emit('output', {'output': f'Internal Error: {e}'}, to`.
                 socketio.emit('output', {'output': f'Internal Error: {e}'}, to=sid)
+                # AUTO: Sets `socketio.emit('execution_complete', {'success': False, 'stage': 'execution'}, to`.
                 socketio.emit('execution_complete', {'success': False, 'stage': 'execution'}, to=sid)
+        # AUTO: Runs cleanup code no matter what happened.
         finally:
+            # LINE: Remove finished interpreter from active session map.
             if interpreters.get(sid) is interp:
+                # AUTO: Removes and returns an item.
                 interpreters.pop(sid, None)
 
+    # LINE: Start interpreter in background so UI remains responsive.
     socketio.start_background_task(run_interpreter)
 
+# AUTO: Attaches this decorator to the next function/class.
 @socketio.on('capture_input')
+# AUTO: Defines function `handle_capture_input`.
 def handle_capture_input(data):
+    # LINE: Identify which browser session sent the water() answer.
     sid = request.sid
+    # LINE: Find that session's waiting interpreter.
     interp = interpreters.get(sid)
+    # AUTO: Checks this condition.
     if interp:
+        # LINE: Get variable name and input value from frontend payload.
         var_name = data.get('var_name', '')
+        # AUTO: Sets `input_value`.
         input_value = data.get('input', '')
+        # LINE: Resume the interpreter waiting inside eval_input().
         interp.provide_input(var_name, input_value)
 
 
+# AUTO: Sets `_prompt_path`.
 _prompt_path = os.path.join(os.path.dirname(__file__), 'ai', 'prompt.txt')
+# AUTO: Opens a managed resource/context.
 with open(_prompt_path, 'r', encoding='utf-8') as _f:
+    # AUTO: Sets `GAL_SYSTEM_PROMPT`.
     GAL_SYSTEM_PROMPT = _f.read()
 
 
+# AUTO: Sets `_gemini_client`.
 _gemini_client = None
+# AUTO: Sets `_chat_sessions`.
 _chat_sessions = {}
 
+# AUTO: Defines function `_get_gemini_client`.
 def _get_gemini_client():
+    # AUTO: Uses a module-level variable inside this function.
     global _gemini_client
+    # AUTO: Checks this condition.
     if _gemini_client is None:
+        # AUTO: Sets `api_key`.
         api_key = os.environ.get('GEMINI_API_KEY', '')
+        # AUTO: Checks this condition.
         if not api_key:
+            # AUTO: Returns this result to the caller.
             return None
+        # AUTO: Sets `_gemini_client`.
         _gemini_client = genai.Client(api_key=api_key)
+    # AUTO: Returns this result to the caller.
     return _gemini_client
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/chat', methods=['POST'])
+# AUTO: Defines function `chat_endpoint`.
 def chat_endpoint():
+    # AUTO: Starts protected code that can catch errors.
     try:
+        # AUTO: Sets `data`.
         data = request.get_json()
+        # AUTO: Checks this condition.
         if not data or 'message' not in data:
+            # AUTO: Returns this result to the caller.
             return jsonify({'error': 'Missing message in request body'}), 400
 
+        # AUTO: Sets `user_message`.
         user_message = data['message']
+        # AUTO: Sets `session_id`.
         session_id = data.get('session_id', 'default')
+        # AUTO: Sets `editor_code`.
         editor_code = data.get('editor_code', '')
 
+        # AUTO: Sets `client`.
         client = _get_gemini_client()
+        # AUTO: Checks this condition.
         if client is None:
+            # AUTO: Sets `fb_reply`.
             fb_reply = fallback_reply(user_message)
+            # AUTO: Returns this result to the caller.
             return jsonify({'reply': fb_reply, 'mode': 'fallback'})
 
+        # AUTO: Checks this condition.
         if session_id not in _chat_sessions:
+            # AUTO: Sets `_chat_sessions[session_id]`.
             _chat_sessions[session_id] = []
+        # AUTO: Sets `history`.
         history = _chat_sessions[session_id]
 
+        # AUTO: Sets `full_message`.
         full_message = user_message
+        # AUTO: Checks this condition.
         if editor_code.strip():
+            # AUTO: Sets `full_message`.
             full_message = f"[Current code in editor]:\n```\n{editor_code}\n```\n\nUser question: {user_message}"
 
+        # AUTO: Appends a value to a list.
         history.append({'role': 'user', 'parts': [{'text': full_message}]})
 
+        # AUTO: Checks this condition.
         if len(history) > 20:
+            # AUTO: Sets `history[:]`.
             history[:] = history[-20:]
 
+        # AUTO: Sets `models_to_try`.
         models_to_try = ['gemini-2.5-flash', 'gemini-2.5-flash-lite', 'gemini-2.0-flash', 'gemini-2.0-flash-lite']
+        # AUTO: Sets `last_error: Exception`.
         last_error: Exception = RuntimeError("No Gemini models were available to try")
+        # AUTO: Starts a loop over these values.
         for model_name in models_to_try:
+            # AUTO: Starts protected code that can catch errors.
             try:
+                # AUTO: Sets `response`.
                 response = client.models.generate_content(
+                    # AUTO: Sets `model`.
                     model=model_name,
+                    # AUTO: Sets `contents`.
                     contents=history,
+                    # AUTO: Sets `config`.
                     config=genai.types.GenerateContentConfig(
+                        # AUTO: Sets `system_instruction`.
                         system_instruction=GAL_SYSTEM_PROMPT,
+                        # AUTO: Sets `temperature`.
                         temperature=0.3,
+                        # AUTO: Sets `max_output_tokens`.
                         max_output_tokens=4096,
+                    # AUTO: Closes the current grouped code/data.
                     ),
+                # AUTO: Closes the current grouped code/data.
                 )
+                # AUTO: Stops the nearest loop.
                 break
+            # AUTO: Handles the matching error case.
             except Exception as model_err:
+                # AUTO: Sets `last_error`.
                 last_error = model_err
+                # AUTO: Sets `err_msg`.
                 err_msg = str(model_err)
+                # AUTO: Checks this condition.
                 if '429' not in err_msg and 'RESOURCE_EXHAUSTED' not in err_msg and '503' not in err_msg and 'UNAVAILABLE' not in err_msg and '403' not in err_msg and 'PERMISSION_DENIED' not in err_msg:
+                    # AUTO: Executes this statement.
                     raise
+                # AUTO: Skips to the next loop iteration.
                 continue
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Stops this flow by raising an error.
             raise last_error
 
+        # AUTO: Sets `reply`.
         reply = response.text or 'No response generated.'
 
+        # AUTO: Appends a value to a list.
         history.append({'role': 'model', 'parts': [{'text': reply}]})
 
+        # AUTO: Returns this result to the caller.
         return jsonify({'reply': reply, 'mode': 'ai'})
 
+    # AUTO: Handles the matching error case.
     except Exception as e:
+        # AUTO: Starts protected code that can catch errors.
         try:
+            # AUTO: Sets `fb_reply`.
             fb_reply = fallback_reply(user_message)
+            # AUTO: Returns this result to the caller.
             return jsonify({'reply': fb_reply, 'mode': 'fallback'})
+        # AUTO: Handles the matching error case.
         except Exception:
+            # AUTO: Does nothing for this required block.
             pass
+        # AUTO: Sets `err_str`.
         err_str = str(e)
+        # AUTO: Returns this result to the caller.
         return jsonify({'error': f'Chat error: {err_str}'}), 500
 
+# AUTO: Attaches this decorator to the next function/class.
 @app.route('/api/chat/clear', methods=['POST'])
+# AUTO: Defines function `chat_clear_endpoint`.
 def chat_clear_endpoint():
+    # AUTO: Sets `data`.
     data = request.get_json() or {}
+    # AUTO: Sets `session_id`.
     session_id = data.get('session_id', 'default')
+    # AUTO: Removes and returns an item.
     _chat_sessions.pop(session_id, None)
+    # AUTO: Returns this result to the caller.
     return jsonify({'success': True})
 
 
+# AUTO: Checks this condition.
 if __name__ == '__main__':
+    # AUTO: Sets `port`.
     port = int(os.environ.get('PORT', 5000))
+    # AUTO: Executes this statement.
     debug = os.environ.get('DEBUG', 'False') == 'True'
 
+    # AUTO: Calls `print`.
     print("Starting GAL Compiler Server...")
+    # AUTO: Calls `print`.
     print(f"Server running at http://0.0.0.0:{port}")
+    # AUTO: Calls `print`.
     print("API endpoints:")
+    # AUTO: Calls `print`.
     print(f"  - POST http://localhost:{port}/api/lex (Lexical Analysis)")
+    # AUTO: Calls `print`.
     print(f"  - POST http://localhost:{port}/api/parse (Syntax Analysis)")
+    # AUTO: Calls `print`.
     print(f"  - POST http://localhost:{port}/api/semantic (Semantic Analysis)")
+    # AUTO: Calls `print`.
     print(f"  - POST http://localhost:{port}/api/icg (Intermediate Code Generation)")
+    # AUTO: Calls `print`.
     print(f"  - POST http://localhost:{port}/api/chat (AI Chat Helper)")
+    # AUTO: Calls `print`.
     print(f"  - Socket.IO: run_code (Execute Program)")
+    # AUTO: Sets `socketio.run(app, host`.
     socketio.run(app, host='0.0.0.0', port=port, debug=debug, allow_unsafe_werkzeug=True)

Backend/shared/__init__.py

@@ -1,4 +1,7 @@
 
+# AUTO: Imports names from another module.
 from .tokens import *  # noqa: F401,F403 - TT_* constants
+# AUTO: Imports names from another module.
 from .tokens import Token, get_token_description  # noqa: F401
+# AUTO: Imports names from another module.
 from .ast_nodes import *  # noqa: F401,F403

Backend/shared/ast_nodes.py

@@ -1,204 +1,376 @@
 
+"""AST node classes shared by the parser, semantic validator, and interpreter.
 
+Each class represents one language construct after parsing, for example a
+VariableDeclarationNode, BinaryOpNode, FunctionCallNode, or WhileLoopNode.
+"""
+
+
+# AUTO: Defines class `ASTNode`.
 class ASTNode:
+    # AUTO: Defines function `__init__`.
     def __init__(self, node_type, value=None, line=None):
+        # LINE: node_type tells semantic/interpreter what this AST node represents.
         self.node_type = node_type
+        # LINE: value stores the node's main text/value, like an operator or name.
         self.value = value
+        # LINE: children stores nested AST nodes under this node.
         self.children = []
+        # LINE: parent points back to the surrounding AST node.
         self.parent = None
+        # LINE: line stores the original source line for error messages.
         self.line = line
 
+    # AUTO: Defines function `add_child`.
     def add_child(self, child):
+        # GUIDE: Parent links let later stages know the surrounding construct,
+        # for example water() can see whether it belongs to an assignment.
+        # AUTO: Sets `child.parent`.
         child.parent = self
+        # AUTO: Appends a value to a list.
         self.children.append(child)
 
+    # AUTO: Defines function `print_tree`.
     def print_tree(self, level=0):
+        # AUTO: Sets `indent`.
         indent = ' ' * (level * 3)
+        # AUTO: Calls `print`.
         print(f"{indent}╚═{self.node_type}: {self.value if self.value else ''}")
+        # AUTO: Starts a loop over these values.
         for child in self.children:
+            # AUTO: Calls `child.print_tree`.
             child.print_tree(level + 1)
         
 
+# AUTO: Defines class `ProgramNode`.
 class ProgramNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, line=None):
+        # LINE: ProgramNode is the root container for the whole AST.
         super().__init__("Program", line=line)
 
+# AUTO: Defines class `VariableDeclarationNode`.
 class VariableDeclarationNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, var_type, var_name, value=None, line=None):
+        # LINE: VariableDeclaration represents code like seed x = 10;
         super().__init__("VariableDeclaration", line=line)
+        # LINE: First child stores declared type.
         self.add_child(ASTNode("Type", var_type, line=line))
+        # LINE: Second child stores variable name.
         self.add_child(ASTNode("Identifier", var_name, line=line))
+        # AUTO: Checks this condition.
         if value:
+            # LINE: Optional third child stores initializer expression.
             self.add_child(value)
 
+# AUTO: Defines class `AssignmentNode`.
 class AssignmentNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, target, value, line=None):
+        # LINE: Assignment represents code like x = y + 1;
         super().__init__("Assignment", line=line)
+        # AUTO: Checks this condition.
         if isinstance(target, str):
+            # LINE: Simple target names are wrapped as Identifier nodes.
             self.add_child(ASTNode("Identifier", target, line=line))
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # LINE: Complex targets are already AST nodes, like array/member access.
             self.add_child(target)
+        # LINE: Second child stores the RHS expression/value.
         self.add_child(value)
         
 
+# AUTO: Defines class `BinaryOpNode`.
 class BinaryOpNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, left, operator, right, line=None):
+        # LINE: BinaryOp stores operator in value with left/right children.
         super().__init__("BinaryOp", operator, line=line)
+        # AUTO: Calls `self.add_child`.
         self.add_child(left)
+        # AUTO: Calls `self.add_child`.
         self.add_child(right)
 
+# AUTO: Defines class `FunctionDeclarationNode`.
 class FunctionDeclarationNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, return_type, name, params, line=None):
+        # LINE: FunctionDeclaration stores function name in value.
         super().__init__("FunctionDeclaration", name, line=line)
+        # LINE: First child stores return type.
         self.add_child(ASTNode("ReturnType", return_type, line=line))
+        # LINE: Second child stores parameters.
         self.add_child(params)
 
+# AUTO: Defines class `FunctionCallNode`.
 class FunctionCallNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, name, args, line=None):
+        # LINE: FunctionCall stores called function name in value.
         super().__init__("FunctionCall", name, line=line)
+        # LINE: Each argument becomes a child.
         for arg in args:
+            # AUTO: Calls `self.add_child`.
             self.add_child(arg)
 
+# AUTO: Defines class `IfStatementNode`.
 class IfStatementNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, condition, line=None):
+        # AUTO: Sets `super().__init__("IfStatement", line`.
         super().__init__("IfStatement", line=line)
+        # AUTO: Calls `self.add_child`.
         self.add_child(condition)
 
+# AUTO: Defines class `ForLoopNode`.
 class ForLoopNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, initialization, condition, update, line=None):
+        # AUTO: Sets `super().__init__("ForLoop", line`.
         super().__init__("ForLoop", line=line)  
+        # AUTO: Calls `self.add_child`.
         self.add_child(initialization)
+        # AUTO: Calls `self.add_child`.
         self.add_child(condition)
+        # AUTO: Calls `self.add_child`.
         self.add_child(update)
 
+# AUTO: Defines class `WhileLoopNode`.
 class WhileLoopNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, condition, line=None):
+        # AUTO: Sets `super().__init__("WhileLoop", line`.
         super().__init__("WhileLoop", line=line)  
+        # AUTO: Calls `self.add_child`.
         self.add_child(condition)
 
+# AUTO: Defines class `DoWhileLoopNode`.
 class DoWhileLoopNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, condition, line=None):
+        # AUTO: Sets `super().__init__("DoWhileLoop", line`.
         super().__init__("DoWhileLoop", line=line)
 
+# AUTO: Defines class `PrintNode`.
 class PrintNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, args, line=None):
+        # AUTO: Sets `super().__init__("PrintStatement", line`.
         super().__init__("PrintStatement", line=line) 
+        # AUTO: Starts a loop over these values.
         for arg in args:
+            # AUTO: Calls `self.add_child`.
             self.add_child(arg)
 
+# AUTO: Defines class `UnaryOpNode`.
 class UnaryOpNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, operator, operand, position="pre", line=None):
+        # AUTO: Sets `super().__init__("UnaryOp", operator, line`.
         super().__init__("UnaryOp", operator, line=line)
+        # AUTO: Sets `self.position`.
         self.position = position
+        # AUTO: Calls `self.add_child`.
         self.add_child(operand)
 
+# AUTO: Defines class `FertileDeclarationNode`.
 class FertileDeclarationNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, var_type, var_name, value, line=None):
+        # AUTO: Sets `super().__init__("SturdyDeclaration", line`.
         super().__init__("SturdyDeclaration", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("Type", var_type, line`.
         self.add_child(ASTNode("Type", var_type, line=line))
+        # AUTO: Sets `self.add_child(ASTNode("Identifier", var_name, line`.
         self.add_child(ASTNode("Identifier", var_name, line=line))
+        # AUTO: Calls `self.add_child`.
         self.add_child(value)
 
+# AUTO: Defines class `ReturnNode`.
 class ReturnNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, return_value=None, line=None):
+        # AUTO: Sets `super().__init__("Return", line`.
         super().__init__("Return", line=line)
+        # AUTO: Checks this condition.
         if return_value:
+            # AUTO: Calls `self.add_child`.
             self.add_child(return_value)
 
+# AUTO: Defines class `UpdateNode`.
 class UpdateNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, operator, operand, prefix = True, line=None):
+        # AUTO: Sets `super().__init__("Update", line`.
         super().__init__("Update", line=line)
+        # AUTO: Sets `self.prefix`.
         self.prefix = prefix
+        # AUTO: Calls `self.add_child`.
         self.add_child(operand)
+        # AUTO: Calls `self.add_child`.
         self.add_child(operator)
 
+# AUTO: Defines class `SwitchNode`.
 class SwitchNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, expression, cases, default_case, line=None):
+        # AUTO: Sets `super().__init__("Switch", line`.
         super().__init__("Switch", line=line)
+        # AUTO: Calls `self.add_child`.
         self.add_child(expression)
+        # AUTO: Starts a loop over these values.
         for case in cases:
+            # AUTO: Calls `self.add_child`.
             self.add_child(case)
+        # AUTO: Checks this condition.
         if default_case is not None:
+            # AUTO: Calls `self.add_child`.
             self.add_child(default_case)
 
+# AUTO: Defines class `ContinueNode`.
 class ContinueNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, line=None):
+        # AUTO: Sets `super().__init__("Continue", line`.
         super().__init__("Continue", line=line)
 
+# AUTO: Defines class `BreakNode`.
 class BreakNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, line=None):
+        # AUTO: Sets `super().__init__("Break", line`.
         super().__init__("Break", line=line)
 
+# AUTO: Defines class `ListNode`.
 class ListNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, line=None, elements=None):
+        # AUTO: Sets `super().__init__("List", line`.
         super().__init__("List", line=line)
+        # AUTO: Sets `self.elements`.
         self.elements = elements or []
+        # AUTO: Starts a loop over these values.
         for element in self.elements:
+            # AUTO: Calls `self.add_child`.
             self.add_child(element)
 
+# AUTO: Defines class `SoilNode`.
 class SoilNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, variable_name, line=None):
+        # AUTO: Sets `super().__init__("SoilFunction", line`.
         super().__init__("SoilFunction", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("Identifier", variable_name, line`.
         self.add_child(ASTNode("Identifier", variable_name, line=line))
 
+# AUTO: Defines class `BloomNode`.
 class BloomNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, variable_name, line=None):
+        # AUTO: Sets `super().__init__("BloomFunction", line`.
         super().__init__("BloomFunction", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("Identifier", variable_name, line`.
         self.add_child(ASTNode("Identifier", variable_name, line=line))
 
+# AUTO: Defines class `AppendNode`.
 class AppendNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, elements, line=None):
+        # AUTO: Sets `super().__init__("Append", line`.
         super().__init__("Append", line=line)
+        # AUTO: Starts a loop over these values.
         for elem in elements:
+            # AUTO: Calls `self.add_child`.
             self.add_child(elem)
 
+# AUTO: Defines class `InsertNode`.
 class InsertNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, index, elements, line=None):
+        # AUTO: Sets `super().__init__("Insert", line`.
         super().__init__("Insert", line=line)
+        # AUTO: Calls `self.add_child`.
         self.add_child(index)
+        # AUTO: Starts a loop over these values.
         for elem in elements:
+            # AUTO: Calls `self.add_child`.
             self.add_child(elem)
 
+# AUTO: Defines class `RemoveNode`.
 class RemoveNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, value, index, line=None):
+        # AUTO: Sets `super().__init__("Remove", line`.
         super().__init__("Remove", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("Identifier", value, line`.
         self.add_child(ASTNode("Identifier", value, line=line))
+        # AUTO: Calls `self.add_child`.
         self.add_child(index)
 
+# AUTO: Defines class `CastNode`.
 class CastNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, target_type, expression, line=None):
+        # AUTO: Sets `super().__init__("TypeCast", line`.
         super().__init__("TypeCast", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("TargetType", target_type, line`.
         self.add_child(ASTNode("TargetType", target_type, line=line))
+        # AUTO: Calls `self.add_child`.
         self.add_child(expression)
 
 
+# AUTO: Defines class `ListAccessNode`.
 class ListAccessNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, list_name, index_expr, line=None):
+        # AUTO: Sets `super().__init__("ListAccess", line`.
         super().__init__("ListAccess", line=line)
+        # AUTO: Sets `self.add_child(ASTNode("ListName", list_name, line`.
         self.add_child(ASTNode("ListName", list_name, line=line))
+        # AUTO: Calls `self.add_child`.
         self.add_child(index_expr)
 
 
+# AUTO: Defines class `MemberAccessNode`.
 class MemberAccessNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, object_name, member_name, line=None):
+        # AUTO: Sets `super().__init__("MemberAccess", line`.
         super().__init__("MemberAccess", line=line)
+        # AUTO: Checks this condition.
         if isinstance(object_name, ASTNode):
+            # AUTO: Calls `self.add_child`.
             self.add_child(object_name)
+        # AUTO: Runs when previous condition did not pass.
         else:
+            # AUTO: Sets `self.add_child(ASTNode("Object", object_name, line`.
             self.add_child(ASTNode("Object", object_name, line=line))
+        # AUTO: Sets `self.add_child(ASTNode("Member", member_name, line`.
         self.add_child(ASTNode("Member", member_name, line=line))
 
 
+# AUTO: Defines class `ArrayMemberAccessNode`.
 class ArrayMemberAccessNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, list_access_node, member_name, line=None):
+        # AUTO: Sets `super().__init__("ArrayMemberAccess", line`.
         super().__init__("ArrayMemberAccess", line=line)
+        # AUTO: Calls `self.add_child`.
         self.add_child(list_access_node)
+        # AUTO: Sets `self.add_child(ASTNode("Member", member_name, line`.
         self.add_child(ASTNode("Member", member_name, line=line))
 
 
+# AUTO: Defines class `BundleDefinitionNode`.
 class BundleDefinitionNode(ASTNode):
+    # AUTO: Defines function `__init__`.
     def __init__(self, bundle_name, members, line=None):
+        # AUTO: Sets `super().__init__("BundleDefinition", line`.
         super().__init__("BundleDefinition", line=line)
+        # AUTO: Sets `self.bundle_name`.
         self.bundle_name = bundle_name
+        # AUTO: Sets `self.members`.
         self.members = members
 

Backend/shared/tokens.py

@@ -1,208 +1,376 @@
 
+"""Token constants and Token class used by every compiler stage.
+
+The lexer creates Token(type, value, line, col). The parser and later stages
+mostly compare token.type values against these constants.
+"""
+
 
 # --- Reserved Words (Keywords) ---
+# AUTO: Sets `TT_RW_WATER`.
 TT_RW_WATER       = 'water'     # Input function - reads user input
+# AUTO: Sets `TT_RW_PLANT`.
 TT_RW_PLANT       = 'plant'     # Output function - prints to console
+# AUTO: Sets `TT_RW_SEED`.
 TT_RW_SEED        = 'seed'      # Data Type - integer (int)
+# AUTO: Sets `TT_RW_LEAF`.
 TT_RW_LEAF        = 'leaf'      # Data Type - character (char)
+# AUTO: Sets `TT_RW_BRANCH`.
 TT_RW_BRANCH      = 'branch'    # Data Type - boolean (true/false)
+# AUTO: Sets `TT_RW_TREE`.
 TT_RW_TREE        = 'tree'      # Data Type - double/float
+# AUTO: Sets `TT_RW_SPRING`.
 TT_RW_SPRING      = 'spring'    # Conditional statement - if
+# AUTO: Sets `TT_RW_WITHER`.
 TT_RW_WITHER      = 'wither'    # Conditional statement - else
+# AUTO: Sets `TT_RW_BUD`.
 TT_RW_BUD         = 'bud'       # Conditional statement - else-if
+# AUTO: Sets `TT_RW_HARVEST`.
 TT_RW_HARVEST     = 'harvest'   # Switch statement
+# AUTO: Sets `TT_RW_GROW`.
 TT_RW_GROW        = 'grow'      # Loop - while
+# AUTO: Sets `TT_RW_CULTIVATE`.
 TT_RW_CULTIVATE   = 'cultivate' # Loop - for
+# AUTO: Sets `TT_RW_TEND`.
 TT_RW_TEND        = 'tend'      # Loop - do-while
+# AUTO: Sets `TT_RW_EMPTY`.
 TT_RW_EMPTY       = 'empty'     # Void return type
+# AUTO: Sets `TT_RW_PRUNE`.
 TT_RW_PRUNE       = 'prune'     # Break statement - exit loop
+# AUTO: Sets `TT_RW_SKIP`.
 TT_RW_SKIP        = 'skip'      # Continue statement - skip to next iteration
+# AUTO: Sets `TT_RW_RECLAIM`.
 TT_RW_RECLAIM     = 'reclaim'   # Return statement - return from function
+# AUTO: Sets `TT_RW_ROOT`.
 TT_RW_ROOT        = 'root'      # Main function entry point
+# AUTO: Sets `TT_RW_POLLINATE`.
 TT_RW_POLLINATE   = 'pollinate' # Function declaration
+# AUTO: Sets `TT_RW_VARIETY`.
 TT_RW_VARIETY     = 'variety'   # Case label in switch statement
+# AUTO: Sets `TT_RW_FERTILE`.
 TT_RW_FERTILE     = 'fertile'   # Constant declaration
+# AUTO: Sets `TT_RW_SOIL`.
 TT_RW_SOIL        = 'soil'      # Default case in switch statement
+# AUTO: Sets `TT_RW_BUNDLE`.
 TT_RW_BUNDLE      = 'bundle'    # Struct definition
+# AUTO: Sets `TT_RW_VINE`.
 TT_RW_VINE        = 'vine'      # String data type
 
 # --- Operators & Symbols ---
+# AUTO: Sets `TT_IDENTIFIER`.
 TT_IDENTIFIER = 'id'        # Variable/function names (e.g., myVar, calcTotal)
+# AUTO: Sets `TT_PLUS`.
 TT_PLUS = '+'               # Addition operator
+# AUTO: Sets `TT_MINUS`.
 TT_MINUS = '-'              # Subtraction operator
+# AUTO: Sets `TT_MUL`.
 TT_MUL = '*'                # Multiplication operator
+# AUTO: Sets `TT_DIV`.
 TT_DIV = '/'                # Division operator
+# AUTO: Sets `TT_MOD`.
 TT_MOD = '%'                # Modulo operator (remainder)
+# AUTO: Sets `TT_EXP`.
 TT_EXP = '**'               # Exponentiation operator (power)
+# AUTO: Sets `TT_EQ`.
 TT_EQ = '='                 # Assignment operator
+# AUTO: Executes this statement.
 TT_EQTO = '=='              # Equality comparison operator
+# AUTO: Adds into `TT_PLUSEQ = '`.
 TT_PLUSEQ = '+='            # Add and assign operator
+# AUTO: Subtracts from `TT_MINUSEQ = '`.
 TT_MINUSEQ = '-='           # Subtract and assign operator
+# AUTO: Multiplies into `TT_MULTIEQ = '`.
 TT_MULTIEQ = '*='           # Multiply and assign operator
+# AUTO: Divides into `TT_DIVEQ = '`.
 TT_DIVEQ = '/='             # Divide and assign operator
+# AUTO: Sets `TT_MODEQ`.
 TT_MODEQ = '%='             # Modulo and assign operator
+# AUTO: Multiplies into `TT_EXPEQ = '*`.
 TT_EXPEQ = '**='            # Exponent and assign operator (x **= 2 → x = x ** 2)
+# AUTO: Sets `TT_CONCAT`.
 TT_CONCAT = '`'             # String concatenation operator
+# AUTO: Sets `TT_LPAREN`.
 TT_LPAREN = '('             # Left parenthesis
+# AUTO: Sets `TT_RPAREN`.
 TT_RPAREN = ')'             # Right parenthesis
+# AUTO: Sets `TT_SEMICOLON`.
 TT_SEMICOLON = ';'          # Statement terminator
+# AUTO: Sets `TT_COMMA`.
 TT_COMMA = ','              # Separator (function args, array elements)
+# AUTO: Sets `TT_COLON`.
 TT_COLON = ':'              # Colon (used in switch cases)
+# AUTO: Sets `TT_BLOCK_START`.
 TT_BLOCK_START = '{'        # Block start (scope begin)
+# AUTO: Sets `TT_BLOCK_END`.
 TT_BLOCK_END = '}'          # Block end (scope close)
+# AUTO: Sets `TT_LT`.
 TT_LT = '<'                 # Less than comparison
+# AUTO: Sets `TT_GT`.
 TT_GT = '>'                 # Greater than comparison
+# AUTO: Executes this statement.
 TT_LTEQ = '<='              # Less than or equal comparison
+# AUTO: Executes this statement.
 TT_GTEQ = '>='              # Greater than or equal comparison
+# AUTO: Executes this statement.
 TT_NOTEQ = '!='             # Not equal comparison
+# AUTO: Sets `TT_EOF`.
 TT_EOF = 'EOF'                  # End of file marker
+# AUTO: Sets `TT_AND`.
 TT_AND = '&&'                   # Logical AND operator
+# AUTO: Sets `TT_OR`.
 TT_OR = '||'                    # Logical OR operator
+# AUTO: Sets `TT_SINGLE_AND`.
 TT_SINGLE_AND = '&'             # Invalid single ampersand
+# AUTO: Sets `TT_SINGLE_OR`.
 TT_SINGLE_OR = '|'              # Invalid single pipe
+# AUTO: Sets `TT_NOT`.
 TT_NOT = '!'                    # Logical NOT operator
+# AUTO: Sets `TT_INCREMENT`.
 TT_INCREMENT = '++'             # Increment operator (e.g., x++)
+# AUTO: Sets `TT_DECREMENT`.
 TT_DECREMENT = '--'             # Decrement operator (e.g., x--)
+# AUTO: Sets `TT_LSQBR`.
 TT_LSQBR = '['                  # Left square bracket (array indexing)
+# AUTO: Sets `TT_RSQBR`.
 TT_RSQBR = ']'                  # Right square bracket
+# AUTO: Sets `TT_NEGATIVE`.
 TT_NEGATIVE = '~'               # Unary negation operator
+# AUTO: Sets `TT_MEMBER`.
 TT_MEMBER = 'member'            # Member token for struct access
+# AUTO: Sets `TT_INTEGERLIT`.
 TT_INTEGERLIT = 'intlit'        # Integer literal token (e.g., 42, 100)
+# AUTO: Sets `TT_DOUBLELIT`.
 TT_DOUBLELIT = 'dblit'         # Double/float literal token (e.g., 3.14, 2.5)
+# AUTO: Sets `TT_STRINGLIT`.
 TT_STRINGLIT = 'stringlit'      # String literal token (e.g., "hello")
+# AUTO: Sets `TT_CHARLIT`.
 TT_CHARLIT = 'chrlit'           # Character literal token (e.g., 'a')
+# AUTO: Sets `TT_BOOLLIT_TRUE`.
 TT_BOOLLIT_TRUE = 'sunshine'    # Boolean true literal
+# AUTO: Sets `TT_BOOLLIT_FALSE`.
 TT_BOOLLIT_FALSE = 'frost'      # Boolean false literal
+# AUTO: Sets `TT_STRCTACCESS`.
 TT_STRCTACCESS = '.'            # Struct member access operator
+# AUTO: Sets `TT_NL`.
 TT_NL = '\n'                    # Newline token
+# AUTO: Sets `TT_DOT`.
 TT_DOT = '.'                    # Dot operator (struct access)
+# AUTO: Sets `TT_COMMENT`.
 TT_COMMENT = 'comment'          # Single-line comment (//...)
+# AUTO: Sets `TT_MCOMMENT`.
 TT_MCOMMENT = 'mcommentlit'     # Multi-line comment (/*...*/)
 
 
 # ============================================================================
 # TOKEN CLASS - Represents a single token (lexeme)
 # ============================================================================
+# AUTO: Defines class `Token`.
 class Token:
     """Represents a token with type, value, line number, and column number"""
 
+    # AUTO: Defines function `__init__`.
     def __init__(self, type_, value=None, line=1, col=0):
+        # LINE: token type is what parser compares, like id/intlit/seed.
         self.type = type_    # Token type (e.g., TT_IDENTIFIER, TT_INTEGERLIT)
+        # LINE: token value is the actual lexeme text, like x or 10.
         self.value = value   # Token text/value (e.g., "myVar", "42")
+        # LINE: line records where the token starts in source code.
         self.line = line     # Line number where token appears
+        # LINE: col records the starting column for error messages.
         self.col = col       # Column number where token starts (0-based)
 
 
 # ============================================================================
 # TOKEN TYPE DESCRIPTIONS - Maps token types to human-readable descriptions
 # ============================================================================
+# AUTO: Defines function `get_token_description`.
 def get_token_description(token_type: str, value: str = '') -> str:
     """Returns a descriptive name for each token type"""
     # Handle negative literals: value starts with ~ but token type is intlit/dbllit
+    # LINE: Special description for negative integer literals.
     if token_type == 'intlit' and isinstance(value, str) and value.startswith('~'):
+        # AUTO: Returns this result to the caller.
         return 'negative integer'
+    # LINE: Special description for negative double literals.
     if token_type == 'dblit' and isinstance(value, str) and value.startswith('~'):
+        # AUTO: Returns this result to the caller.
         return 'negative float'
 
+    # LINE: Map token types to human-readable lexeme table labels.
     descriptions = {
         # Reserved Words - I/O
+        # AUTO: Executes this statement.
         'water': 'Input Function',
+        # AUTO: Executes this statement.
         'plant': 'Output Function',
 
         # Reserved Words - Data Types
+        # AUTO: Executes this statement.
         'seed': 'Integer Type',
+        # AUTO: Executes this statement.
         'leaf': 'Character Type',
+        # AUTO: Executes this statement.
         'branch': 't/f',
+        # AUTO: Executes this statement.
         'tree': 'Float Type',
+        # AUTO: Executes this statement.
         'vine': 'String Type',
+        # AUTO: Executes this statement.
         'empty': 'Void Type',
 
         # Reserved Words - Control Flow
+        # AUTO: Executes this statement.
         'spring': 'If Statement',
+        # AUTO: Executes this statement.
         'wither': 'Else Statement',
+        # AUTO: Executes this statement.
         'bud': 'Else-If Statement',
+        # AUTO: Executes this statement.
         'harvest': 'Switch Statement',
+        # AUTO: Executes this statement.
         'variety': 'Case Label',
+        # AUTO: Executes this statement.
         'soil': 'Default Case',
 
         # Reserved Words - Loops
+        # AUTO: Executes this statement.
         'grow': 'While Loop',
+        # AUTO: Executes this statement.
         'cultivate': 'For Loop',
+        # AUTO: Executes this statement.
         'tend': 'Do-While Loop',
+        # AUTO: Executes this statement.
         'prune': 'Break Statement',
+        # AUTO: Executes this statement.
         'skip': 'Continue Statement',
 
         # Reserved Words - Functions
+        # AUTO: Executes this statement.
         'root': 'Main Function',
+        # AUTO: Executes this statement.
         'pollinate': 'Function Declaration',
+        # AUTO: Executes this statement.
         'reclaim': 'Return Statement',
 
         # Reserved Words - Other
+        # AUTO: Executes this statement.
         'fertile': 'Constant Declaration',
+        # AUTO: Executes this statement.
         'bundle': 'Struct Definition',
 
         # Identifiers and Literals
+        # AUTO: Executes this statement.
         'id': 'Identifier',
+        # AUTO: Executes this statement.
         'intlit': 'Integer Literal',
+        # AUTO: Executes this statement.
         'dblit': 'double Literal',
+        # AUTO: Executes this statement.
         'stringlit': 'string',
+        # AUTO: Executes this statement.
         'chrlit': 'Character',
+        # AUTO: Executes this statement.
         'sunshine': 'Boolean True',
+        # AUTO: Executes this statement.
         'frost': 'Boolean False',
 
         # Arithmetic Operators
+        # AUTO: Executes this statement.
         '+': 'Plus Operator',
+        # AUTO: Executes this statement.
         '-': 'Minus Operator',
+        # AUTO: Executes this statement.
         '*': 'Multiply Operator',
+        # AUTO: Executes this statement.
         '/': 'Divide Operator',
+        # AUTO: Executes this statement.
         '%': 'Modulo Operator',
+        # AUTO: Executes this statement.
         '**': 'Power Operator',
+        # AUTO: Executes this statement.
         '~': 'Negate Operator',
+        # AUTO: Executes this statement.
         '++': 'Increment Operator',
+        # AUTO: Executes this statement.
         '--': 'Decrement Operator',
 
         # Assignment Operators
+        # AUTO: Sets `'`.
         '=': 'Assign Operator',
+        # AUTO: Adds into `'`.
         '+=': 'Add-Assign Operator',
+        # AUTO: Subtracts from `'`.
         '-=': 'Sub-Assign Operator',
+        # AUTO: Multiplies into `'`.
         '*=': 'Mul-Assign Operator',
+        # AUTO: Divides into `'`.
         '/=': 'Div-Assign Operator',
+        # AUTO: Sets `'%`.
         '%=': 'Mod-Assign Operator',
 
         # Comparison Operators
+        # AUTO: Executes this statement.
         '==': 'Equal Operator',
+        # AUTO: Executes this statement.
         '!=': 'Not-Equal Operator',
+        # AUTO: Executes this statement.
         '<': 'Less-Than Operator',
+        # AUTO: Executes this statement.
         '>': 'Greater-Than Operator',
+        # AUTO: Executes this statement.
         '<=': 'Less-Equal Operator',
+        # AUTO: Executes this statement.
         '>=': 'Greater-Equal Operator',
 
         # Logical Operators
+        # AUTO: Executes this statement.
         '&&': 'AND Operator',
+        # AUTO: Executes this statement.
         '&': 'Invalid Single-Ampersand',
+        # AUTO: Executes this statement.
         '||': 'OR Operator',
+        # AUTO: Executes this statement.
         '|': 'Invalid Single-Pipe',
+        # AUTO: Executes this statement.
         '!': 'NOT Operator',
 
         # Delimiters and Punctuation
+        # AUTO: Executes this statement.
         '(': 'Left Parenthesis',
+        # AUTO: Executes this statement.
         ')': 'Right Parenthesis',
+        # AUTO: Executes this statement.
         '{': 'Left Brace',
+        # AUTO: Executes this statement.
         '}': 'Right Brace',
+        # AUTO: Executes this statement.
         '[': 'Left Bracket',
+        # AUTO: Executes this statement.
         ']': 'Right Bracket',
+        # AUTO: Executes this statement.
         ';': 'Semicolon',
+        # AUTO: Executes this statement.
         ',': 'Comma',
+        # AUTO: Executes this statement.
         ':': 'Colon',
+        # AUTO: Executes this statement.
         '.': 'Dot Operator',
+        # AUTO: Executes this statement.
         '`': 'Concatenation Operator',
 
         # Special
+        # AUTO: Executes this statement.
         'member': 'Struct Member',
+        # AUTO: Executes this statement.
         'EOF': 'End of File',
+        # AUTO: Executes this statement.
         '\n': 'Newline',
+        # AUTO: Executes this statement.
         'comment': 'comment',
+        # AUTO: Executes this statement.
         'mcommentlit': 'multicomment',
+    # AUTO: Closes the current grouped code/data.
     }
 
+    # AUTO: Returns this result to the caller.
     return descriptions.get(token_type, 'Unknown Token')