| Commit message (Collapse) | Author | Age | Files | Lines |
|
|
|
|
|
|
| |
The check was already in place for direct calls to the super constructor.
Without this additional check, ExplicitOuter crashes, as it doesn't create
an $outer pointer for the constructor-arg scoped inner object, but expects
one to exist when transforming the Outer.this reference.
|
|\
| |
| | |
classtag => classmanifest conversion no longer requires runtime universe
|
| | |
|
|\ \
| | |
| | | |
Wip sensible deprecation msgs √
|
| | | |
|
| | | |
|
| | | |
|
| | | |
|
| |/
|/| |
|
| |
| |
| |
| |
| |
| |
| | |
Wow, I wonder what the upper bound is on how long I might have chased my
tail before finding this. I know what the lower bound is, unfortunately.
It's just that usually the answer to a mystery is not "the empty package
class has magically become the root class, but only sometimes."
|
|\ \
| | |
| | | |
Fixups to Future task stack
|
| |/
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| | |
This fixes a bug where _taskStack could batch a task
into the wrong executor, as previously commented in the
code.
It now uses the _taskStack machinery for the Future.apply
dispatch in addition to callback dispatch, so we can batch
Future(body) as well.
Less significantly, it micro-optimizes by combining some
different closures and Runnable into a Task object, so
there aren't as many objects created when storing and
dispatching a callback. So it saves a bit of memory
and runtime perhaps.
|
|\ \
| |/
|/| |
fixes a checkinit problem
|
| | |
|
|\ \
| | |
| | | |
Suppress non-local return unchecked warnings.
|
| | |
| | |
| | |
| | |
| | | |
There doesn't seem to be any way to do that by adding
a synthetic annotation.
|
|/ / |
|
| |
| |
| |
| |
| | |
* forkjoin.done/forkjoine.clean can test forkjoin source
* fjbg.done/fjbg.clean can test fjbg source.
|
|\ \
| | |
| | | |
SI-5696 Detect excess constructor argument lists.
|
| | |
| | |
| | |
| | | |
An apply method fooled the usual mechanism.
|
|/ /
| |
| |
| |
| |
| |
| |
| |
| | |
If the target method is defined in Java, treat the super reference
as an error, otherwise allow it in the knowledge that Scala loosens
the access restrictions on its generated classes.
Moves the test for that bug out of pending-ville. It's sufficient
to place Test in the empty package to exercise the right code paths.
|
|\ \
| | |
| | | |
SI-4831 Fix ambiguous import detection for renamed imports.
|
| |/ |
|
|\ \
| | |
| | | |
An IntelliJ module for reflect.
|
| |/ |
|
|/
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Consts are hashconsed modulo static-approximation-for-dynamic-value-equality
thus, two value-equality tests in patterns should reuse the same ValueConst
if and only if the tested values are guaranteed to be equal in all possible executions
the implementation uses unique types to track unique consts
for an Ident with a stable symbol, we simply use the corresponding singleton type
for a Select, we have to indirect some more: we store all the unique trees we've encountered and a unique type for each of them
this unique type is then used to find the uniqut const that approximates the run-time value
this may seem roundabout, but we need to standardize on types for representing "value" tests,
as a type test against a singleton type must give rise to the same ValueConst
as a value test using a tree that refers to the same symbol as the singleton type test
|
| |
|
|\
| |
| | |
SI-5167 An impl class method should refer to its own parameter symbols.
|
| |
| |
| |
| |
| |
| |
| |
| | |
Rather than those of the original method in the trait.
If they are shared, parameter renaming in the implementaion class
is visible in the original method. This led to a crash in the resident
compiler when looking up the default argument getter.
|
|\ \
| | |
| | | |
SI-5652 Mangle names of potentially public lambda lifted methods.
|
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | | |
This can happen if they are accessed from an inner class. If a
subclass is happens to lift a public method to the same name,
a VerifyError ensues.
The enclosed tests:
- demonstrate the absense of the VerifyError
- show the names generated for the lifted methods (which are
unchanged if not called from an inner class, or if lifted
into a trait implementation class.)
- ensure that the callers are rewritten to call the correct
method when multiple with the same name are lifted.
It's not ideal that this phase needs a priori knowledge of the
later phases to perform this mangling. A better fix would defer
this until the point when the methods are publicised, and leave
the unmangled private method in place and install an public,
mangled forwarder.
|
|\ \ \
| | | |
| | | | |
Fix SI-5853.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
This solves two issues.
First, up to now the newly generated symbols for normalized
members were not being added to the declaration list of the
owner during `specialize`. Now they are.
Second, during `extmethods`, the extension methods generated
get an additional curried parameter list for `$this`.
Trouble was, after that, during `uncurry` and before `specialize`,
these curried parameter lists were merged into one list.
Specialization afterwards treats extension methods just
like normal methods and generates new symbols without the
curried parameter list.
The `extensionMethod` now takes this into account by checking
if the first parameter of a potential extension method has
the name `$this`.
Review by @dragos.
Review by @odersky.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
Compile Global or Typers twice in resident mode yielded a CyclicReference error, in phase erasure. The error was due to a cyclic call of isDerivedValue class. Checking I noted that isDerivedValue class is called very often, and mostly unneccessesarily. I tightened teh condition to not force the type of the class if it is a trait or package. This made the CyclicReference go away.
Widened criterion that enables validation of derived value classes. Previous version made two neg tests slip through.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
Reduce time spent in lubs by making depth more adaptive. It now takes into account separately the depth of the lub types and the maximal depth of theior base type sequences. It cuts depth more aggressively if it is the base types instead of the types themselves that grow deep.
The old truncation behavior is retained under option -Xfull-lubs
Another change is that we now track depth more precisely, which should also help or at least allow better statistics.
Also added statistics that measure #lubs and time spent in them.
|
| | | | |
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
the pattern `(_: T)` is made checkable using (ct: ClassTag[T]).unapply
by rewriting it to `ct(_: T)` (if there's a ClassTag[T] available)
similarly for extractors: if the formal type of the unapply method
is an uncheckable type, wrap in the corresponding classtag extractor (if available)
don't trigger rewrite on non-toplevel unchecked types
(i.e., only look at type constructor part of T when looking for unchecked types)
TODO: find outer match to figure out if we're supposed to be unchecked
would like to give users a chance to opt-out from the wrapping,
but finding the match to which this pattern belongs turned out to be tricky...
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
before, an unapply call would be derived from a case SomeClass(_, ..., _) pattern,
where SomeClass is a valid constructor reference, and thus also a reference to an
unapply-bearing companion object
this assumption is going to be violated once we start using class tags to make
uncheckable type tests checkable, since we could encounter unapply calls like
{<method calls that construct classTag>}.unapply(<arg>)
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | | |
Review by @dragos, @jsuereth. Required bootstrapping because the starr was
ant tasks were invoking locker with -Ysourcepath instead of -sourcepath.
|
| | | | |
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | | |
This protects everyone from the confusion caused by stuff like this:
https://issues.scala-lang.org/browse/SI-5884
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
Before 2.10 we had a notion of ClassManifest that could be used to retain
erasures of abstract types (type parameters, abstract type members) for
being used at runtime.
With the advent of ClassManifest (and its subtype Manifest)
it became possible to write:
def mkGenericArray[T: Manifest] = Array[T]()
When compiling array instantiation, scalac would use a ClassManifest
implicit parameter from scope (in this case, provided by a context bound)
to remember Ts that have been passed to invoke mkGenericArray and
use that information to instantiate arrays at runtime (via Java reflection).
When redesigning manifests into what is now known as type tags, we decided
to explore a notion of ArrayTags that would stand for abstract and pure array
creators. Sure, ClassManifests were perfectly fine for this job, but they did
too much - technically speaking, one doesn't necessarily need a java.lang.Class
to create an array. Depending on a platform, e.g. within JavaScript runtime,
one would want to use a different mechanism.
As tempting as this idea was, it has also proven to be problematic.
First, it created an extra abstraction inside the compiler. Along with class tags
and type tags, we had a third flavor of tags - array tags. This has threaded the
additional complexity though implicits and typers.
Second, consequently, when redesigning tags multiple times over the course of
Scala 2.10.0 development, we had to carry this extra abstraction with us, which
exacerbated the overall feeling towards array tags.
Finally, array tags didn't fit into the naming scheme we had for tags.
Both class tags and type tags sound logical, because, they are descriptors for
the things they are supposed to tag, according to their names.
However array tags are the odd ones, because they don't actually tag any arrays.
As funny as it might sound, the naming problem was the last straw
that made us do away with the array tags. Hence this commit.
|
| | | |
| | | |
| | | |
| | | |
| | | | |
More information can be found here:
https://groups.google.com/group/scala-internals/msg/138efc5476751269
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
Finally, -sourcepath is split into:
-Ysourcepath - for the library bootstrapping
-doc-source-path - for scaladoc links to source code
(squished the resident compiler test fix into this commit)
Review by @jsuereth.
|
| | | |
| | | |
| | | |
| | | | |
This is the first step of factoring out scala-reflect.jar.
|