www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.ide - Which features are the most important for an IDE for D?

reply Ary Borenszweig <ary esperanto.org.ar> writes:
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.
Feb 07 2008
next sibling parent reply naryl <cy ngs.ru> writes:
On Fri, 08 Feb 2008 04:02:11 +0300, Ary Borenszweig <ary esperanto.org.ar>  
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".

 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.


I would like to add:
- Intention Actions (  
http://www.jetbrains.com/idea/docs/help/editing/intentionactions.html )
- External build tool integration, like Ant for Java. (As you may guess,  
I'd vote for DSSS :) )
Feb 07 2008
parent Robert Fraser <fraserofthenight gmail.com> writes:
naryl wrote:

 I would like to add:
 - Intention Actions ( 
 http://www.jetbrains.com/idea/docs/help/editing/intentionactions.html )


JDT has that, and it's a sort-of-planned feature for Descent. I don't 
usually use that feature for correcting mistakes, I actually use it to 
write a lot of my code. For example, if I need a new class I'll often 
just write the new declaration, toss a couple method calls there, and go 
back and use the quick-fix processor (as JDT calls it) to generate the 
class with the correct constructor & functions right there. If I'm 
assigning it to an interface, it'll even put the unimplemented methods 
there. Very handy!
Feb 07 2008
prev sibling next sibling parent BCS <ao pathlink.com> writes:
Reply to Ary,


 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.
 


in the order I though of them:

Live "unittest": this would look like a table of values to call a function 
with and any time the function will compile (try every key stroke) the function 
is run and each output is reported. (the level of integration with the compiler 
this would demand would be intense) This would make one of the best things 
about using spreadsheets available in a real programming language.

selective import maintenance: if you try to use a new function it adds it 
to the import list (maybe after asking) or maybe even adding new imports.
Feb 07 2008
prev sibling next sibling parent Bjoern <nanali nospam-wanadoo.fr> writes:
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.


1-
Realtime Developer Collaboration without the need of CVS, SVN and the 
like. (requires RDBMS and async. communication support)
2-
The I in IDE ;)
Bjoern
Feb 08 2008
prev sibling next sibling parent Alexander Panek <alexander.panek brainsware.org> writes:
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".


- proper Vim integration
- Help in applying conventions, or even being able to define conventions 
on a per project base (module/package naming, type naming, general code 
style, etc.)
- Additional to the above point, possibility to define project templates 
and rules/conventions
- integration of one or more build tools (namely rebuild, dsss, make) 
and abstraction of config files of each (automatic generation for a 
project, too, of course but with the possibility to alter variables & co 
with the IDE itself, without having to edit the file(s))
Feb 08 2008
prev sibling next sibling parent reply boyd <gaboonviper gmx.net> writes:
What I'd like to see most in an IDE is userfriendliness. Especially the  
installation of the IDE. I just want to download the IDE, and install it  
with a few button clicks or a single console command. It should be able to  
do most of its features without the need to configure compiler paths, or  
what not. That's what I think is missing in the current IDE's for D.

----
On Fri, 08 Feb 2008 02:02:11 +0100, Ary Borenszweig <ary esperanto.org.ar>  
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".

 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.
Feb 08 2008
parent reply "Saaa" <empty needmail.com> writes:
 What I'd like to see most in an IDE is userfriendliness. Especially the 
 installation of the IDE. I just want to download the IDE, and install it 
 with a few button clicks or a single console command. It should be able to 
 do most of its features without the need to configure compiler paths, or 
 what not. That's what I think is missing in the current IDE's for D.


Poseidon is going that way. (If all goes well)
I also wish more programs could update themselves with the latest build.
And maybe update the compiler as well.

There should be a project on dsource which would make handling stuff like 
that easier :)
Feb 08 2008
parent BCS <BCS pathlink.com> writes:
Saaa wrote:

What I'd like to see most in an IDE is userfriendliness. Especially the 
installation of the IDE. I just want to download the IDE, and install it 
with a few button clicks or a single console command. It should be able to 
do most of its features without the need to configure compiler paths, or 
what not. That's what I think is missing in the current IDE's for D.


 
 
 Poseidon is going that way. (If all goes well)
 I also wish more programs could update themselves with the latest build.
 And maybe update the compiler as well.
 
 There should be a project on dsource which would make handling stuff like 
 that easier :)
 
 


seeing as dmd is free an small on win/Linux having an app that updates 
it's self using a source download/compile would not be to nasty even for 
non-programmer users.
Feb 08 2008
prev sibling next sibling parent reply =?ISO-8859-15?Q?J=F6rg_R=FCppel?= <joerg sharky-x.de> writes:
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".
 
 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.


In addition to that list in no particular order:
° Code navigation similar to webbrowser where you follow code definitions
and uses go to definition etc). Most IDEs have that, but very few implement
a proper back button/shortcut, so that I can quickly look up a function
implementation and return to where I was before.
° Find all references: Given a symbol, it shows me all places where this
symbol is used.
° Method outline: A combobox that, when clicked, lists all method declared
in the current file and brings me there on selection.
° Symbol search: A dialog where I can search for symbols project wide.
° Automatic code formatting as I type, with the settings stored per project,
and not per user.
Feb 08 2008
next sibling parent reply Robert Fraser <fraserofthenight gmail.com> writes:
Jörg Rüppel wrote:

 In addition to that list in no particular order:
 ° Code navigation similar to webbrowser where you follow code definitions
 and uses go to definition etc). Most IDEs have that, but very few implement
 a proper back button/shortcut, so that I can quickly look up a function
 implementation and return to where I was before.


You just blew my mind! This is something that always bothers me when 
using go-to-definition, but I never thought there'd be such a simple 
solution.
Feb 08 2008
next sibling parent reply Frank Benoit <keinfarbton googlemail.com> writes:
Robert Fraser schrieb:

 
 You just blew my mind! This is something that always bothers me when 
 using go-to-definition, but I never thought there'd be such a simple 
 solution.


In JDT you can use ALT-Left/Right or the arrow symbols in the toolbar.
Feb 08 2008
next sibling parent Robert Fraser <fraserofthenight gmail.com> writes:
Frank Benoit wrote:

 Robert Fraser schrieb:

 You just blew my mind! This is something that always bothers me when 
 using go-to-definition, but I never thought there'd be such a simple 
 solution.


 
 In JDT you can use ALT-Left/Right or the arrow symbols in the toolbar.


OK, _YOU_ just blew my mind! I learn something new about JDT every day! 
And it turns out Descent has this feature, too :-).
Feb 08 2008
prev sibling parent Ary Borenszweig <ary esperanto.org.ar> writes:
Frank Benoit wrote:

 Robert Fraser schrieb:

 You just blew my mind! This is something that always bothers me when 
 using go-to-definition, but I never thought there'd be such a simple 
 solution.


 
 In JDT you can use ALT-Left/Right or the arrow symbols in the toolbar.


I think it's actually a part of Eclipse, not just JDT. I can navigate 
across different editors that way (not just java source files).
Feb 08 2008
prev sibling parent reply naryl <cy ngs.ru> writes:
On Fri, 08 Feb 2008 16:03:45 +0300, Robert Fraser  
<fraserofthenight gmail.com> wrote:


 Jörg Rüppel wrote:

 In addition to that list in no particular order:
 ° Code navigation similar to webbrowser where you follow code  
 definitions
 and uses go to definition etc). Most IDEs have that, but very few  
 implement
 a proper back button/shortcut, so that I can quickly look up a function
 implementation and return to where I was before.


 You just blew my mind! This is something that always bothers me when  
 using go-to-definition, but I never thought there'd be such a simple  
 solution.


The only IDE I know of that has this feature is NetBeans.
Feb 08 2008
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
naryl wrote:

 On Fri, 08 Feb 2008 16:03:45 +0300, Robert Fraser 
 <fraserofthenight gmail.com> wrote:
 

 Jörg Rüppel wrote:

 In addition to that list in no particular order:
 ° Code navigation similar to webbrowser where you follow code 
 definitions
 and uses go to definition etc). Most IDEs have that, but very few 
 implement
 a proper back button/shortcut, so that I can quickly look up a function
 implementation and return to where I was before.


 You just blew my mind! This is something that always bothers me when 
 using go-to-definition, but I never thought there'd be such a simple 
 solution.


 
 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.

--bb
Feb 08 2008
parent Jussi Jumppanen <jussij zeusedit.com> writes:
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
Feb 08 2008
prev sibling parent Jascha Wetzel <firstname mainia.de> writes:
Jörg Rüppel wrote:

 In addition to that list in no particular order:
 ° Code navigation similar to webbrowser where you follow code definitions
 and uses go to definition etc). Most IDEs have that, but very few implement
 a proper back button/shortcut, so that I can quickly look up a function
 implementation and return to where I was before.


the current SEATD alpha plugin for Kate has such a navigation history ;)

http://seatd.mainia.de
Feb 08 2008
prev sibling next sibling parent reply Frank Benoit <keinfarbton googlemail.com> writes:
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.
Feb 08 2008
parent reply Aarti_pl <aarti interia.pl> writes:
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)
Feb 08 2008
parent reply Robert Fraser <fraserofthenight gmail.com> writes:
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
Feb 08 2008
parent BCS <BCS pathlink.com> writes:
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)
Feb 08 2008
prev sibling next sibling parent BCS <ao pathlink.com> writes:
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
Feb 08 2008
prev sibling next sibling parent reply Yigal Chripun <yigal100 gmail.com> writes:
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
Feb 08 2008
parent Robert Fraser <fraserofthenight gmail.com> writes:
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 :-).
Feb 08 2008
prev sibling next sibling parent "Vladimir Panteleev" <thecybershadow gmail.com> writes:
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
Feb 08 2008
prev sibling next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
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.
Feb 08 2008
parent reply Ary Borenszweig <ary esperanto.org.ar> writes:
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.
Feb 09 2008
parent Vladimir Vlasov <vlasov scatt.com> writes:
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.
Feb 09 2008
prev sibling next sibling parent dennis luehring <dl.soluz gmx.net> writes:
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,...
Feb 09 2008
prev sibling next sibling parent bobef <bobef abv-nospam.bg> writes:
Intellisense
Debuging
Smart build system

I can't say which one is most important.
Feb 09 2008
prev sibling next sibling parent Tom <tom nospam.com> writes:
Integrated builder (DSSS would be great).

Tom;

Ary Borenszweig escribió:
....
Feb 09 2008
prev sibling next sibling parent reply Christopher Wright <dhasenan gmail.com> writes:
Start autocompletion as soon as I start typing. I'm pretty much always 
going to be typing a type name, function name, or variable name, so why 
not offer suggestions immediately?

Have an option to accept autocompletion suggestions as soon as a 
character is entered that can separate the current token -- whitespace, 
a dot, equals sign, that sort of thing.

These two will save a very large amount of typing.

Additionally, offering a way to resolve imports based on types used 
would be good. I know I want a Time struct, but I don't recall whether I 
get it from tango.core or tango.util or maybe they've moved it this release.

An efficient keyboard shortcut for goto inheritor/base/implementation 
for a method or type.

A template mechanism, so I can click new -> from template -> my custom 
template, enter a name, and have a new module instantiated from the 
template.

Essentially, I want Resharper.
Feb 14 2008
next sibling parent reply Robert Fraser <fraserofthenight gmail.com> writes:
Descent has all of this already.

Christopher Wright wrote:

 Start autocompletion as soon as I start typing. I'm pretty much always 
 going to be typing a type name, function name, or variable name, so why 
 not offer suggestions immediately?


You have to press control-space to get it, but if you type "n" and have 
a local variable called "name", that will be suggested. Maybe we should 
add an option to pop up the suggestion box immediately.


 
 Have an option to accept autocompletion suggestions as soon as a 
 character is entered that can separate the current token -- whitespace, 
 a dot, equals sign, that sort of thing.


Descent just has this with dot, everything else you need to press 
control-space.


 
 These two will save a very large amount of typing.
 
 Additionally, offering a way to resolve imports based on types used 
 would be good. I know I want a Time struct, but I don't recall whether I 
 get it from tango.core or tango.util or maybe they've moved it this 
 release.


Yup, got that. Start typing Time control-space up the autocomplete, 
choose the suggestion, and the import is automatically added. Good times 
ensue.


 
 An efficient keyboard shortcut for goto inheritor/base/implementation 
 for a method or type.


Control-click on it.


 
 A template mechanism, so I can click new -> from template -> my custom 
 template, enter a name, and have a new module instantiated from the 
 template.


Been in Descent for a while... sort of. A more robust templating 
mechanism is probably in order, though.


 
 Essentially, I want Resharper.
Feb 14 2008
parent reply Christopher Wright <dhasenan gmail.com> writes:
Robert Fraser wrote:

 Descent has all of this already.


I just started using it yesterday, so forgive my ignorance.


 Christopher Wright wrote:

 Start autocompletion as soon as I start typing. I'm pretty much always 
 going to be typing a type name, function name, or variable name, so 
 why not offer suggestions immediately?


 
 You have to press control-space to get it, but if you type "n" and have 
 a local variable called "name", that will be suggested. Maybe we should 
 add an option to pop up the suggestion box immediately.


I would certainly appreciate that, though a lot of people would kvetch 
if that were the default. I knew that Eclipse allowed for ctrl-space to 
force autocompletion.


 Have an option to accept autocompletion suggestions as soon as a 
 character is entered that can separate the current token -- 
 whitespace, a dot, equals sign, that sort of thing.


 
 Descent just has this with dot, everything else you need to press 
 control-space.


Okay. So it shouldn't be too hard to do this, if I want to patch Descent.


 These two will save a very large amount of typing.

 Additionally, offering a way to resolve imports based on types used 
 would be good. I know I want a Time struct, but I don't recall whether 
 I get it from tango.core or tango.util or maybe they've moved it this 
 release.


 
 Yup, got that. Start typing Time control-space up the autocomplete, 
 choose the suggestion, and the import is automatically added. Good times 
 ensue.


Groovy.


 An efficient keyboard shortcut for goto inheritor/base/implementation 
 for a method or type.


 
 Control-click on it.


And inheritor or base? And a keyboard shortcut?


 A template mechanism, so I can click new -> from template -> my custom 
 template, enter a name, and have a new module instantiated from the 
 template.


 
 Been in Descent for a while... sort of. A more robust templating 
 mechanism is probably in order, though.
 

 Essentially, I want Resharper.
Feb 15 2008
parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Christopher Wright wrote:

 An efficient keyboard shortcut for goto inheritor/base/implementation 
 for a method or type.


 Control-click on it.


 
 And inheritor or base? And a keyboard shortcut?
 


If you're talking about the type and method hierarchy features, which 
you seem to be, that feature is not yet implement. But if it was, the 
keyboard shortcut would be Ctrl-T, same as JDT.

-- 
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Mar 24 2008
prev sibling parent reply Ary Borenszweig <ary esperanto.org.ar> writes:
Christopher Wright escribió:

 Start autocompletion as soon as I start typing. I'm pretty much always 
 going to be typing a type name, function name, or variable name, so why 
 not offer suggestions immediately?
 
 Have an option to accept autocompletion suggestions as soon as a 
 character is entered that can separate the current token -- whitespace, 
 a dot, equals sign, that sort of thing.


Visual Studio does that, and at least for me it becomes annoying some 
times. This is so because autocompletion is not perfect, and can't 
always be perfect (unless it reads your mind), so suggestions may be 
wrong, and you end up canceling the suggestions popup and then start 
typing. For example, say foo is of an enum type:

foo = // <-- will suggest automatically enum values

But maybe I want to assign a variable to foo, not a constant enum value.

Although I think it's a good idea to have it as an option, but I don't 
know if that can be done in Eclipse. Maybe you should try putting all 
the letters and symbols in the characteres textbox that triggers the 
autocompletion? :-)


 
 These two will save a very large amount of typing.
 
 Additionally, offering a way to resolve imports based on types used 
 would be good. I know I want a Time struct, but I don't recall whether I 
 get it from tango.core or tango.util or maybe they've moved it this 
 release.
 
 An efficient keyboard shortcut for goto inheritor/base/implementation 
 for a method or type.


For go to definition you can also use F3. For what you are asking for, 
we first need to implement type hierarchies, and for type hierarchies we 
need to implement the searching functionality, so it'll take some time...


 
 A template mechanism, so I can click new -> from template -> my custom 
 template, enter a name, and have a new module instantiated from the 
 template.
 
 Essentially, I want Resharper.
Feb 15 2008
parent Christopher Wright <dhasenan gmail.com> writes:
Ary Borenszweig wrote:

 Visual Studio does that, and at least for me it becomes annoying some 
 times. This is so because autocompletion is not perfect, and can't 
 always be perfect (unless it reads your mind), so suggestions may be 
 wrong, and you end up canceling the suggestions popup and then start 
 typing. For example, say foo is of an enum type:
 
 foo = // <-- will suggest automatically enum values
 
 But maybe I want to assign a variable to foo, not a constant enum value.


Then there'd be multiple matches, and the completion shouldn't insert 
one automatically.


 Although I think it's a good idea to have it as an option, but I don't 
 know if that can be done in Eclipse. Maybe you should try putting all 
 the letters and symbols in the characteres textbox that triggers the 
 autocompletion? :-)


I can enter a maximum of four characters into that box, so no.


 An efficient keyboard shortcut for goto inheritor/base/implementation 
 for a method or type.


 
 For go to definition you can also use F3. For what you are asking for, 
 we first need to implement type hierarchies, and for type hierarchies we 
 need to implement the searching functionality, so it'll take some time...


Understood.
Feb 15 2008
prev sibling next sibling parent Graham St Jack <Graham.StJack internode.on.net> writes:
For me, a very important feature is to be able to build (with jump-to-
error) using a tool of my choice. The IDE needs to separate building from 
its own needs of where to find things. Of course, it needs to have a 
"default" build tool (like dsss for example).
Feb 17 2008
prev sibling parent BCS <ao pathlink.com> writes:
Not exactly important but cool:

a pile of math tools

"Math view", hover over an equation and the IDE format's it as an equation 
(like in TeX)
"Convert to TeX", take an equation (selected or copied) and transform it 
into TeX probably on the clipboard.
The other way" copy an equation out of some tex source (or OCR/read it out 
of a doc/pdf/ps) and generate a D expression of it.
same thing for other syntax.
"equation manipulator" performs, valid math operations (factor, distribute 
in/out, etc.)

Fix errors: when a compile error is highlighted, put some common fixes in 
the right click menu (add semicolon, add cast, etc)
Feb 17 2008