| Commit message (Collapse) | Author | Age | Files | Lines |
|---|
| ... | |
| |
|
|
| |
Previously, the filterDisjoint forced the signature computation too eagerly, which led to a stub for AnyRef.
|
| | |
|
| |
|
|
| |
This is a debugging measure (maybe migrate to a different setting?)
|
| |
|
|
| |
Constructors are handled anyway in computeNPMembersNamed
|
| |
|
|
|
|
|
|
|
|
|
|
| |
1) Accessibility check was broken because it looked at symbol's owner, where it should have looked at context owner.
2) Refined treatement if members. Previously, nonPrivate member returned a subset of member, i.e. those denotations returned by member that were not private. This is not correct. In a situation like
class A { def x: Int = 1 }
class B { private def x: String = "" } extends A
(new B).x
the non-private member returned should be A#x. Changed membersNamed and friends as well as checkAccessible to account for that.
|
| |
|
|
| |
Need to do Symbol.apply(...) instead of new Symbol(...) because symbols are hash-consed and the constructor is private. This slipped through because of the wholes in accessibility checks which will be fixed in the next commit.
|
| |
|
|
| |
Needs to unwrap parameters. While we are at it, breaking out common functionality in underlyingClassRef.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
1) get Method
The idea is that if a case class has exactly one case field, then that field is returned as result of the get method. If it has more than one, it is a subtype of Product and the fields are returned by the _i methods.
2) unapply: Boolean
If a class has no case fields the unapply method returns true, rather than the this.
3) Self names
A self clause
{ self => ...
if now desugared to
{ self: C =>
where C is the type of the class.
|
| |
|
|
| |
apply method.
|
| |
|
|
| |
Type parameters of classes have to be entered before the class is completed.
|
| |
|
|
| |
Namer refactorings that break out the functionality for class completing into a separate class. We need to enter type parameters early in a second step.
|
| |
|
|
| |
To avoid duplication between by-name parameters and expr types, we treat by-name parameters as as having ExprType. A part of this is introducing ByNameTypeTree, a specific tree class for => T types.
|
| |
|
|
| |
... as all other show methods do.
|
| |
|
|
| |
Annotaton and argument appeared in reversed order.
|
| |
|
|
| |
These need to have their paramAccessor and other flags removed, leaving only Param.
|
| | |
|
| |
|
|
|
|
| |
traits except Java modules.
We now assume that all classes or traits (with the exception of Java statics) have a constructor.
|
| |
|
|
|
|
| |
Previously, alias type refs were also accepted. But this is the wrong assumption for computeMembersNames. So, e.g. instead of leaving an AnyRef we now expand to Object.
Also making ==, != take an Any instead of Object
|
| |
|
|
| |
Otherwise type comparers will go wrong.
|
| |
|
|
|
|
|
| |
1) Desugar type bounds containing empty trees
2) Include a productN parent for a case class, only if the case class has 2 or more parameters in its parameter section.
Also, handle type bounds appearing in AppliedTypeTrees (these represent wildcard types).
|
| | |
|
| |
|
|
|
|
|
|
|
|
|
|
| |
We need to take account of the possibility of inserting a () argument list in normalization. Otherwise, a type with a
def toString(): String
member would not count as a valid solution for ?{toString: String}. This would then lead to an implicit insertion, with a nice explosion of inference search because of course every implicit result has some sort
of toString method.
The problem is solved by dereferencing nullary method types if the corresponding function type is not
compatible with the prototype.
|
| | |
|
| | |
|
| |
|
|
| |
Changed format of UnApply nodes to also take implicit parameters. See doc comment in class Trees.UnApply
|
| |
|
|
|
|
|
|
|
|
| |
This is quite drastic. The problem is, we do not really know what to do with annotations in types. In a case demonstrated by dotc.ast.CheckTrees, a substitution of type parameter T in
class Trees[-T @uncheckedVariance]
gave us Trees[Type @uncheckedVariance], which messed up type inference in implicit search afterwards. In the case above, we clearly want to lose the annotation if the underlying type is not a type variable. Even if the underlying type is a type variable, the annotation looks wrong, since it should apply only to T, not that other variable. So the safest route seems to be to just drop the annotation.
That was a specific case, how to draft a general rule? In the absense of a better idea, it seems safest to always drop type annotations if the underlying type changes in a transformation. If some map does not want that behavior it would have to implement the AnnotatedType case explicitly.
|
| | |
|
| |
|
|
| |
Shadowing got confused if the shadowing expression truned out to be a closure.
|
| | |
|
| |
|
|
|
|
|
|
|
| |
Previously, if the result of an unapply arg type is a type with isDefined and get methods, we proceed as follows:
if the get result type is a product: take the produce argument types
otherwise take the get result type itself
The problem is if the get result type is an empty product. We solve this by demanding that the get result type is a ProductN type, not just a subclass of product.
|
| |
|
|
|
|
|
|
| |
1. Shadowing tree uses adaptation funProto of prototype. Previously many shadowing tries failed with errors like "need to follow with "_" to adapt to function". These early failures hid potential shadowing conflicts.
2. Shadowing conflict testing is now done using symbols instead of comparing references. Comparing references gave false negative when a shadoing tree had inferred type parameters, for instance. There were other problems as well. Generally, comparsing references seems too fragile.
3. Inferred views are now re-adapted. This is necessary if the view itself takes another implicit parameter.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Faced with a pattern like
Apply(x, xs)
we first look for an Apply object which is an extractor. If this fails, we now
interprete Apply as a type. If it is a type alias which points to a class type that
has a companion module, we then try that companion module as an extractor.
Scala 2.x does ot that way, and it's used widely within dotty itself. Think tpd.Apply as the found object,
Trees.Apply as the extractor.
Also, added a fix to normalization which made normalization go deep into a method type.
|
| | |
|
| | |
|
| | |
|
| |
|
|
| |
The previous addition of checkClassTypeWithStablePrefix to Namer#classSig needs to be adjusted.
|
| |
|
|
|
| |
The previous treatment would force all members, causing cyclic reference errors.
We fix it by filtering early in computeMemberNames itself for implicits.
|
| | |
|
| |
|
|
| |
Previously, we did not strip off the => when comparing against expected type.
|
| |
|
|
|
|
|
| |
Fixes for
var x: T = _
super.f(...)
|
| |
|
|
| |
Plus some small tweaks in Typer
|
| | |
|
| |
|
|
| |
Was only needed as a parameter to a continuation, so it seemed easier to just pass the components directly.
|
| | |
|
| | |
|
| | |
|
| | |
|
| |
|
|
|
|
| |
Also fixes to typedReturn.
Adapted tests accordingly.
|
| | |
|
| | |
|
