Re: IDE's that support ADA

[Stephen Leake <stephen_leake@stephe-leake.org>]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> On Tue, 28 Oct 2014, Stephen Leake wrote:
>
>> Interesting. The latest version of Emacs was released 20 Oct 2014.
>> In what sense is it not "modern"?
>>
>> What does Visual Studio have that you believe Emacs doesn't have,
>> that you find useful? It is often somewhat difficult to find and
>> turn on various features in Emacs.
>
> Typical features of modern IDEs include: displaying semantic errors
> (type errors, etc) as you type, 

Meaning it attempts to parse the syntax after typing every character? So
if you start typing 'if ... then ... else .. end if', you get errors
until you type 'endif'? Yuck.

The current Emacs Ada mode indentation engine fails in that scenario
because the parse fails, and I'm working to make the parser tolerant of
errors so the indentation works.

On the other hand, Emacs Ada mode will tell you of the first current
syntax error if you ask it (which I do when indentation fails). And it
has a mode where you get that report each time you attempt to indent.

So I'll count that as "does that".

Hmm. You said "semantic", not "syntactic". So this means a full compile
with name and type resolution, not just a syntax parse. That makes sense
for simpler languages; I don't think it makes much sense for Ada.

> refactoring support, 

I've never been clear what this means, exactly. It could be:

- Rename all occurences of this identifier

    Emacs Ada mode has "show all references", which would walk thru all
    occurrences and let you rename each one; that could be enhanced
    fairly easily.

- Change the parameter list for this subprogram

    I don't see how you can automate that; you have to consider exactly
    what that means at each use. So the "walk thru all occurences" is
    useful.


- something else?

> integrated debugging, 

Has that.

> and code completion along with display of associated documentation.

There are various completion modes in Emacs; they will search open
buffers, history lists, etc.

If by this you mean "show me only possible completions that would
_compile_ here", that requires a successful semantic compile in the face of
errors. I'm working on allowing a syntax parse; that will get part way
there. 

In some simple cases you don't need a parse; if I type
"Ada.Text_IO.Put", it could offer "" and "_Line" as completions by
parsing the Ada.Text_IO spec, without parsing the current file.

More useful would be all the operations on type "Bar_Type" for object
"Foo". The GNAT cross-reference info can build that list given
"Bar_Type", so I might be able to get there.

I haven't tried completion in GPS in a while.

If the "associated documentation" for a subprogram is the comments at
the declaration, then that just requires navigating to the current
completion choice in another window. Although one editor I saw put that
in a help balloon; cute, but probably not enough space for useful info.

> Many IDEs also facilitate test case generation and profiling. 

Emacs can easily run the GNAT command line tool that does this, and
navgate thru the reports.

> In the Ada world there is integration with SPARK (for example as GPS
> does).

Not clear what "integration" means here. Again, Emacs can run the
command line tools that SPARK uses.

> Emacs is powerful and may well be able to do some or all of these
> things. Indeed, there is a Scala extension for Emacs that goes a long
> way in this direction. I believe it works by interacting directly with
> the Scala compiler behind the scenes.

Emacs Ada mode uses a mix of the GNAT compiler (for cross reference
info) and a separate parser (for indentation and lower-level navigation).

-- 
-- Stephe