Robert Fraser wrote:
> Aarti_pl wrote:
> 
>> Frank Benoit pisze:
>>
>>> Speed. The IDE shall not slow down if the project has hundreds of source files or uses big libs/files. Editing shall always be smooth.
>>
>>
>> You will have to translate Eclipse to D ;-)
>>
>> BR
>> Marcin Kuszczak
>> (aarti_pl)
> 
> 
> Done! ;-P
> 
> http://www.dsource.org/projects/descent

I think that he's thinking of porting Eclipse to D so that it's not written in Java. (I don't have an opinion on this BTW)

Reply to Ary,

Internal Diff: I want to mark points (plural!) in time and then get a on screen diff from those points (highlight added stuff, mark removed, hover-over to see removed and replaced text). It would be cool if there were some way to search the deltas (find all places where ' was replaced with ") and how about right-click>undo for each delta? Also being able to drop into the old versions to copy stuff out would be cool.

I'm thinking more granular than per-save or per-commit but it would also be cool to integrate this with a source control system so that you can get that same tool set with source control revisions

almost all requested features are probably already implemented in the
major IDEs on the market. I personally use Eclipse so I [eagerly] await
the completion of Descent so Eclipse could support D.
I want proper integration more than anything else, so Descent would use
all the advanced features provided by the Eclipse platform.
Also I want a built-in (or pre-configured and bundled) compiler so that
I can just use Eclipse to build my project and not mess with external
paths, command-line tools, DSSS/makefiles/dmd/installation of external
programs/whatever. The IDE should provide _full_ support for all the D
features including stuff like:
1. compile on the fly parts of the code like CTFE functions
2. mixin support - if there's an error the IDE should show mixed-in
location and also it's definition.
3. same as above for templates.

-- Yigal

Bill Baxter Wrote:

> naryl wrote:
> > 
> > The only IDE I know of that has this feature is NetBeans.
> 
> Visual Studio has it too.  Same Alt-left/Alt-right key binding as JDT.

Zeus implements this feature through its TagsSearchUndo and TagsSerachRedo functions, which can be bound to the keyboard or added to the toolbar.

JussiJ

Yigal Chripun wrote:
> almost all requested features are probably already implemented in the
> major IDEs on the market. I personally use Eclipse so I [eagerly] await
> the completion of Descent so Eclipse could support D.
> I want proper integration more than anything else, so Descent would use
> all the advanced features provided by the Eclipse platform.
> Also I want a built-in (or pre-configured and bundled) compiler so that
> I can just use Eclipse to build my project and not mess with external
> paths, command-line tools, DSSS/makefiles/dmd/installation of external
> programs/whatever. The IDE should provide _full_ support for all the D
> features including stuff like:
> 1. compile on the fly parts of the code like CTFE functions
> 2. mixin support - if there's an error the IDE should show mixed-in
> location and also it's definition.
> 3. same as above for templates.
> 
> -- Yigal

I also see this as a future for Descent, and we could sure use some help getting there :-).

I mentioned this in another thread: it would be really great for D in general if we had an IDE that either comes with the full toolchain necessary for compiling and debugging programs, or will download the necessary components at installation. This applies more to Windows users (since Linux users will most likely find their way around on their own) - having an installation package with Eclipse+Descent, DMD, DDBG and possibly Tango would be wonderful.

-- 
Best regards,
 Vladimir                          mailto:thecybershadow@gmail.com

Ary Borenszweig wrote:
> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".

The most important is to allow plugins so it is user extensible. Coupled with that, it needs a built-in scripting language (like elisp is used for emacs).

If you do this right, you won't have to have all those other features, and users won't have to wait for you to implement them.

I believe user extensibility, for example, was a big factor in the success of firefox.

Ary Borenszweig schrieb:
> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
> 
> I'll give as an example the features I found most useful in Eclipse for Java:
>  - Refactoring.
>  - Import rewriting: adding necessary imports and removing unnecessary automatically.
>  - Semantic errors as you type.
>  - Autocompletion.
>  - Implement methods of interface/abstract class.
>  - Type hierarchy.
>  - Finding all the locations where a symbol is used.
>  - Extract variable: selecting an expression and replacing it with a variable, and also adding a declaration for it.
>  - Cast expression/argument to X.
> 
> But possibles answers for D could also be "Template instantiation debugging", "Mixin expansion", etc.

for refactoring/cleanup:

- symbol renaming - rename this variable/function...
- show scope - is it a global, local member, variable/method/class...?
- show dependecies - of a function/class,...

That's exactly the Eclipse philosophy, and Descent honors that.

For example, you have access to the structure of a project, packages, modules (called compilation units in Descent), and it's declarations. You can see which methods are in a module, which are their arguments names and types, as well as return types. Base classes and interfaces of classes are also provided.

Given a compilation unit, you can create a parser that will give you an AST for it, optionally with bindings resolved. Bindings refer to the ability to know the resolved types of expressions and names in the source file, as well as compile-time values. That allows you to do static analysis on code. The metrics plugin works this way, although it needs to be updated to take advantage of bindings (which were implemented in 0.5). To see this in action in Descent, go to Window  -> Show View -> D -> AST View.

Further, you can specify transformations to the AST by simply modifying it and then rewriting the AST to the same file or to another file. That allows any kind of refactoring, "quick fixes" and "assistancies" you can imagine.

This is exaclty the way JDT is built. Here is an article explaining some of it: http://www.eclipse.org/articles/article.php?file=Article-JavaCodeManipulation_AST/index.html

Another feature (not yet implemented in Descent): searching symbols and names is extensible. That means you can make a plugin that, when searching with Descent, will return results for modules referenced in a dsss or bud config file. :-)

Just one note: all of what I mentioned is 80% implemented in Descent (that's why the zero is still there in the version number of the release :-P).

Walter Bright escribió:
> Ary Borenszweig wrote:
>> I'm talking about features that already exist in IDEs for other languages, or features that don't exist at all. Suppose you are typing some D source file and stop thinking "Man, I would really like to do/know X".
> 
> The most important is to allow plugins so it is user extensible. Coupled with that, it needs a built-in scripting language (like elisp is used for emacs).
> 
> If you do this right, you won't have to have all those other features, and users won't have to wait for you to implement them.
> 
> I believe user extensibility, for example, was a big factor in the success of firefox.

Ary Borenszweig пишет:
> Further, you can specify transformations to the AST by simply modifying it and then rewriting the AST to the same file or to another file. That allows any kind of refactoring, "quick fixes" and "assistancies" you can imagine.

I can imagine, given what Eclipse already can do with Java, C/C++ and D sources, automatic transformation of Java and C++ code into almost-compilable D code might be excellent feature to have.