1 Name usage types: as parameters, as base classes, as callables. This potentially restricts
2 attribute usage effects because names mentioned as base classes are not propagated and
3 made freely available for use in attribute accesses.
4
5 Low-Level Instructions and Macro Instructions
6 =============================================
7
8 Have contexts and values stored separately in memory. This involves eliminating DataValue
9 and storing attributes using two words.
10
11 Migrate macro instructions such as the *Index instructions to library code implemented
12 using low-level instructions.
13
14 Consider introducing classic machine level instructions (word addition, subtraction, and
15 so on) in order to implement all current RSVP instructions.
16
17 Move common code sequences to a library routine, such as the context checking that occurs
18 in functions and methods.
19
20 Dataflow Optimisations
21 ======================
22
23 Assignments, particularly now that no result register exists, may cause StoreTemp/LoadTemp
24 instruction pairs to be produced and these could be eliminated.
25
26 Ambiguous/Multiple Class/Function Definitions
27 =============================================
28
29 Classes and functions are not supposed to have multiple definitions, where one code path
30 may define one form of a class or function with a given name and another code path may
31 define another form with that name. Currently, such multiple definitions are treated like
32 "unions" in the object table.
33
34 Class and Module Attribute Assignment
35 =====================================
36
37 Allow unrestricted class and module assignment (but not new external binding of
38 attributes), eliminating run-time checks on object types in instructions like
39 StoreAttrIndex. This may involve less specific objects being identified during inspection.
40
41 Potentially re-evaluate class bases in order to see if they are non-constant.
42
43 Verify that the context information is correctly set, particularly for the unoptimised
44 cases.
45
46 Update docs/assignment.txt.
47
48 Prevent assignments within classes, such as method aliasing, from causing the source of an
49 assignment from being automatically generated. Instead, only external references should be
50 registered.
51
52 Prevent "from <module> import ..." statements from registering references to such local
53 aliases such that they cause the source of each alias to be automatically generated.
54
55 Consider attribute assignment observations, along with the possibility of class and module
56 attribute assignment.
57
58 (Note direct assignments as usual, indirect assignments via the attribute usage
59 mechanism. During attribute collection and inference, add assigned values to all
60 inferred targets.)
61
62 (Since class attributes can be assigned, StoreAttrIndex would no longer need to reject
63 static attributes, although this might still be necessary where attribute usage analysis
64 has not been performed.)
65
66 Potentially consider changing static attribute details to use object-relative offsets in
67 order to simplify the instruction implementations. This might allow us to eliminate the
68 static attribute flag for attributes in the object table, at least at run-time.
69
70 Dynamic Attribute Access
71 ========================
72
73 Consider explicit accessor initialisation:
74
75 attr = accessor("attr")
76 getattr(C, attr)
77
78 Attribute Usage
79 ===============
80
81 To consider: is it useful to distinguish between attribute name sets when the same names
82 are mentioned, but where one path through the code sets different values on attributes
83 than another? The _attrtypes collapses observations in order to make a list of object
84 types for a name, and the final set of names leading to such type deductions might be a
85 useful annotation to be added alongside _attrcombined.
86
87 (Update the reports to group identical sets of attribute names.)
88
89 Attribute usage on attributes might be possible if one can show that the expression of an
90 attribute access is constant and that the attribute target is also constant or only refers
91 to a single type. For example, in the sys module:
92
93 stderr = file()
94
95 If no work is done to associate the result of the invocation with the stderr name, then
96 one could instead at least attempt to determine whether stderr is assigned only once. If
97 so, it might be possible to record attribute usage on references to the name. For example:
98
99 sys.stderr.write(...) # sys.stderr supports write -> {file, ...}
100
101 Interface/Type Generalisation
102 -----------------------------
103
104 Consolidate interface observations by taking all cached table accesses and determining
105 which usage patterns lead to the same types. For example, if full usage of {a, b} and
106 {a, b, c} leads to A and B in both cases, either {a, b} can be considered as partial usage
107 of the complete interface {a, b, c}, or the latter can be considered as an
108 overspecification of the former.
109
110 Consider type deduction and its consequences where types belong to the same hierarchy
111 and where a guard could be generated for the most general type.
112
113 Consider permitting multiple class alternatives where the attributes are all identical.
114
115 Support class attribute positioning similar to instance attribute positioning, potentially
116 (for both) based on usage observations. For example, if __iter__ is used on two classes,
117 the class attribute could be exposed at a similar relative position to the class (and
118 potentially accessible using a LoadAttr-style instruction).
119
120 **** Constant attribute users need not maintain usage since they are already resolved. ****
121
122 Self-Related Usage
123 ------------------
124
125 Perform attribute usage on attributes of self as names, potentially combining observations
126 across methods.
127
128 Additional Guards
129 -----------------
130
131 Consider handling branches of values within namespaces in order to support more precise value usage.
132
133 Loop entry points and other places where usage becomes more specific might be used as
134 places to impose guards. See tests/attribute_access_type_restriction_loop_list.py for an
135 example. (Such information is already shown in the reports.)
136
137 Strict Interfaces/Types
138 -----------------------
139
140 Make the gathering of usage parameterisable according to the optimisation level so that a
141 choice can be made between control-flow-dependent observations and the simple collection
142 of all attributes used with a name (producing a more static interface observation).
143
144 AttributeError
145 --------------
146
147 Consider attribute usage observations being suspended or optional inside blocks where
148 AttributeError may be caught (although this doesn't anticipate such exceptions being
149 caught outside a function altogether). For example:
150
151 y = a.y
152 try:
153 z = a.z # z is an optional attribute
154 except AttributeError:
155 z = None
156
157 Frame Optimisations
158 ===================
159
160 Stack frame replacement where a local frame is unused after a call, such as in a tail call
161 situation.
162
163 Local assignment detection plus frame re-use. Example: slice.__init__ calls
164 xrange.__init__ with the same arguments which are unchanged in xrange.__init__. There is
165 therefore no need to build a new frame for this call, although in some cases the locals
166 frame might need expanding.
167
168 Reference tracking where objects associated with names are assigned to attributes of other
169 objects may assist in allocation optimisations. Recording whether an object referenced by
170 a name is assigned to an attribute, propagated to another name and assigned to an
171 attribute, or passed to another function or method might, if such observations were
172 combined, allow frame-based or temporary allocation to occur.
173
174 Instantiation Deduction
175 =======================
176
177 Consider handling Const, List and Tuple in micropython.inspect in order to produce
178 instances of specific classes. Then, consider adding support for guard
179 removal/verification where known instances are involved. For example:
180
181 l = []
182 l.append(123) # type deductions are filtered using instantiation knowledge
183
184 Currently, this is done only for Const values in the context of attribute accesses during
185 inspection.
186
187 Handling CallFunc in a similar way is more challenging. Consider the definitions in the sys module:
188
189 stderr = file()
190
191 It must first be established that file only ever refers to the built-in file class, and
192 only then can the assumption be made that stderr in this case refers to instances of file.
193 If file can also refer to other objects, potential filtering operations are more severely
194 limited.
195
196 Invocation-Related Deduction
197 ============================
198
199 Where an attribute access (either in conjunction with usage observations or independently)
200 could refer to a number of different targets, but where the resulting attribute is then
201 used in an invocation, filtering of the targets could be done to eliminate any targets
202 that are not callable. Guards would need introducing to prevent inappropriate operations
203 from occurring at run-time.
204
205 Inlining
206 ========
207
208 Where a function or method call can always be determined, the body of the target could be
209 inlined - copied into place - within the caller. If the target is only ever called by a
210 single caller it could be moved into place. This could enhance deductions based on
211 attribute usage since observations from the inlined function would be merged into the
212 caller.
213
214 Function Specialisation
215 =======================
216
217 Specialisation of certain functions, such as isinstance(x, cls) where cls is a known
218 constant.
219
220 Structure and Object Table Optimisations
221 ========================================
222
223 Fix object table entries for attributes not provided by any known object, or provide an
224 error, potentially overridden by options. For example, the augmented assignment methods
225 are not supported by the built-in objects and thus the operator module functions cause
226 the compilation to fail. Alternatively, just supply the methods since something has to do
227 so in the builtins.
228
229 Consider attribute merging where many attributes are just aliases for the same underlying
230 definition.
231
232 Consider references to defaults as occurring only within the context of a particular
233 function, thus eliminating default value classes if such functions are not themselves
234 invoked.
235
236 Scope Handling
237 ==============
238
239 Consider merging the InspectedModule.store tests with the scope conflict handling.
240
241 Consider labelling _scope on assignments and dealing with the assignment of removed
242 attributes, possibly removing the entire assignment, and distinguishing between such cases
243 and unknown names.
244
245 Check name origin where multiple branches could yield multiple scope interpretations:
246
247 try:
248 set # built-in name
249 except NameError:
250 from sets import Set as set # local definition of name
251
252 set # could be confused by the local definition at run-time
253
254 Object Coverage
255 ===============
256
257 Support __init__ traversal (and other implicit names) more effectively.
258
259 Importing Modules
260 =================
261
262 Consider supporting relative imports, even though this is arguably a misfeature.
263
264 Other
265 =====
266
267 Consider a separate annotation phase where deductions are added to the AST for the
268 benefit of both the reporting and code generation phases.
269
270 Check context_value initialisation (avoiding or handling None effectively).
271
272 Consider better "macro" support where new expressions need to be generated and processed.
273
274 Detect TestIdentity results involving constants, potentially optimising status-affected
275 instructions:
276
277 TestIdentity(x, y) # where x is always y
278 JumpIfFalse(...) # would be removed (never false)
279 JumpIfTrue(...) # changed to Jump(...)
280
281 Status-affected blocks could be optimised away for such constant-related results.