forked from nim-lang/Nim
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathtodo.txt
142 lines (118 loc) · 5.23 KB
/
todo.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
version 0.9.2
=============
- FFI:
* test libffi on windows
* test: times.format with the FFI
- acyclic vs prunable; introduce GC hints
- CGEN: ``restrict`` pragma + backend support; computed goto support
- document NimMain and check whether it works for threading
Bugs
====
- docgen: sometimes effects are listed twice
- 'result' is not properly cleaned for NRVO
- instantiated generics are listed in error messages
- sneaking with qualifiedLookup() is really broken!
- aporia.nim(968, 5) Error: ambiguous identifier: 'DELETE' --
use a qualifier
- blocks can "export" an identifier but the CCG generates {} for them ...
- osproc execProcesses can deadlock if all processes fail (as experienced
in c++ mode)
- bootstrapping does not work in C++ mode
- result = result shr 8 for the "system()" wrapper
version 0.9.4
=============
- macros as type pragmas
- provide tool/API to track leaks/object counts
- hybrid GC
- use big blocks in the allocator
- implement full 'not nil' checking
- make 'bind' default for templates and introduce 'mixin';
special rule for ``[]=``
- implicit deref for parameter matching
- ``=`` should be overloadable; requires specialization for ``=``; general
lift mechanism in the compiler is already implemented for 'fields'
- lazy overloading resolution:
* get rid of ``expr[typ]``, use perhaps ``static[typ]`` instead
* special case ``tyStmt``
version 0.9.X
=============
- test&finish first class iterators:
* nested iterators
- implement the missing features wrt inheritance
- object pooling support for *hard* realtime systems
- improve the compiler as a service
- better support for macros that rewrite procs
- macros need access to types and symbols (partially implemented)
- effect propagation for callbacks
- perhaps: change comment handling in the AST
- enforce 'simpleExpr' more often --> doesn't work; tkProc is
part of primary!
- the typeDesc/expr unification is weird and only necessary because of
the ambiguous a[T] construct: It would be easy to support a[expr] for
generics but require a[.typeDesc] if that's required; this would also
allow [.ref T.](x) for a more general type conversion construct; for
templates that would work too: T([.ref int])
Concurrency
-----------
- shared memory heap: ``shared ref`` etc. The only hard part in the GC is to
"stop the world". However, it may be worthwhile to generate explicit
(or implicit) syncGC() calls in loops. Automatic loop injection seems
troublesome, but maybe we can come up with a simple heuristic. (All procs
that `new` shared memory are syncGC() candidates... But then 'new' itself
calls syncGC() so that's pointless.) Hm instead of an heuristic simply
provide a ``syncgc`` pragma to trigger compiler injection --> more general:
an ``injectLoop`` pragma
- 'writes: []' effect; track reads/writes for shared types
- use the effect system for static deadlock prevention and race detection
- ``~`` operator for effects
- introduce 'noaddr' pragma to prevent taking the address of a location; this
is very handy to prevent aliasing of global data
version 0.9.XX
==============
- object branch transitions can't work with the current 'reset'; add a 'reset'
with an additional parameter --> simple:
provide a 'reset(x, TObj(k: nkValue))' instead? why bother? '=' does the
same.
- document nimdoc properly finally
- make 'clamp' a magic for the range stuff
- better type syntax for functions and tuples: tuple(int, int); (int,int)->int
Not essential for 1.0.0
=======================
- 'const' objects including case objects
- mocking support with ``tyProxy`` that does: fallback for ``.`` operator
- overloading of ``.``? Special case ``.=``?
- allow implicit forward declarations of procs via a pragma (so that the
wrappers can deactivate it): better solution: introduce the notion of a
'proc section' that is similar to a type section.
- implement the "snoopResult" pragma; no, make a strutils with string append
semantics instead ...
- implement "closure tuple consists of a single 'ref'" optimization
- optimize method dispatchers
- ``with proc `+`(x, y: T): T`` for generic code
- new feature: ``distinct T with operations``
- arglist as a type (iterator chaining); variable length type lists for generics
- resizing of strings/sequences could take into account the memory that
is allocated
- codegen should use "NIM_CAST" macro and respect aliasing rules for GCC
- implement marker procs for message passing
- activate more thread tests
- implement closures that support nesting of *procs* > 1
- GC: implement simple generational GC
* first version: mark black in write barrier
* second version: introduce fake roots instead of marking black
* third version: find some clever heuristic which is preferable
- object constructors: static check for fields if discriminator is known at
compile time
GC
==
- precise stack marking; embrace C++ code generation for that
- marker procs for Boehm GC
- implement 'mixed' GC mode
Optimizations
=============
- optimize 'if' with a constant condition --> necessary in frontend for better
dead code elimination
- escape analysis for string/seq seems to be easy to do too;
even further write barrier specialization
- inlining of first class functions
- proc specialization in the code gen for write barrier specialization