* Also enhanced reporting error exit reporting through the scons logger to provide
the exception in the compilation report.
* More error exits in scons should do this.
* Avoid imports of whole modules and instead import only select names
from them.
* For the nuitka.Options module we split off the states into a separate
"nuitka.States" module that provides an object that is also faster
to access that module attributes. This is a micro optimization that
allows their use to be faster.
* Renamed XML reading/creating functions for clearer names when used
with out the module name, same for source code references objects.
* Was not converting variable assignments from variables created
during re-formulations to the dedicated nodes, potentially missing
out on optimizations specific to that case, because it was then
not recognized to be non-generic anymore later.
* Was not optimizing comparisons and truth checks for temporary
variable references, missing out on these opportunities, e.g.
with match statements.
* When a variable is aliased, but the source variable is one that
cannot escape or is even very hard, we were not annotating that
as well as we can, now e.g. comparisions with constant values that
are immutable are done even if aliased.
* Remove knowledge of variables assigned to other variables only if
that can escape, otherwise that has no real point.
* New black removes a few leading new lines in blocks, so many
files changed in that way.
* The "pygments" has a vulnerability, but updating that and the
restructured text checking stuff did not actually matter at
all.
* Bumped needed version for development to 3.8, since black does
not do 3.7 anymore, and it's old enough.
* All expression nodes now use a dedicated generated children mixin
class, aimed at optimal use.
* Some select expression nodes now use dedicated base classes with
automatic computations done in there.
* When cloning nodes or getting visitable nodes, more more compact
code is used that should perform better.
* Named chilren now have types, and "tuple" is handled explicitely
without checking values for their type, so updates, iteration etc.
is all directl.
* Remove useless checker for "kw_defaults" from function creation nodes,
they are only ever "None" when the node is created. No need to check
afterwards anymore.
* Only when a function node is created, is there a chance for "kw_defaults"
to be empty dict, so use a factory function instead.
* With useless checkers removed, generated children mixins now do apply
the checkers statically rather than checking on every update if there
is one, and the checkers dictionary per expression can be dropped as
result, making things perform much better for child replacement.
* Attach type shapes to methods specs for use in attribute node
generation, such that the proper mixin class for the result
type shape can be chosen automatically, but we do have some types,
that depend on Python version looking at it, and won't be suitable yet.
* Factories for nodes are now detected automatically in node generation,
making them easier to use.
* Added support for "importlib.metadata.entry_points" and its
backport variant "importlib_metadata" too.
* Added operations for all "bytes" methods as well, such that the
existing few ones are automatically generated as well.
* Added "auto_compute" for annotations of nodes that never change and do
annotate and potentially raise an exception or not. This will allow to
do stub method implementations, and rather have the base class contain
this directly.
* The "iter" node for 2 arguments was not annotating its exception exit,
which was discovered when looking for a boiler plate node to migrate
to "auto_compute" which then of course resolves the bug.
* Make sure we pass tuple values when creating nodes that have children
with that type. We created node lists only to always convert them to
tuple value when the node is created. This is now avoided in many
cases.
* Sequences had dead attribute "sequence_kind", removed that attribute.
* Made a new sequence mixin for reuse in "importlib.metadata.EntryPoints"
values which are more or less a sequence derived class.
* Made dictionary mixin for reuse in "importlib.metadata.SelectableGroups"
as these are more or less a dict derived class.
* Replaced "willRaiseException" with "willRaiseAnyException" which will be
more accurate and faster, and matches what the result of the function
is more closely anyway. We do not ask the other question at all yet.
* Remove useless raise checks in sequence making nodes, they were
repeating the effort done in the base class for no good reason,
potentially wasting a lot of time.
* Made meta data using test cover the new entry_points method without
arguments at least.
* Instead of trying to keep stdout clean in order to not break
the XML parsing, this is more robust, and avoids the need to
redirect the output.
* With --generate-c-only the C compilation can still be avoided,
but code is generated always, adapted the test to require that.
* Constant values are the only ones that need to check their propagation right now.
* Iterators will be interesting for iterator tracing.
* Assignments from variables are also the only ones to do certain
checks.
* With this, "sys" attributes etc. are also resolved in functions.
* Also add "sys.platform", "sys.maxsize", and "sys.hexversion" as
trusted constants.
* For Python2, add "sys.subversion" and "sys.maxint" as trusted
constants specific for that version.
* Addressed new warnings and removed a few annotations in __past__ module that
were there for being checked with Python2 which we no longer do.
* Turned a few constant checking branches into proper TODOs.
* Allow these to become hard imports as well.
* For hard name imports, generate more efficient code.
* Should give slightly less complex C code and less exception exits.
* This is in preparation for 3.10 which will fail to work that work.
* Extended numeric values to be hexadecimal.
* Using tuples over strings in testing.
* This uses AppImage to create the executable.
* The output from AppImage is too confusing for Nuitka target audience,
thefore silence it.
* Also provide general traces from Nuitka for other stages as well.
* An icon will be needed, but currently, only a hardcoded one can be
specified.
nodes
* We only had one common node, lets split this up into a variant with
only 2 arguments, to save memory when using it and a bit of the
processing during optimization.
* We didn't say that we know the shape type for these, so that was
added.
* And as for side effects, creating slice objects doesn't have any,
so make this clear.
* This uses mixins, which do the typical slot behavior.
* Also adding a slot for hash ability, to be used for operations so far.
* The mixin added can be used in other nodes as well in the future.
* Unpacking to single arguments is something we use, this makes it more
clear with braces.
* Unpack to multiple arguments is now displayed much cleaner.
* Multiline imports are used more often at least.
* The autoformat had been done partially in the past, but now it
is complete.
* Covering it with pylint makes sense, but required a lot of
small changes.
Updated the file with few more different types of subscripts that python allows i.e Added 3 argumented subscripting and also added negative indiced subscripting. To make sure that we are not missing any minute details.
