Don't avoid to load trait impl .class without inliner.

When the inliner is on, it is necessary to load class
files containing the implementation of traits, i.e.,
those ending in $class.class. This is needed to be
able to inline these methods. However it is useless
if the inliner is disabled.

The previous logic avoided to put these files on the
classpath when the inliner was off. However, this
complicates things, and it makes the classpath
mechanism dependent on something totally unrelated.

On this basis, this commit removes that logic, and
instead trait impl .class files are always kept on
the classpath.
Update of Eclipse project files

- Update of project dependencies
- Deletion of scala-xml project
- Deletion of scala-parser-combinators project
- Update of .gitignore to match nested .cache files
Add -Yno-load-impl-class disabling loading of $class.class files.

The parent commit, a3f71badf67bbaac1a4ba16f68211ea6e31aa473,
removed some logic preventing $class.class files to be
loaded. It did so only when the inliner was off.

Should this cause any issue, this option provides a means to
restore the old behavior by *never* loading $class.class files.

So, using -inline -Yno-load-impl-class will not load
$class.class files either (where previously -inline would
load them). The two old behaviors being available by *either*
using -inline *or* -Yno-load-impl-class (not both).
Updating Position call sites.

Calling position factories rather than instantiating these
particular classes. Not calling deprecated methods. Added a few
position combinator methods.
SI-7859 Value classes may wrap a non-public member

We allow value class constructors to be non-public, so to be regular,
we should also allow the same for the param accessor.

This commit uses the 'makeNotPrivate' machinery to ensure that
the backend can generate the requisite unboxing calls.

This commit:

  - refactors the code that enforced the restrictions, improving
    a few error messages and positions. The remaining restrictions
    needed some rewording in light of this change.
  - allows value classes to have non-public, val parameters.
    private[this] / protected[this] are still disallowed as value
    classes don't have a concept of `this`, and because trying to
    accomdate then would complicate the implementation.

    This means that `class C(x: Int) extends AnyVal` is not allowed,
    the user still must write `private val x: Int` or `val x: Int`.
  - Outlaw `class C()()(val x: Int) extends AnyVal` to curtail any
    bugs that might lurk in such a formulation.

The tests:

  - Show that the privacy is respected in the typer phase, under
    joint and separate compilation. We don't want a repeat performance
    of SI-6601.
  - Show that code that needs compiler-generated unboxes works under
    both compilation scenarios
  - Checks that the remaining restrictions are enforced and well
    communicated.
Merge pull request #3003 from paulp/pr/position-catchup

Updating Position call sites.
SI-7886 unsoundness in pattern matcher.

I tracked down what was behind the issue described here:

  // TODO: fix the illegal type bound in pos/t602 -- type inference
  // messes up before we get here:
  /*override def equals(x$1: Any): Boolean = ...
         // Span[Any] --> Any is not a legal type argument for Span!
         val o5: Option[com.mosol.sl.Span[Any]] =
  */

...which led straight to the unsoundness seen in neg/t7886.
It is dangerous to have an expected type of "Any" because
the type system will blithely ignore kind errors, since "Any"
can absorb anything. The consequence in this instance was
that inferring the case constructor for a type like

  Foo[T <: Bound]

if done with expected type Any, this would come up with Foo[Any].
I altered it to use expected type Foo[T], which lets the dummy
type parameter survive to carry the bound forward and restores
sense to the inference. The before/after output for -Xprint:patmat
on pos/t602.scala is:

15c15
<         if (x1.isInstanceOf[com.mosol.sl.Span[Any]])
---
>         if (x1.isInstanceOf[com.mosol.sl.Span[K]])
17c17
<             <synthetic> val x2: com.mosol.sl.Span[Any] = \
  (x1.asInstanceOf[com.mosol.sl.Span[Any]]: com.mosol.sl.Span[Any]);
---
>             <synthetic> val x2: com.mosol.sl.Span[K] = \
  (x1.asInstanceOf[com.mosol.sl.Span[K]]: com.mosol.sl.Span[K]);
19,20c19,20
<               val low$0: Option[Any] = x2.low;
<               val high$0: Option[Any] = x2.high;
---
>               val low$0: Option[K] = x2.low;
>               val high$0: Option[K] = x2.high;

A file in the library depended (needlessly) on the unsoundness.
It was easy to fix but reminds us this may affect existing code.
SI-6680 unsoundness in gadt typing.

Introduces -Xstrict-inference to deal with the significant
gap between soundness and what presently compiles. I'm hopeful
that it's TOO strict, because it finds e.g. 75 errors compiling
immutable/IntMap.scala, but it might be that bad.
Remove 'hasDefaultFlag'.

This is the change which broke the compiler until I made the
changes found in 693ecffbaf.
Removing unused code.

Most of this was revealed via -Xlint with a flag which assumes
closed world. I can't see how to check the assumes-closed-world
code in without it being an ordeal. I'll leave it in a branch in
case anyone wants to finish the long slog to the merge.
Merge pull request #3004 from paulp/pr/remove-unused

Remove unused code.
clearly establishes what macro bundles are

Previously it was enough to just extend scala.reflect.macros.Macro, which
created some loopholes, but now scalac enforces that bundles:
  1) Are static (not necessarily top-level, but just static)
  2) Are traits (objects shouldn't be bundles anyway, and classes bring
     complications with their ctors which require special treatment in
     generated classes, so why support them if they don't bring anything
     new to the table?)
  3) Are monomorphic (again, this brings unnecessary complications wrt
     auxiliary code generation, so I don't see merit in supporting
     polymorphic bundles, whatever that a polymorphic bundle could mean)
  4) Don't provide concrete implementation for Macro.c (if they do then
     what is the point?)
gets rid of randomness in virtual filenames for bundles

Bundles are emitted in compilation units that wrap virtual source files.
Previously we had those virtual files named randomly to ensure freshness,
but that led to infinite compilation loops in SBT (see the commit message
for more details and a link to a scala-user discussion).

Now the names are generated deterministically from full names of bundles,
which fixes the problems with SBT.
macro bundles are now usable in repl

One of the previous commits relaxed the top-level restriction for bundles,
turning it into a requirement of staticness (i.e. bundles nested in static
objects are also okay now).

This means that we can now define bundles in repl. Almost.

There's still a little problem remaining that arises from the fact that
when compiling a line of input, repl doesn't automatically import all
previously defined symbols, but rather uses an heuristic to scan the
input and guess what symbols need to be imported.

Unfortunately for bundles, this heuristic fails, because when scanning
a macro definition that looks like `def foo = macro Macros.foo`, it thinks
that it's only necessary to import a term symbol called Macros (a vanilla
way of defining macro impls), but not a type symbol called Macros (a new
way of writing macro impls in bundles).

This commit fixes the problem by making the repl look for both term and
type symbols corresponding to the identifiers used in macro definitions.
Merge pull request #2977 from sjrd/topic/remove-classpath-logic-dependent-on-inline

Don't avoid to load trait impl .class without inliner.
Merge pull request #2994 from xeno-by/topic/bundles

assorted fixes for bundles
Merge pull request #2965 from retronym/ticket/7859

SI-7859 Value classes may wrap a non-public member
Rework cff8b569 to heal the windows build.

 - change newTermName to fix negative length names
   rather than reject them
 - restore the old logic in unspecializedName for names that
   result from AnyRef specialized type parameters.

Why does fix the windows build? I remain none the wiser.
Merge pull request #2973 from sschaef/eclipse-update3

Update of Eclipse project files
Merge pull request #3013 from retronym/topic/unspec-fix-windows

Rework cff8b569 to heal the windows build.