Fix, avoid adding too large constants created with "+".
Fix, error for "vars()" was not compatible.

* Shall not raise "AttributeError" or whatever the lookup gives,
  but "TypeError" instead.

* Might cause subtle compatibility issues.
Optimization: Comparision of objects with itself can be faster, but only for sane types.

* This is also a correction for ">=" and floats and other strange types.
Added warning about too large constants

* Because we now distinguish user provided constants from computed
  ones, we can impose limits.

* Only active in debug mode.
Markup User provided constants
Cleanups and minor correction

* Was sharing a raise statement node in call helpers, which could potential
  become harmful.

* Line lengths format changes.

* Removed obsolete comment.
Make sure, expressions only enter code generation once.
Optimization: Faster function calls

* Optimize non-compiled function calls (without arguments so far only,
  with is TODO).

* Changed signature of function call entry point to accept "PyObject **"
  instead of tuple.

* Changed method calls to insert the "self" into the "PyObject **" which
  ought to be quick, as no new tuple is involved. This allows to remove
  the special variant.

* Added variant for only positional arguments that attempt to directly
  call the implementation of argument counts match. The handling of
  defaults is "TODO".

* Moved call related code generation to its own module "CallCodes".
Detect nodes that fail to compute to new nodes.

* This can be an efficiency issue.

* Only active for debug mode.
Cleanup, store module variables in the owning module and access from there.
Cleanup, remove MSVC specific definition, solved differently now.

Also it was ignored anyway.
Added "tolerant" as detail to "del" statement, indicate side effects and potential no exeception.

* Noted that tolerant "del" statements required a frame, which they
  cannot really raise an exception, so removed that.

* Tolerant was missing as a detail, and will become more important
  once object deletions are more properly represented.
Added amount of statements to details of statement sequences.

Gives nicer trace outputs, otherwise mostly useless.
Avoid tuples and dictionary creation for calls in case of constant arguments.

* For user provided container literals, it was already done, make that
  code re-usable.

* Providing them for calls as well, avoids the noise of later doing
  it in optimization.
Cleanups

* Line length 80 in more places

* Removed now unused function
Cleanup complex call helper code

* Assign variables using code dedicated to it. Otherwise they do not
  get variable versions allocated which is needed for SSA. Doing it
  manually was a bad idea.

* The frames should have the argument names for consistency.

* Share the helper functions to create variable references, now that
  they don't use variable objects anymore, they are not specific for
  every helper.

* Allow to complete the closure for functions too.
Create constants containers more immediately during building where possible

* Slices of assignment statements when they become tuple and are all
  constant values are now created as constant immediately.

* Positional arguments of complex calls were still created as a tuple
  creation even with constant arguments. Also now done immediately.

* Calls to metaclass for class re-formulations now build the dictionary
  as constant immediately if possible as well.

* Python3: Keyword default arguments, and annotations are now also
  built immediately if possible.

* This is all using a helper function, and avoids noise in optimization
  from these trivial things.
Added idea about non-recursive function, that wouldn't have to do recursion checks.
Optimization: More fast function call optimization work

* Generate the code to execute fast calls for positional arguments
  only. This allows to cover all needed variants, instead of only
  a fixed amount.

* Code cleanups to no arguments call variant.

* Trace the needed variants of quick calls.

* Added support for calling non-compiled Python functions in a
  quick way, with arguments too.

* This adds a generated helper body file "__helpers.cpp" for stuff we
  can't really want to duplicate.
Changelog updates