* We now trace variables in trace collection as a dictionary
per variable with a dictionary of the versions, this is
closer to out frequent usage per variable.
* That makes it a lot easier to update variables after the
tracing is finished to know their users and writers.
* Requires a lot less work, but also makes work less memory
local such that the performance gain is relatively small
despite less work being done.
* Also avoids that a set for the users is to be maintained.
* The numbering of function causes issues when code
is used from cache, because then unused helpers
never come to exist.
* This avoids a re-compilation for some modules the
second time around a compilation happens and not
all complex helpers are added at all.
could hang
* The locals could refer to the wrong scope if it is not attached at
creation time, which it now is.
* To get to the optimization, variable references for builtin names
have the scope attached just in case they later use it, this has
a dedicated node to save the attribute for the general case.
* Also for Optimization, prepare inlining of helper function bodies,
with local scopes, this should now be easy to accomplish later.
* For loops, we were not considering the initial trace state reliably,
esp. not if it was an uninit trace, which has been fixed.
* Compare traces instead of type shapes to decide if we stablized in
a loop analysis, that is more telling and faster to do.
* More correct annotation of trace escaping, doing away with loop usage
and potential usage.
* Make sure construct the type shapes with alternatives in place, so
we don't have do unmerge them later in code that uses the set of
shapes for a trace or variable.
* Constants are now externally processed and accessed via per-module constant indexes.
* Added dedicated binary for merging constant values from all modules.
* Make sure built-in dictionaries are sorted so their position can be used for reference.
* Removed special internal module and made it normal with automatic parameter variable
releases.
* Built-in loopup helpers now use strings instead of premade strings. This allows to use
them for constant creation too.
* Global constants are no longer special and are created in the same way, referenced with
defines that are indexes to global constants array.
* Freezer and meta path based importer now share their data by using the same stream
and are in the same files.
* This wasn't done previously and will otherwise break XML storage
by loosing this information.
* Also use "None" for no flags, to save creating a set object without
need.
* Autoformat currently only sorts pylint disable comments, and does
not call black yet.
* This also adds a few doc strings that I failed to keep separate as a
commit, but who cares.
* Make raising codes work as well with variable descriptions instead
of hard coded variable names.
* Instead of preserving the code object in the generator making, we
attach it to all kinds of functions and provide a simple C function
to create generators. This makes that code ligher too. We now would
need to know even more information, e.g. the heap storage size, that
we do not have there.
* For internal helper functions, we now have a factory function that
does the always same details, e.g. inernal module, and now having
no code object, so things are less verbose.
* Add argument for heap size to generator, coroutine, asyncgen creation
and have a member pointer "heap_storage" to the space and use it for
heap storage.
* Now global variable traces are attached to be variable itself, no
need to look up traces from anywhere else.
* This probably fixes a couple of bugs that were caused by the two
views of variable information and traces not being consistent at
all times.
* This gives a correct view on more variables sooner, giving a better
chance to fast optimization.
* Saves 0.5% memory for large compilations. Not much at this time,
but should make it possible to unload modules no more needed.
* Unified try node used to re-formulation both try/finally and try/except
nodes.
* Much improved SSA for loop exits and try exits, this will lead to much
better SSA results. In case of try/finally statements, this is now even
much more correct too.
* Duplicating final blocks nodes, implemented by generic cloning via a
new method that calls the constructor with childrent and details. This
required many modifications to make them unified.
* The exception line number is no longer taken from the frame, but has
its own storage.
* Making more use of unwanted non-abort checks in code generation.
* Detach frames only when they are in fact used for an exception traceback.
* Also added support for values trailing a star assignment. This is allowed
in Python3, and so far was ignored. As were syntax errors with double
star usages, also Python3 only.
* Many code generation functions were moved to dedicated modules, using the
expression registry more often.
* Finalization needs to no longer care about try statements, and they do not
have a flag to indicate exception publication. This is all now done in a
consistent way.
* Target updates in context now return the old value consistently, so it's
easier to update them.
* The "internal" module handling also got its own dedicated module to
manage itself.
* More whitelisting for CPython3.x test suites with Python2.
* Distributed remaining code and uses of "nuitka.codegen.Generator" to
modules.
* Stop having a unified "nuitka.codegen.CodeTemplates" and import from
the respective templates module directly. Also split up more according
to the desired topic more often.
* The code generation of "or"/"and" nodes was leaking references, and
potentially even loosing references, and therefore corrupting. Too
old to rebase though.
