Parsing:
- context handling
  - prototypes
  - splice/substr/lvalue subroutines
- filetest
  - after filetest, foo and _ are not barewords
- stash access through hash syntax
- glob access through hash syntax
- global variables/symbols (STDOUT!)
- scoping (check if/while conditions, for loop headers, etc.)
- do ...
- attributes
- formats
- add operator descriptor and do parse tree modifications based on that
  - like: defined &foo; pipe X, Y; etc.
- indirect method calls
  - find more corner cases
- list slices ( ... )[ ... ]
- test all unary/binary operator
- subroutine prototypes
  - declaration
  - parsing
    - & as first parameter permits either:
      mymap { ... } 1, 2, 3
      mymap sub { ... }, 1, 2, 3
      myeval { ... }, 1 == myeval( sub { ... } ), 1
- local()/my()
  - check invalid declarations
  - check non-lvaluable expressions
- implicit $_ in various builtins
- handling of parse errors with recovery
- lexical pragmas/hints
  - strictures
- proper lexing of ${  id # comment\n } vs. ${ id # comment \n expr }
- more tests for ${foo[.......} crazy cases
- proper check for overridable builtins (only if imported)
- builtins overridable using CORE::GLOBAL
- CORE::builtin to always call builtin
- special treatment for glob()
- simplify detection of <foo> vs. <foo >, avoid constructing a lexer
- packages
  - package handling in our()
- parsing of nullary/unary vs. list operators
- => auto-quoting
  - => quoting of -foo => 1
- quoted strings
  - \Q\L\U\E in quoted strings/patterns
  - \xaf, \011,etc when lexing quoted strings
- regexp
  - char classes
    - [a-\w] is not a range
    - [a-] is not a range
    - [[] is a "["
    - ^ negation
  - other metacharacters
  - backreferences, also in substitution
  - magic variables
  - (?...) syntax and grouping
  - empty pattern
  - flags
  - context-dependent bexaviour
  - always a pattern after =~/!~
  - tr/// lexing/parsing
- correct parsing of heredoc in substitutions (s//<<HEREDOC/e)
- construct flow graph (or similar structure)

Runtime:
- integer -> float on overflow (also in parsing!)
- proper scalar polimorphing
  - mixed-mode arithmetic
- proper handling of function return values
  - implicit return
  - context
- encapsulate lexical lookup/closure, for eval ""
- better handling of sub calls
  - encapsulate enter/leave
- proper morphing on scalar assignment
- autovivification
- create common superclass for reference/scalar
- multiple dispatch operators
- array/list/hash assignment
  - optimize lists with common assignments
  - check mixed assignments
- garbage collection and/or reference counting
- do file/require/use/eval string
- stack unwinding
  - eval/die
  - nonlocal redo/last/next/goto
- computed goto/next/last/redo
- local()
  - check code generation for all block types and
    different cases for local() in conditions or in loop/conditional/continue
    blocks
  - local() ends at end of file
  - localization of array, hash, glob, array/hash element
  - check that when localizing a variable, it is always
    a global/package variable
  - magical/tied variables (probably add a localize() method to all types)
  - localization of complex expressions (?:, lists, ...)
  - integrate in stack unwinding
- my()
  - check code generation for all block types and
    different cases for my() in conditions or in loop/conditional/continue
    blocks
  - my() at global scope does not end at end of file
  - code generation for return/die/last/redo/next, ...
  - test global my() vs. local my(), lexical arrays, hashes
  - integrate in stack unwinding
- objects, tie, overload

Refactoring:
- check offsets for call sequence, refactor stack handling
- remove all globals from Toy code generator
- replace all strings with integer constants/flags
  - move information about bultins/overridables to a separate module
    (currently in both lexer and parse-tree)
- rewrite lexer to use /\G.../g instead of s///
  - assert unlexed tokens are relexed with the correct expectations
  - assert lex_string/lex unlex buffers do not intermingle
- make regexp parser a full blown parser, not the hack it is;
  maybe add a lexer subclass for parsing patterns
- detect builtins that could have an indirect object as first argument
  earlier in the parsing
- add structure to contain actions to be performed at block end,
  and can generate code for them
- make the top level of a file/string/... a new parse tree node
  (or a special type of block)