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