new frontend written in D

[Jacob Carlborg]

On 2011-09-28 19:14, Jonathan M Davis wrote:
> On Wednesday, September 28, 2011 07:45 Gor Gyolchanyan wrote:
>> I agree, that rewriting the language is not a good idea until the
>> current version is fully studied, so i don't want D3 either. D2 is
>> good enough for now.
>> But I don't have D2 because most of what makes it unique isn't
>> implemented or is buggy. And i still won't have it for a long long
>> time (I really want classes in CTFE, for example).
>
> Having a D compiler for D would be cool, but really, does it matter? At least,
> to the average programmer? The average programmer wants a compiler that works.
> Fixing dmd's bugs gets you that. That's what's being done. Rewriting dmd in D
> doesn't help with that at all. In fact it makes it worse, because it's
> inevitable that new bugs will be introduced.
>
> In the long run, it would be nice to have a compiler in D (maybe even the
> primary compiler), and maybe such a compiler could be more performant thanks
> to slicing and the like. But until D2 is fully stable, that just seems like
> wasted effort. There are far more important things for getting D2 fully
> usable. The operative word is "nice." It would be _nice_ if we had a fully
> working D compiler in D, but it's far from necessary and really doesn't gain
> us much at this point in time.
>
> I honestly don't understand why having a D compiler in written in D is so
> important to some people. What we need is a solid compiler. The language that
> it's in doesn't matter all that much IMHO. Yes, it's a good sign for D if it
> can have a fully functional, performant compiler written in D (especially if
> it's _more_ performant than a comparable compiler written in C++), but what
> matters is being able to write your own code in D, not whether the tools
> you're using were written in any particular language.
>
> However, regardless of why you might want another D compiler with a new
> frontend, I think that it would make a _lot_ of sense to wait until D2's spec
> has completely stabilized (it's fairly stable now but not completely stable),
> and dmd is more or less bug-free (obviously not completely bug-free, but on
> the level typically expected of a compiler). That would severely reduce how
> much rewriting you would have to do as D and dmd change, and the problem would
> become much more tractable.
>
> - Jonathan M Davis

Yes it does matter. The most important thing isn't what language the 
compiler is written in, but let me but it this way. There are some much 
else, beside from a compiler, that a frontend can be used for:

IDE integration:

* Syntax highlighting
* Code completion
* Showing syntax and semantic errors
* Refactoring
* Outline views
* DDoc views

Other:

* Debugger
* Source-to-source compiler

Example of how it's working with GCC (or has been working). There's a 
complete frontend in the compiler. There's another half-working 
frontend/expression parser in the debugger. There's third half-working 
frontend in some IDE. That's just crazy.

What is important is to have a modular frontend that can be used as a 
library. Having something like what Clang is for C/C++/Objective-C, but 
for D.

We all want to write our programs and tools in D, that's why we're here 
right. Now, what if it happens that your tool needs some kind of 
functionality that can be found in the frontend. With a modular frontend 
that can be used like a library you just use the frontend as every other 
library and there's nothing special about it. To be able to use the 
library with D it would be a lot easier if it's written in D, not 
necessary, but a lot easier.

So in the end, the language a compiler/frontend is written in is quite 
important.

-- 
/Jacob Carlborg