Nim - This repository contains the Nim compiler, Nim's stdlib, tools, and documentation. (mirror)

diff options

-rw-r--r--

1 files changed, 3 insertions, 0 deletions

version 0.9.2 ============= - lazy overloading resolution: * get rid of ``expr[typ]``, use perhaps ``static[typ]`` instead * typedesc[T] needs to be documented in ast.nim - FFI: * test libffi on windows * test: times.format with the FFI - acyclic vs prunable; introduce GC hints - implement constructors + full 'not nil' checking - CGEN: ``restrict`` pragma + backend support; computed goto support - fix: - 'result' is not properly cleaned for NRVO - document NimMain and check whether it works for threading - fix destructors; don't work yet when used as expression; alternative for version 1: disallow expressions yielding a type with a destructor that are not in a 'let/var' context (p(a.openFile, b.openFile) makes no sense anyway) version 0.9.4 ============= - provide tool/API to track leaks/object counts - hybrid GC - use big blocks in the allocator - make 'bind' default for templates and introduce 'mixin'; special rule for ``[]=`` - implicit deref for parameter matching; overloading based on 'var T' - ``=`` should be overloadable; requires specialization for ``=``; general lift mechanism in the compiler is already implemented for 'fields' version 0.9.X ============= - test&finish first class iterators: * nested iterators - implement the missing features wrt inheritance - improve the compiler as a service - better support for macros that rewrite procs - macros need access to types and symbols (partially implemented) - result = result shr 8 for the "system()" wrapper - rethink the syntax/grammar: * parser is not strict enough with newlines * change comment handling in the AST 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 - 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 --> re-evaluate this issue after constructors have been added - 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) - 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 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 Bugs ==== - 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 ... - JS gen: fix exception handling - the better scoping for locals is the wrong default for endb - osproc execProcesses can deadlock if all processes fail (as experienced in c++ mode)


context:
space:
mode: