paul@379 | 1 | Make use of the _attrcombined annotation instead of _attrnames when deducing types and
|
paul@379 | 2 | defining guards.
|
paul@379 | 3 |
|
paul@372 | 4 | Support slicing. This is difficult because __getitem__ has to handle integers and slice
|
paul@372 | 5 | objects differently. One could either just try and iterate over the argument and then
|
paul@372 | 6 | catch the AttributeError for integers, or one could test the instances first.
|
paul@372 | 7 |
|
paul@372 | 8 | Support isinstance. Like slicing, the problem is dealing with the class or tuple input
|
paul@372 | 9 | to the function. A strict tuple check is permissible according to the CPython behaviour,
|
paul@372 | 10 | but an iterable would be more elegant (as would *args).
|
paul@372 | 11 |
|
paul@376 | 12 | Local assignment detection plus frame re-use. Example: slice.__init__ calls
|
paul@376 | 13 | xrange.__init__ with the same arguments which are unchanged in xrange.__init__. There is
|
paul@376 | 14 | therefore no need to build a new frame for this call.
|
paul@376 | 15 |
|
paul@372 | 16 | Consider attribute usage observations being suspended inside blocks where AttributeError
|
paul@372 | 17 | may be caught (although this doesn't anticipate such exceptions being caught outside a
|
paul@372 | 18 | function altogether).
|
paul@372 | 19 |
|
paul@368 | 20 | Fix object table entries for attributes not provided by any known object, or provide an
|
paul@368 | 21 | error, potentially overridden by options. For example, the augmented assignment methods
|
paul@368 | 22 | are not supported by the built-in objects and thus the operator module functions cause
|
paul@372 | 23 | the compilation to fail. Alternatively, just supply the methods since something has to do
|
paul@372 | 24 | so in the builtins.
|
paul@368 | 25 |
|
paul@368 | 26 | Support tuple parameters.
|
paul@364 | 27 |
|
paul@364 | 28 | Consider type deduction and its consequences where types belong to the same hierarchy
|
paul@364 | 29 | and where a guard could be generated for the most general type.
|
paul@364 | 30 |
|
paul@364 | 31 | Consider attribute merging where many attributes are just aliases for the same underlying
|
paul@364 | 32 | definition.
|
paul@364 | 33 |
|
paul@362 | 34 | Consider merging the InspectedModule.store tests with the scope conflict handling.
|
paul@362 | 35 |
|
paul@364 | 36 | Consider permitting multiple class alternatives where the attributes are all identical.
|
paul@364 | 37 |
|
paul@360 | 38 | Support class attribute positioning similar to instance attribute positioning, potentially
|
paul@360 | 39 | (for both) based on usage observations. For example, if __iter__ is used on two classes,
|
paul@360 | 40 | the class attribute could be exposed at a similar relative position to the class (and
|
paul@360 | 41 | potentially accessible using a LoadAttr-style instruction).
|
paul@360 | 42 |
|
paul@349 | 43 | Consider references to defaults as occurring only within the context of a particular
|
paul@349 | 44 | function, thus eliminating default value classes if such functions are not themselves
|
paul@349 | 45 | invoked.
|
paul@349 | 46 |
|
paul@343 | 47 | Consider labelling _scope on assignments and dealing with the assignment of removed
|
paul@343 | 48 | attributes, possibly removing the entire assignment, and distinguishing between such cases
|
paul@343 | 49 | and unknown names.
|
paul@343 | 50 |
|
paul@342 | 51 | Check name origin where multiple branches could yield multiple scope interpretations:
|
paul@342 | 52 |
|
paul@342 | 53 | ----
|
paul@342 | 54 | try:
|
paul@342 | 55 | set # built-in name
|
paul@342 | 56 | except NameError:
|
paul@342 | 57 | from sets import Set as set # local definition of name
|
paul@342 | 58 |
|
paul@342 | 59 | set # could be confused by the local definition at run-time
|
paul@342 | 60 | ----
|
paul@342 | 61 |
|
paul@332 | 62 | Support __init__ traversal (and other implicit names) more effectively.
|
paul@332 | 63 |
|
paul@332 | 64 | Check context_value initialisation (avoiding or handling None effectively).
|
paul@332 | 65 |
|
paul@342 | 66 | __getitem__ could be written in Python, using a native method only to access fragments.
|
paul@349 | 67 |
|
paul@342 | 68 | Consider better "macro" support where new expressions need to be generated and processed.
|
paul@342 | 69 |
|
paul@342 | 70 | **** Constant attribute users need not maintain usage since they are already resolved. ****
|
paul@342 | 71 |
|
paul@310 | 72 | Loop entry points should capture usage to update later assignments in the loop.
|
paul@310 | 73 | The continue and break statements should affect usage propagation.
|
paul@304 | 74 |
|
paul@304 | 75 | Consider handling CallFunc in micropython.inspect in order to produce instances of specific classes.
|
paul@304 | 76 | Then, consider adding support for guard removal/verification where known instances are involved.
|
paul@304 | 77 | Consider handling branches of values within namespaces in order to support more precise value usage.
|