Switch from IncOptions.copy to IncOptions.with* methods.

The copy method on IncOptions has been deprecated because it can't be
easily evolved in binary compatible way. As a replacement, with* methods
for parameter has been introduced. Let's switch to those methods, isntead.
Add support for IncOptions.{nameHashing, recompileOnMacroDef} flags

Add support for new incremental compiler options introduced in
sbt 0.13.2:

  * `nameHashing` that enables new (experimental) incremental compilation
    algorithm
  * `recompileOnMacroDef` that controls the behavior of a heuristic
     that takes care of invalidating of source files that depend on
     macros

Those two options are directly exposed as IDE project settings.

Other than that, I've made one small refactoring. We've switched to a new,
overloaded variant of `IC.readAnalysis` that takes IncOptions as an
argument. The new variant returns the right variant of analysis in both
cases when name hashing is enabled or disabled.

Fixed #1002117
Hides the Scala version chooser if runtime < 2.11

The possibility to build on different source level is only
available from Scala 2.11.
Do not show the UI if not applicable.
Merge pull request #701 from gkossakowski/name-hashing

Add support for name hashing
Merge pull request #705 from skyluc/issue/xsource-UI-only-for-211-and-better

Hides the Scala version chooser if runtime < 2.11
Filter both -Xsource and -Ymacro-expand options from the build compiler.

The two options are needed to put the presentation compiler in compatibility
mode, but they should not make it to the build compiler. (2.10 does replies
with `bad option:-Xsource`, for example)
Merge pull request #704 from dragos/issue/filter-macro-noexpand

Filter -Ymacro-expand from build compiler
Ease condition to show only tooltips in code completion

On constructor completion only the tooltip, which shows the name of all
the parameters that need to be inserted, should be shown. This may not
be the best behavior but this is how it works at the moment. The
condition that checks this can safely abort the whole method that should
insert the actual completion because there is nothing to insert.
Ease completion proposal logic
Move most non UI logic out of ScalaCompletionProposal

This contains no functional changes, it only introduces new methods.
Removal of unnecessary adjusting of cursor position

It turned out that in the completion proposal logic the whole logic to
adjust the cursor position is unnecessary because it can be done
together with applying the text change.

Furthermore it turned out that the dependency to the selection provider
can be removed as well because the text viewer which is needed and
provided by the selection provider is already passed to the completion
proposal.
Split up last mixed UI/Non UI parts in ScalaCompletionProposal

The logic that computes the text that should be inserted into the
document is now completely independent from the UI which means it is
possible to test the behavior of the code with our test suite.

The only functional change this introduces is that the method

    editor.selectAndReveal

is no longer implicitly called by

    EditorUtils.applyChangesToFileWhileKeepSelection

It is not necessary to call this method because there is no selection
kept after a code completion, only the position of the cursor needs to
be tracked, which is already done by

    EditorUtils.applyChangesToFile

Fixes #1001912
Reorganize content of ScalaCompletionProposal

- The last Non UI related stuff is moved out
- Private members are moved to the bottom of the class
- Private fields are moved to the top of the class
Refactorings in auto edit strategy test suite

The new design is more flexible and allows the addition of text
edit operations by the subclasses.
Add compiler support for text edit test suite
Add tests for completion overwrite feature
Move accessibility tests to new completion test suite

The only functional change is that the previous `normalizeCompletion`
method is no longer applied. This shouldn't be necessary because a
string representation of a completion proposal should be clearly defined
and therefore not change between Scala or scalac versions.
Move some completion test cases to new test suite

- Simplify CompilerSupport in TextEditTests. It turned out that most
  behavior is already defined in SDTTestUtils. The new implementation
  is also more correct as it turned out while implementing tests. The
  previous implementation created a ScalaSourceFile directly, but by
  doing this it is not correctly wired together with the compilation
  unit. Creating a compilation unit directly creates also a
  ScalaSourceFile implicitly which can then be used later in the test
  implementation.
- Some test cases are moved from core.completion.CompletionTests to
  core.ui.completion.StandardCompletionTests. For this move the test
  cases where simplified a little bit. They no longer check the internal
  representation of a copmletion proposal but how the completion is
  displayed to users and how the document is changed after the
  completion is applied.
Move more completion test cases to new test suite

All test cases that belong together are moved to the new test suite.
This does not include ignored tests that test behavior which is not
implemented yet. It does also not include tests that mostly test a
different part of the completion behavior. It turned out that #1001014
can be closed because it is fixed.

While writing these tests the new test suite had to be extended further
times. Nevertheless, there are still tests that can still not be
implemented with the new test suite - therefore these tests aren't moved
either.

Re #1001014
Create new parameter completion tests

At the moment all tests are still disabled and therefore the old ones
are not yet removed. This is because the behavior is only insufficient
implemented.