When renaming a setter or variable, display the getter name.

Fixes #1001177
Small refactoring/clean-up in ``ScalaMatchLocator``
Fix #1001173, #1001174 - Correctly expose abstract val/var to JDT

Abstract val/var were being ignored in the ``ScalaStructureBuilder`` and
therefore no ``IJavaElement`` was being created. Indeed, abstract val/var are
represented in scalac as ``DefTree``, and the attached symbol has the ACCESSOR
flag set (that because the symbol that is attached to abstract val/var is
always the getter symbol, i.e., its accessor).

The fix consisted in simply not pruning ``DefTree`` that have the ACCESSOR flag
set (this fixed #1001173).

A nice side effect of the fix is that missing implementation of abstract val/var
are now reported in Java sources (which fixes #1001174).
Method references inside closures are now correctly reported
References of abstract fields are now correctly reported

Abstract fields cannot be represented in JDT (Java doesn't have abstract
fields, only methods can be abstract).  Therefore, when looking for the
``IJavaElement`` of an abstract val/var, its accessor (i.e., the getter)
is returned instead.
References of anonymous classes are now correctly reported

* Do not update the ``currentOwner`` for type bounds.
* Set the ``currentOwner`` of an annotation to be the member/class
declaration to which the annotation is applied to.
* Use ``getJavaElement`` instead of ``getElementAt`` for finding the
enclosing ``IJavaElement`` to be reported as result of the search.
Refactoring in FindReferencesTests
Re-enabled a few test
In ``testSearchIndexAnnotations``, look for exact matches of ``org.junit.Test``

This is a detail, and both ``SearchPattern.R_PREFIX_MATCH`` and
``SearchPattern.R_EXACT_MATCH`` work fine.  However, I think the latter better
express the intention of the test.
Correctly index referenced to var's assignments (i.e., calls to the setter)

When looking for reference of a field assignment, both calls to the var's
setter (i.e., assignment) and getter should be returned. For this to be
working, the ``ScalaIndexBuilder`` is now checking if the name of a ``RefTree``
is a setter name, and if that is so a reference to the getter name (which is
the actual field name) is instead added in the indexer.

An additional interesting point is the element selection in the editor. When in
the editor the user right click on an element to find his references, the
symbol attached to the selected code element is typecheck, and in the case of
an var assignement the typechecked symbol is the setter symbol, while for the
very same untyped (i.e., not typechecked) tree node the attached symbol is the
getter symbol.

In ``ScalaCompilationUnit.codeSelect`` setter symbols are turned into getter
ones because the ``ScalaIndexBuilder`` does not indexes the setter name, but
only the getter name (which is the actual var's name), as explained in the
first paragraph of this commit.
Merge pull request #162 from misto/issue/show-getter-name-when-renaming-1001177

When renaming a setter or variable, display the getter name.
Fix #1001167 - Corrected issue with finding references of method with a ``Int`` arg

Prevent a NPE when when comparing the signature of types that have no qualifier
(such as ``Int``).
Added alternative launch delegates for Scala Eclipse applications

The new launch delegates are added to the Equinox weaving launch
configurations, if available in the Eclipse setup.

Fix #1001158
Merge pull request #158 from skyluc/issue/scala-debugger-in-equinox-launchers-1001158

Added alternative launch delegates for Scala Eclipse applications
Merge pull request #163 from dotta/issue/find-ref-of-method-with-int-arg-1001167

Corrected NPE occurring when comparing the signature of types that have no qualifier (such as ``Int``).
Made `problemsOf` public, so it can be used from the worksheet.

Added helper method for handling responses.
More abstract dealings with Scala compilation units. 

We need a way to treat uniformly different kinds of Scala-based sources. Until now
we routed everything through `ScalaCompilationUnit`, that extends the JDT `CompilationUnit`
class. This tight connection is counter-productive, and in most cases, unnecessary.

This commit is a step towards extracting a set of interfaces for other Scala-based
sources to benefit of reconciliation ('errors-as-you-type'), hyperlinking and completion
engine that already exists.

* extracted `InteractiveCompilationUnit` as a super type of `ScalaCompilationUnit`
* switched from `ScalaCompilationUnit` to `InteractiveCompilationUnit` wherever possible, to allow
hyperlinking to work in the scala-worksheet project
* added a utility method to retrieve the compilation unit associated with an open editor that
uses the platform adapter protocol to allow other plugins to participate.
Add 'additionalCpEntries' to the Sbt builder.

This allows the worksheet to use the builder in order to compiler worksheets, 
without polluting the project class path.