compiler toolchain

[Aaron J. Seigo]

A short word on my thoughts for the compiler toolchain to allow your minds to 
start working through the implications and start dreaming ideas ;)

The plan is to give the compiler hooks throughout for additional systems to 
tap into. The obvious example to use here is clang (http://clang.llvm.org/)

The plan is to expose not just an AST (IDE-friendly and all that) but to allow 
hooks for instrumenting, adding and changing the generated results at various 
steps. Compiler plugins will be able to extend the functionality of the 
compiler using these hooks.

For instance, the integrated testing framework will be implemented as a 
compiler plugin. In non-release builds it will instrument the compiled code to 
allow it to capture which functions and lines get run while running any given 
test. This will allow for:

* very useful code coverage reports that go beyond "this line was run 8 times 
in testing"

* automated running of unit tests which touch functions that have been changed 
since the last run

* code injection to support patterns like mocking that are based on actual 
modules / functions in the code

The integrated documentation system will similarly be able to note 
documentation coverage, when documentation no longer matches what it 
documents, ....

Refactoring tools will also be more easily added with this kind of 
infrastructure.

Another benefit to this approach is that funq can provide things like an 
integrated testing and documentation framework without welding it too tightly 
to the compiler and runtime.

It should be possible to write these plugins in funq itself, though a C++ API 
will probably also be offered for use by more complex tools or IDEs.

-- 
Aaron J. Seigo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 198 bytes
Desc: This is a digitally signed message part.
URL: <http://kde.org/pipermail/funq-devel/attachments/20140804/24f7aa3d/attachment.sig>