| Commit message (Collapse) | Author | Age | Files | Lines |
| |
|
|
|
|
| |
A small dose of packedType closes SI-4869.
|
|
|
|
| |
Closes SI-3999. Review by @odersky.
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Implementing a warning for the behavior described in SI-1987 gave me
enough of a foot in the door to fix it rather than warning about it. I
suppose this is a variation of rubber ducky debugging.
% scalac -Ylog:typer test/files/run/t1987.scala
[log typer] !!! Overloaded package object member resolved incorrectly.
Discarded: def duh(n: Double): Unit
Using: val duh: (n: Double)Unit <and> (n: Long)Unit
Review by @odersky.
|
|\ |
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| | |
with null value"
This commit reverts the following two commits:
5f2568e36b87d183fd4e4442d5c304db628846c4 - "Revert "Accept prefixed xml attributes with null value"
b00002f9049c034510438881b4a4449d73fe2f54 - "Disabling some scaladoc tests."
and fixes a scaladoc test broken by:
4787f883604d1344257c0b40c15790c3dde477f2 - "Fixed equality and string representation of xml attributes with null value"
|
| | | |
| \ | |
| \ | |
| \ | |
|\ \ \ \
| |_|_|/
|/| | |
| | | | |
'soc/SI-4627' into develop
|
| |\ \ \
| | | | |
| | | | |
| | | | |
| | | | | |
Conflicts:
.gitignore
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
This implementation is based on AVL trees.
The current implementation is contributed by Lucien Pereira.
Fixes #4147.
|
| |/ / /
|/| | |
| | | |
| | | | |
Functions of functions use parens for grouping.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
There are too many potential optimizations unavailable to us due to the
lack of bright lines among different kinds of symbols. For instance the
difference between a TypeSymbol which represents a type alias and one
which represents an abstract type is only whether the DEFERRED flag
is set. This creates issues.
1) There are many (many) places where tests are performed on every symbol
which could be done more efficiently and (especially) more verifiably
correctly with polymorphism.
2) TypeRefs based on those symbols are also checking that flag
constantly, in perpetuity. A symbol created as an alias is never (to the
best of my knowledge) going to intentionally morph into one representing
an abstract type, nor vice versa.
3) One has no guarantees, because anyone can set or reset the DEFERRED
flag at any time.
So tackling more than one problem at once herein:
1) I created canonical symbol creation points which take the flags as
an argument, so that there can be a difference between initializing a
symbol's flags and setting/resetting them at arbitrary times.
2) I structured all the symbol creators to take arguments in the
same order, which is:
def newXXX(name: Name, ..., pos: Position = NoPosition, flags: Long = 0L)
(Where "..." is for those symbols which require something
beyond the name to create, such as a TypeSkolem's origin.)
The name is first because it's the only always required argument.
I left but deprecated the variations which take (pos, name).
3) I created subclasses of TypeRef based on the information which
should be stable from creation time onward:
- args or no args?
- abstract type, type alias, or class?
2x3 == 6 and that's how many subclasses of TypeRef there are now. So
now, for example, every TypeRef doesn't have to carry null symInfoCache
and thisInfoCache fields for the benefit of the minority which use them.
I still intend to realize the gain possible once we can evade the fields
for pre and args without losing pattern matcher efficiency.
|
| | | | |
|
| | | |
| | | |
| | | |
| | | |
| | | | |
This reverts commit 51089b34a7a535498dee42e6465d4d577d65b7d5.
A scaladoc test is failing and I have no time to look at it.
|
| |/ /
|/| |
| | |
| | |
| | |
| | | |
Now notices most things which look like main methods and says
something useful if they aren't usable as entry points.
Closes SI-4749.
|
| | | | |
| \ \ | |
| \ \ | |
| \ \ | |
|\ \ \ \ \
| | | | | |
| | | | | |
| | | | | | |
and 'szabolcsberecz/xml-attribute-fix'
|
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | | |
This changes makes PrefixedAttribute work the same way as
UnprefixedAttribute with respect to null values:
<t p:a={ null: String }/> is accepted and results in <t/>
|
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | | |
Prior to this patch <t a={ null: String }/> was not equal to <t/> and
it's string representation was "<t ></t>" instead of "<t></t>"
This includes changing MetaData.normalize() so that it doesn't reverse
the chain. On the downside, the iterate function in MetaData.normalize()
is not tail-recursive now.
|
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | | |
The reason why the test case compiled without error is pretty devious: When checking the `Foo.x' implicit, a CyclicReference error occurs which causes the alternative to be discarded. Why a CylicReference? Because the inferencer tries to decide whether the owner of `z` is a subclass of the owner od `x`. To do this, it computed the info of the owner of `z1`, which is not complete because no result type for `f1` was given. Hence a CyclicReference error.
The fix is twofold: (1) We make isNonBottomSubClass smarter so that it always returns false if the symbol in question is not a type; hence the info need not be computed. (2) It's dubious to swallow CyclicReference errors anywhere, but I deemed it too risky to propagate them. But at least the CyclicReference is now logged if -Ylog-implicit is true. This hopefully spares future maintainers the same detective work I had to go through when digging this out.
|
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | | |
Was going straight to the field and bypassing the null guard.
Closes SI-5300.
|
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | | | | |
I zeroed in on the actual conditions under which the parameter bounds
can be utilized without poisoning the well. Also fixed a bug in
ClassfileParser where it would get confused and set Any as a lower
bound, as well as a bug or at least misbehavior where a TypeBounds with
only Any/Nothing as an upper/lower bound would be treated differently
than one with no bound at all.
Review by @moors.
|
| |_|/ / /
|/| | | |
| | | | |
| | | | | |
Closes SI-3758.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
Misters hkarg and hkparam have to work harder to see
things from the same perspective, so they don't end up
in a huff over bounds which were the same all along.
Closes SI-5020, review by @moors.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
This sort of thing was crashing. No longer.
trait Fooz[Q <: Array[_]] { def f0(x: Q) = x.length }
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
Well, "fix" is pretty generous, how about "workaround".
It does seem to do the job. Closes SI-4070, review by @moors.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
% scala -Dscalac.debug.tvar
scala> class Foo[CC[X] <: Traversable[X]] { def bar[T](xs: CC[T]) = xs.head }
defined class Foo
scala> new Foo bar List(1,2,3)
[ create] ?CC ( In Foo[CC[X] <: Traversable[X]] )
[ create] ?CC ( In Foo[CC[X] <: Traversable[X]] )
[ setInst] Nothing ( In Foo[CC[X] <: Traversable[X]], CC=Nothing )
[ create] ?CC ( In Foo[CC[X] <: Traversable[X]] )
[ create] ?T ( In Foo[CC[X] <: Traversable[X]]#bar[T] )
[ create] ?A ( In List#apply[A] )
[ create] ?A ( In List#apply[A] )
[ setInst] Int ( In List#apply[A], A=Int )
[ create] ?CC ( In Foo[CC[X] <: Traversable[X]] )
[ create] ?T ( In Foo[CC[X] <: Traversable[X]]#bar[T] )
[ create] ?CC ( In Foo[CC[X] <: Traversable[X]] )
[ applyArgs] ?CC ( In Foo[CC[X] <: Traversable[X]], apply args ?T to CC )
[ setInst] List ( In Foo[CC[X] <: Traversable[X]], CC=List )
[ setInst] Int ( In Foo[CC[X] <: Traversable[X]]#bar[T], T=Int )
res0: Int = 1
Also, I gave TypeVar some polymorphism. Review by @moors.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
% scalac files/neg/t5357.scala
files/neg/t5357.scala:5: error: '=>' expected but ':' found.
case A: N => 1
^
one error found
That's uggo! Now it says:
% scalac files/neg/t5357.scala
files/neg/t5357.scala:5: error: Pattern variables must start with a lower-case letter. (SLS 8.1.1.)
case A: N => 1
^
one error found
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
I think I found an issue underlying more than one bit of sketchy
behavior amongst CC[_] and friends.
Plus, I managed to initialize TypeConstraints with the bounds of the
originating type parameter. I feel like that should cause something
nifty to happen somewhere, but I have seen neither confetti nor lasers
in greater quantities than I usually do. Will keep my remaining eye out.
Closes SI-5359, review by @moors.
|
| | | | |
| | | | |
| | | | |
| | | | | |
Making the inherited java vararg check cheaper.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
Reworked some old code which was far too expensive for the
job it was performing.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
It's too handy and I can't reach it from key classes whose
calls I want to profile.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
Sometime during the signature-related chaos before 2.9.1,
genjvm was modified to pin ACC_BRIDGE onto mixed-in methods.
This isn't necessary to suppress the signature (which has
already happened at that point) and has deleterious effects
since many tools ignore bridge methods. Review by @odersky.
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
Don't assume that just because someone is calling x.toInt
and x <: java.lang.Number, that it's a boxed primitive.
Closes SI-5356.
|
|/ / / /
| | | |
| | | |
| | | |
| | | |
| | | | |
The reason why the test case compiled without error is pretty devious: When checking the `Foo.x' implicit, a CyclicReference error occurs which causes the alternative to be discarded. Why a CylicReference? Because the inferencer tries to decide whether the owner of `z` is a subclass of the owner od `x`. To do this, it computed the info of the owner of `z1`, which is not complete because no result type for `f1` was given. Hence a CyclicReference error.
The fix is twofold: (1) We make isNonBottomSubClass smarter so that it always returns false if the symbol in question is not a type; hence the info need not be computed. (2) It's dubious to swallow CyclicReference errors anywhere, but I deemed it too risky to propagate them. But at least the CyclicReference is now logged if -Ylog-implicit is true. This hopefully spares future maintainers the same detective work I had to go through when digging this out.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
New command line option prints a message whenever the compiler
inserts an implicit conversion. Implicit parameters are not
under consideration here, since the primary motivation is to make
it easy to inspect your code for unintentional conversions, since
they can have dramatic performance implications.
class A {
def f(xs: Array[Byte]) = xs.size
def g(xs: Array[Byte]) = xs.length
}
% scalac -Xlog-implicit-conversions logImplicits.scala
logImplicits.scala:2: applied implicit conversion from xs.type to ?{val size: ?} = implicit def byteArrayOps(xs: Array[Byte]): scala.collection.mutable.ArrayOps[Byte]
def f(xs: Array[Byte]) = xs.size
^
|
|/ / /
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | | |
Fixing consecutive type application made it more obvious there was
another missing bit of the parser, type application following function
application. This should (and now does) work:
object F { def apply[T] = List[T]() }
def g() = F
g()[String]
|
| | |
| | |
| | |
| | |
| | |
| | |
| | | |
Custom versions of collections which methods which operate on 2 or 3
collections. Eliminated most users of zip/zipped. Cleaned up the kinds
checking code somewhat. Reduced the number of silent typechecks
being performed at named argument sites.
|
| | | |
|
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | | |
Implemented great suggestion from moors. More imports in power mode,
including the contents of treedsl. Also, another swing at overcoming
the mismatched global singletons problem, this time taking advantage of
dependent method types. Amazingly, it seems to work.
Continuing in the quest to create a useful compiler hacking environment,
there is now an implicit from Symbol which allows you to pretend a
Symbol takes type parameters, and the result is the applied type based
on the manifests of the type arguments and the type constructor of the
symbol. Examples:
// magic with manifests
scala> val tp = ArrayClass[scala.util.Random]
tp: $r.global.Type = Array[scala.util.Random]
// evidence
scala> tp.memberType(Array_apply)
res0: $r.global.Type = (i: Int)scala.util.Random
// treedsl
scala> val m = LIT(10) MATCH (CASE(LIT(5)) ==> FALSE, DEFAULT ==> TRUE)
m: $r.treedsl.global.Match =
10 match {
case 5 => false
case _ => true
}
// typed is in scope
scala> typed(m).tpe
res1: $r.treedsl.global.Type = Boolean
|
| | |
| | |
| | |
| | | |
Closes SI-5175.
|
|\ \ \ |
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
The parser through I think a quirk of history would not allow
back to back type applications, like
expr[T1, T2][T3, T4]
Now it does, meaning the only thing it can:
val n0 = Partial[immutable.HashMap][String][Int] ++ Seq(("a", 1))
val n1 = Partial.apply[immutable.HashMap].apply[String].apply[Int] ++ Seq(("a", 1))
assert(n0 == n1)
|
| | | | | |
| \ \ \ | |
| \ \ \ | |
| \ \ \ | |
|\ \ \ \ \ \
| |_|_|/ / /
|/| | | | |
| | | | | | |
'kepler/topic/reifyclosuretests', 'kepler/topic/antscalacheck', 'szabolcsberecz/SI-5104', 'kepler/ticket/5334' and 'kepler/topic/miscfixes' into develop
|
| | |/ / /
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | | |
The bug was caused by the inconsistency between j.l.Math.min() and
j.l.Double.compareTo() wrt NaN (j.l.Math.min() considers NaN to be
less than any other value while j.l.Double.compareTo() says it's
greater...)
The fix changes Ordering.{FloatOrdering,DoubleOrdering) to base
it's results on primitive comparisons and math.{min,max} instead
of j.l.{Float,Double}.compareTo()
|
|/ / / /
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
Changing NullaryMethodType to be a SimpleTypeProxy because nearly all
its operations forward to its result type was it seems not such a good
idea, because it also meant that calling .underlying returned the result
type rather than the method type. The way this materialized was in
subtype checks of refinement types. A lub is calculated for two nullary
method types in the course of calculating a refinement, and then the
input types are checked against the calculated lub.
However in the lub refinement, the nullary method type has become a bare
typeref, and so the subtype check failed. Closes SI-5317.
This does give me confidence that all the malformed lubs one sees
logged under -Ydebug (and there are still many, especially with type
constructors) are alerting us to real bugs elsewhere in Types.
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
1) introduce BodyTreeMaker to get rid of special casing for body
now each case is a list of TreeMakers rather than a pair of such a list and a tree
needed to do this since emitting switches requires access to the untranslated body
2) emitting switches
- alternatives are flattened: each alternative block ends with a jump to the next alternative (if there is one)
- to avoid stack overflow in typedMatch: detect when translateMatch returns a Match
the patch to uncurry would be nicer with an extractor, but that breaks due to a bug in old patmat
made trees into dags again -- NPE in erasure
tree.duplicate seems to break lambdalift because it
does not give fresh symbols (or trees?) to the valdefs
for the arguments of duplicated functions
duplicate enclosing tree, not subtrees
improved propagateSubstitution for AlternativesTreeMaker
- it now propagates to all its alternatives, so we don't have to do that in chainBefore
- by making propagation more regular, a bug in substitution in AlternativesTreeMaker manifested itself
it introduced a new binder, unnecessarily, which then was unbound -- now reusing binder of outer pattern
having removeSubstOnly in propagateSubstitution unveiled a bug: guard treemaker should substitute
move fixerUpper closer to what it fixes up
|
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | | |
TreeMakers (esp. CondTreeMakers) are approximated by hash-cons'ed Conds
sharing is detected for prefixes of Conds, and shared conditions are only tested once
their results are stored, and repeated tests branch on the last shared condition,
reusing the results from the first time they were checked
a Test is 1-to-1 with a TreeMaker, but may share its Cond
TODO: clean separation of the two translation strategies:
- naive flatMap/orElse (for virtualization)
- less-naive if-then-else (with CSE etc coming)
sharing trees caused wrong bytecode to be emitted (verifyerror)
tentative explanation:
"because lambdalift uses mutable state to track which variables have been captured
if you refer to the same variable with the same tree twice
it'll get confused"
Sent at 8:27 PM on Thursday
>> grzegorz.kossakowski: so we found a bug in jvm
according to http://java.sun.com/docs/books/jvms/second_edition/html/Instructions2.doc2.html
checkcast should throw a classcastexception
becuase it's a shorthand for if !(x instanceof T) throw ClassCastExcpt
but jvm decided to throw verifyerror
and yeah, the check is wrong
if jvm was not throwing verifyerror it would throw classcast exception
saying that ObjectRef cannot be casted to $colon$colon
...
>> me:
so now where does it come from?
since a ref is involved, i thought LambdaLift
>> grzegorz.kossakowski: yup
or now
I don't think lambalift introduces that kind of low-level casts
but I might be wrong
btw. it's interesting that it unpacks stuff from objectref twice
in your code
and in one place checkcast is correct
and in another is wrong
Sent at 9:33 PM on Thursday
>> grzegorz.kossakowski: also, since it's a verifyerror
I think genjvm should have an assertion
>> grzegorz.kossakowski:
193: getfield #54; //Field scala/runtime/ObjectRef.elem:Ljava/lang/Object;
196: checkcast #8; //class scala/runtime/ObjectRef
199: invokevirtual #95; //Method scala/collection/immutable/$colon$colon.tl$1:()Lscala/collection/immutable/List;
it's this
see
you have checkcast for ObjectRef
and then on that value, you try to call tl() method from List
Sent at 9:56 PM on Thursday
>> me: fixed
sharing trees is bad
very bad
because lambdalift uses mutable state to track which variables have been captured
if you refer to the same variable with the same tree twice
it'll get confused
|
|/ / /
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | | |
behold the mythical unapplyProd: it does not exist, yet it promises to speed up pattern matching on case classes
instead of calling the synthetic unapply/unapplySeq, we don't call the mythical synthetic unapplyProd,
since -- if it existed -- it would be the identity anyway for case classes
eventually, we will allow user-defined unapplyProd's, which should give you almost the same speed as case class matching
for user-defined extractors (i.e., you don't have to wrap in an option, just return something on which we can select _i for i = 1 to N, unless it is null, which indicates match failure)
still need to figure out a way to derive the types for the subpatterns, without requiring you to wrap your result in a ProductN
unapplyProd support for vararg case classes
using caseFieldAccessors instead of synthetic _i
now the compiler bootstraps again, and after this optimization, quick.lib overhead is 70%, quick.comp is 50%
(compiling with a locker built using -Yvirtpatmat, and itself generating code for -Yvirtpatmat)
before the optimization, I think the overhead for quick.comp was close to 100% in this scenario
more robust tupleSel for case classes
TODO:
- pos/t602 -- clean up after type inference as in fromCaseClassUnapply
- run/pf-catch -- implement new-style orElse for partial function in uncurry
|
|/ /
| |
| |
| | |
Otherwise they cause type errors.
|
| |
| |
| |
| | |
Let type parameter be inferred. Closes SI-4871.
|
| | |
|