To use Walter's code to make the parsing and build a model, since it's the only safe way to guarantee compliance with the current DMD compiler. Then diffing changes in the source should make changes in the plugin quite simple. (not to use ANTLR, for instance)
To document every public class, so that other people can join the project "easily". I took a look at the DDT code and I found just a little bit of comment...
To use an architecture similar to the one JDT uses. DDT tried this, but I don't know what happened (most of the classes are empty!)... For example PHPEclipse uses many of JDT classes and interfaces (redefining them)... even keeping the same names! (i.e. IJavaElement)
To make things with patience.

First do the parsing (port the parser), build a model and have an outline.
Second singal syntax errors.
Third signal simple semantic errors (I believe method "semantic" of Dsymbol... maybe "semantic2" and "semantic3" uses relationships between modules).
Fourth, copy JDT architecture.
Fifth, add renaming, refactoring, autocomplete, quick fixes, etc. ... In the middle of those points be

able to compile everything :-P

With patience I mean: take a deep look at how JDT is done, then put yourself to program.

Fortunately, I've already ported most of the parser (for D 0.168) to Java, I already build a model, have an outline view and signal simple syntax errors. Not just the line number, but the exact positions where the error is present. Also the plugin compiles automatically your code, but I still don't know how to link everything automatically (I'm missing some rule, I guess). And nothing more: I'm currently reading a lot of code from the JDT core plugin, and some Walter's code.

I think a D plugin for eclipse would be of big utility to the D community. Since I started programing in Java with Eclipse I totally forgot about compiling, getting errors, fixing them, having to "find/search" to do refactoring, etc. And programming like that is so, so fast you only have to focus on your code, really.

I know, Walter, you think an IDE is something non-essential. But for big projects it is *really* helpful.

A good IDE, and some good core libraries, is what missing here (IMHO).

Is anyone interested?

Getting Started

If you have DDT installed, please uninstall it first through Manage Configuration.

(adapted from NG:digitalmars.D/43441 by Ary Manzana)

Bill Baxter wrote:

: Actually I could do without a full-blown IDE if there were just a decent visual debugger. For writing code I'm fine with emacs, but debugging via printfs is annoying. And don't go telling me about that crashy WinDbg thing -- it's just not up to snuff.

I agree. Well, making the debug thing is the most difficult part, but it would be very nice to have it, although right now I'm not feeling capable of doing that (I know little about compilers, debuggers, etc.). Eclipse provides a framework to hook some debug stuff, so I guess it won't be (that) hard to do it.

Well, I've cleaned up a bit the code and here it is:

http://www.esperanto.org.ar/d/descent.ui.zip

Umm... Uncompress everything in the eclipse directory, and everything should work. In the plugins directory there are three jars (core, ui and tests... I forgot to mention I made a lot of tests), source code included, so you can take a look and not feel that scared (the most important is descent.core).

Before starting you should know the plugin compiles with "dmd" only, and it searches it in the environment path (I only tried it in Windows). I put an option in a property page to change it, but I couldn't get to get it working

Go to File -> New -> Project -> D -> D project, enter a location and hit it. You should see a "src" folder in the project. There you must create the d files (File -> New -> File -> foo.d). While you write the file, if you stop typing you should see error markers appearing, as well as the outline view being updated. If you save the file you should see *all* the errors, since I parse dmd output (I will drop these once the plugin gets all the errors by itself). Also, obj and di files are created when saving, so compiling is faster.

Well... that's all for now. I know it's less (maybe?) than what DDT has, but maybe it's a bit more organized, and it uses incremental building (just for single files, not for projects yet).

The next step would be to understand the semantic routines and add them to the code. I guess I won't have to copy all the source code since I only need to get errors, not to compile anything... I wonder if making a visitor would be easier to get the semantics done...? Any ideas...?

Related Projects

See Eclipse Editor.

FolderProjects