diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala index 747500465c0a..05333bfb778c 100644 --- a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala +++ b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala @@ -13,6 +13,7 @@ import typer.ProtoTypes.{newTypeVar, representedParamRef} import UnificationDirection.* import NameKinds.AvoidNameKind import util.SimpleIdentitySet +import NullOpsDecorator.stripNull /** Methods for adding constraints and solving them. * @@ -627,8 +628,11 @@ trait ConstraintHandling { * 1. If `inst` is a singleton type, or a union containing some singleton types, * widen (all) the singleton type(s), provided the result is a subtype of `bound`. * (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint) - * 2. If `inst` is a union type, approximate the union type from above by an intersection - * of all common base types, provided the result is a subtype of `bound`. + * 2a. If `inst` is a union type and `widenUnions` is true, approximate the union type + * from above by an intersection of all common base types, provided the result + * is a subtype of `bound`. + * 2b. If `inst` is a union type and `widenUnions` is false, turn it into a hard + * union type (except for unions | Null, which are kept in the state they were). * 3. Widen some irreducible applications of higher-kinded types to wildcard arguments * (see @widenIrreducible). * 4. Drop transparent traits from intersections (see @dropTransparentTraits). @@ -641,10 +645,12 @@ trait ConstraintHandling { * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it, * as those could leak the annotation to users (see run/inferred-repeated-result). */ - def widenInferred(inst: Type, bound: Type)(using Context): Type = + def widenInferred(inst: Type, bound: Type, widenUnions: Boolean)(using Context): Type = def widenOr(tp: Type) = - val tpw = tp.widenUnion - if (tpw ne tp) && (tpw <:< bound) then tpw else tp + if widenUnions then + val tpw = tp.widenUnion + if (tpw ne tp) && (tpw <:< bound) then tpw else tp + else tp.hardenUnions def widenSingle(tp: Type) = val tpw = tp.widenSingletons @@ -664,6 +670,23 @@ trait ConstraintHandling { wideInst.dropRepeatedAnnot end widenInferred + /** Convert all toplevel union types in `tp` to hard unions */ + extension (tp: Type) private def hardenUnions(using Context): Type = tp.widen match + case tp: AndType => + tp.derivedAndType(tp.tp1.hardenUnions, tp.tp2.hardenUnions) + case tp: RefinedType => + tp.derivedRefinedType(tp.parent.hardenUnions, tp.refinedName, tp.refinedInfo) + case tp: RecType => + tp.rebind(tp.parent.hardenUnions) + case tp: HKTypeLambda => + tp.derivedLambdaType(resType = tp.resType.hardenUnions) + case tp: OrType => + val tp1 = tp.stripNull + if tp1 ne tp then tp.derivedOrType(tp1.hardenUnions, defn.NullType) + else tp.derivedOrType(tp.tp1.hardenUnions, tp.tp2.hardenUnions, soft = false) + case _ => + tp + /** The instance type of `param` in the current constraint (which contains `param`). * If `fromBelow` is true, the instance type is the lub of the parameter's * lower bounds; otherwise it is the glb of its upper bounds. However, @@ -672,10 +695,10 @@ trait ConstraintHandling { * The instance type is not allowed to contain references to types nested deeper * than `maxLevel`. */ - def instanceType(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int)(using Context): Type = { + def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int)(using Context): Type = { val approx = approximation(param, fromBelow, maxLevel).simplified if fromBelow then - val widened = widenInferred(approx, param) + val widened = widenInferred(approx, param, widenUnions) // Widening can add extra constraints, in particular the widened type might // be a type variable which is now instantiated to `param`, and therefore // cannot be used as an instantiation of `param` without creating a loop. @@ -683,7 +706,7 @@ trait ConstraintHandling { // (we do not check for non-toplevel occurences: those should never occur // since `addOneBound` disallows recursive lower bounds). if constraint.occursAtToplevel(param, widened) then - instanceType(param, fromBelow, maxLevel) + instanceType(param, fromBelow, widenUnions, maxLevel) else widened else diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala index b5fe41095516..5c8c7633945b 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala @@ -487,7 +487,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling // If LHS is a hard union, constrain any type variables of the RHS with it as lower bound // before splitting the LHS into its constituents. That way, the RHS variables are - // constraint by the hard union and can be instantiated to it. If we just split and add + // constrained by the hard union and can be instantiated to it. If we just split and add // the two parts of the LHS separately to the constraint, the lower bound would become // a soft union. def constrainRHSVars(tp2: Type): Boolean = tp2.dealiasKeepRefiningAnnots match @@ -495,23 +495,46 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling case AndType(tp21, tp22) => constrainRHSVars(tp21) && constrainRHSVars(tp22) case _ => true - widenOK - || joinOK - || (tp1.isSoft || constrainRHSVars(tp2)) && recur(tp11, tp2) && recur(tp12, tp2) - || containsAnd(tp1) - && !joined - && { - joined = true - try inFrozenGadt(recur(tp1.join, tp2)) - finally joined = false - } - // An & on the left side loses information. We compensate by also trying the join. - // This is less ad-hoc than it looks since we produce joins in type inference, - // and then need to check that they are indeed supertypes of the original types - // under -Ycheck. Test case is i7965.scala. - // On the other hand, we could get a combinatorial explosion by applying such joins - // recursively, so we do it only once. See i14870.scala as a test case, which would - // loop for a very long time without the recursion brake. + /** Mark toplevel type vars in `tp2` as hard in the current typerState */ + def hardenTypeVars(tp2: Type): Unit = tp2.dealiasKeepRefiningAnnots match + case tvar: TypeVar if constraint.contains(tvar.origin) => + state.hardVars += tvar + case tp2: TypeParamRef if constraint.contains(tp2) => + hardenTypeVars(constraint.typeVarOfParam(tp2)) + case tp2: AndOrType => + hardenTypeVars(tp2.tp1) + hardenTypeVars(tp2.tp2) + case _ => + + val res = widenOK + || joinOK + || (tp1.isSoft || constrainRHSVars(tp2)) && recur(tp11, tp2) && recur(tp12, tp2) + || containsAnd(tp1) + && !joined + && { + joined = true + try inFrozenGadt(recur(tp1.join, tp2)) + finally joined = false + } + // An & on the left side loses information. We compensate by also trying the join. + // This is less ad-hoc than it looks since we produce joins in type inference, + // and then need to check that they are indeed supertypes of the original types + // under -Ycheck. Test case is i7965.scala. + // On the other hand, we could get a combinatorial explosion by applying such joins + // recursively, so we do it only once. See i14870.scala as a test case, which would + // loop for a very long time without the recursion brake. + + if res && !tp1.isSoft then + // We use a heuristic here where every toplevel type variable on the right hand side + // is marked so that it converts all soft unions in its lower bound to hard unions + // before it is instantiated. The reason is that the union might have come from + // (decomposed and reconstituted) `tp1`. But of course there might be false positives + // where we also treat unions that come from elsewhere as hard unions. Or the constraint + // that created the union is ultimately thrown away, but the type variable will + // stay marked. So it is a coarse measure to take. But it works in the obvious cases. + hardenTypeVars(tp2) + + res case CapturingType(parent1, refs1) => if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1) @@ -2960,8 +2983,8 @@ object TypeComparer { def subtypeCheckInProgress(using Context): Boolean = comparing(_.subtypeCheckInProgress) - def instanceType(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type = - comparing(_.instanceType(param, fromBelow, maxLevel)) + def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type = + comparing(_.instanceType(param, fromBelow, widenUnions, maxLevel)) def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type = comparing(_.approximation(param, fromBelow, maxLevel)) @@ -2981,8 +3004,8 @@ object TypeComparer { def addToConstraint(tl: TypeLambda, tvars: List[TypeVar])(using Context): Boolean = comparing(_.addToConstraint(tl, tvars)) - def widenInferred(inst: Type, bound: Type)(using Context): Type = - comparing(_.widenInferred(inst, bound)) + def widenInferred(inst: Type, bound: Type, widenUnions: Boolean)(using Context): Type = + comparing(_.widenInferred(inst, bound, widenUnions)) def dropTransparentTraits(tp: Type, bound: Type)(using Context): Type = comparing(_.dropTransparentTraits(tp, bound)) diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala index c087aac83cb8..35afab770259 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala @@ -537,7 +537,9 @@ object TypeOps: override def apply(tp: Type): Type = tp match case tp: TypeVar if mapCtx.typerState.constraint.contains(tp) => val lo = TypeComparer.instanceType( - tp.origin, fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound)(using mapCtx) + tp.origin, + fromBelow = variance > 0 || variance == 0 && tp.hasLowerBound, + widenUnions = tp.widenUnions)(using mapCtx) val lo1 = apply(lo) if (lo1 ne lo) lo1 else tp case _ => diff --git a/compiler/src/dotty/tools/dotc/core/TyperState.scala b/compiler/src/dotty/tools/dotc/core/TyperState.scala index 81b60c608e28..94f85d5c1dd7 100644 --- a/compiler/src/dotty/tools/dotc/core/TyperState.scala +++ b/compiler/src/dotty/tools/dotc/core/TyperState.scala @@ -25,19 +25,20 @@ object TyperState { type LevelMap = SimpleIdentityMap[TypeVar, Integer] - opaque type Snapshot = (Constraint, TypeVars, LevelMap) + opaque type Snapshot = (Constraint, TypeVars, TypeVars, LevelMap) extension (ts: TyperState) def snapshot()(using Context): Snapshot = - (ts.constraint, ts.ownedVars, ts.upLevels) + (ts.constraint, ts.ownedVars, ts.hardVars, ts.upLevels) def resetTo(state: Snapshot)(using Context): Unit = - val (constraint, ownedVars, upLevels) = state + val (constraint, ownedVars, hardVars, upLevels) = state for tv <- ownedVars do if !ts.ownedVars.contains(tv) then // tv has been instantiated tv.resetInst(ts) ts.constraint = constraint ts.ownedVars = ownedVars + ts.hardVars = hardVars ts.upLevels = upLevels } @@ -91,6 +92,14 @@ class TyperState() { def ownedVars: TypeVars = myOwnedVars def ownedVars_=(vs: TypeVars): Unit = myOwnedVars = vs + /** The set of type variables `tv` such that, if `tv` is instantiated to + * its lower bound, top-level soft unions in the instance type are converted + * to hard unions instead of being widened in `widenOr`. + */ + private var myHardVars: TypeVars = _ + def hardVars: TypeVars = myHardVars + def hardVars_=(tvs: TypeVars): Unit = myHardVars = tvs + private var upLevels: LevelMap = _ /** Initializes all fields except reporter, isCommittable, which need to be @@ -103,6 +112,7 @@ class TyperState() { this.myConstraint = constraint this.previousConstraint = constraint this.myOwnedVars = SimpleIdentitySet.empty + this.myHardVars = SimpleIdentitySet.empty this.upLevels = SimpleIdentityMap.empty this.isCommitted = false this @@ -114,6 +124,7 @@ class TyperState() { val ts = TyperState().init(this, this.constraint) .setReporter(reporter) .setCommittable(committable) + ts.hardVars = this.hardVars ts.upLevels = upLevels ts @@ -180,6 +191,7 @@ class TyperState() { constr.println(i"committing $this to $targetState, fromConstr = $constraint, toConstr = ${targetState.constraint}") if targetState.constraint eq previousConstraint then targetState.constraint = constraint + targetState.hardVars = hardVars if !ownedVars.isEmpty then ownedVars.foreach(targetState.includeVar) else targetState.mergeConstraintWith(this) @@ -238,6 +250,7 @@ class TyperState() { val otherLos = other.lower(p) val otherHis = other.upper(p) val otherEntry = other.entry(p) + if that.hardVars.contains(tv) then this.myHardVars += tv ( (otherLos eq constraint.lower(p)) || otherLos.forall(_ <:< p)) && ( (otherHis eq constraint.upper(p)) || otherHis.forall(p <:< _)) && ((otherEntry eq constraint.entry(p)) || otherEntry.match diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala index 935d22d14de2..b2a9e876b8a3 100644 --- a/compiler/src/dotty/tools/dotc/core/Types.scala +++ b/compiler/src/dotty/tools/dotc/core/Types.scala @@ -4714,12 +4714,16 @@ object Types { * is also a singleton type. */ def instantiate(fromBelow: Boolean)(using Context): Type = - val tp = TypeComparer.instanceType(origin, fromBelow, nestingLevel) + val tp = TypeComparer.instanceType(origin, fromBelow, widenUnions, nestingLevel) if myInst.exists then // The line above might have triggered instantiation of the current type variable myInst else instantiateWith(tp) + /** Widen unions when instantiating this variable in the current context? */ + def widenUnions(using Context): Boolean = + !ctx.typerState.hardVars.contains(this) + /** For uninstantiated type variables: the entry in the constraint (either bounds or * provisional instance value) */ diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala index e6426cc54cd5..ad8d0e50d348 100644 --- a/compiler/src/dotty/tools/dotc/typer/Namer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala @@ -1888,7 +1888,7 @@ class Namer { typer: Typer => TypeOps.simplify(tp.widenTermRefExpr, if defaultTp.exists then TypeOps.SimplifyKeepUnchecked() else null) match case ctp: ConstantType if sym.isInlineVal => ctp - case tp => TypeComparer.widenInferred(tp, pt) + case tp => TypeComparer.widenInferred(tp, pt, widenUnions = true) // Replace aliases to Unit by Unit itself. If we leave the alias in // it would be erased to BoxedUnit. diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala index 2e49e0c8bb58..e3f5382ecad7 100644 --- a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala @@ -514,7 +514,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context): val tparams = poly.paramRefs val variances = childClass.typeParams.map(_.paramVarianceSign) val instanceTypes = tparams.lazyZip(variances).map((tparam, variance) => - TypeComparer.instanceType(tparam, fromBelow = variance < 0) + TypeComparer.instanceType(tparam, fromBelow = variance < 0, widenUnions = true) ) val instanceType = resType.substParams(poly, instanceTypes) // this is broken in tests/run/i13332intersection.scala, diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala index 36e600faefc6..d802ef0df973 100644 --- a/compiler/src/dotty/tools/dotc/typer/Typer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala @@ -2847,7 +2847,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer if (ctx.mode.is(Mode.Pattern)) app1 else { val elemTpes = elems.lazyZip(pts).map((elem, pt) => - TypeComparer.widenInferred(elem.tpe, pt)) + TypeComparer.widenInferred(elem.tpe, pt, widenUnions = true)) val resTpe = TypeOps.nestedPairs(elemTpes) app1.cast(resTpe) } diff --git a/tests/pos/i14770.scala b/tests/pos/i14770.scala new file mode 100644 index 000000000000..182ccba21fdf --- /dev/null +++ b/tests/pos/i14770.scala @@ -0,0 +1,25 @@ +type UndefOr[A] = A | Unit + +extension [A](maybe: UndefOr[A]) + def foreach(f: A => Unit): Unit = + maybe match + case () => () + case a: A => f(a) + +trait Foo +trait Bar + +object Baz: + var booBap: Foo | Bar = _ + +def z: UndefOr[Foo | Bar] = ??? + +@main +def main = + z.foreach(x => Baz.booBap = x) + +def test[A](v: A | Unit): A | Unit = v +val x1 = test(5: Int | Unit) +val x2 = test(5: String | Int | Unit) +val _: Int | Unit = x1 +val _: String | Int | Unit = x2