diff options
author | Grzegorz Kossakowski <grzegorz.kossakowski@gmail.com> | 2014-02-23 23:18:38 +0100 |
---|---|---|
committer | Grzegorz Kossakowski <grzegorz.kossakowski@gmail.com> | 2014-02-23 23:18:38 +0100 |
commit | 5c84255b6783a0ff21999d0b7456b2d7ff5ee953 (patch) | |
tree | 5adc14578378138d8bb6880fa11dbd8b80575ae6 /src | |
parent | efa99c01974febe227937f090afbb93b9a6a59a5 (diff) | |
parent | c001b888b896989a2c0afa0c24d038502970151c (diff) | |
download | scala-5c84255b6783a0ff21999d0b7456b2d7ff5ee953.tar.gz scala-5c84255b6783a0ff21999d0b7456b2d7ff5ee953.tar.bz2 scala-5c84255b6783a0ff21999d0b7456b2d7ff5ee953.zip |
Merge pull request #3559 from adriaanm/t1503
SI-1503 don't assume unsound type for ident/literal patterns
Diffstat (limited to 'src')
3 files changed, 55 insertions, 4 deletions
diff --git a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala index a6b69e239f..d007df75e3 100644 --- a/src/compiler/scala/reflect/reify/codegen/GenTypes.scala +++ b/src/compiler/scala/reflect/reify/codegen/GenTypes.scala @@ -34,9 +34,9 @@ trait GenTypes { if (tsym.isClass && tpe == tsym.typeConstructor && tsym.isStatic) Select(Select(reify(tsym), nme.asType), nme.toTypeConstructor) else tpe match { - case tpe @ NoType => + case tpe : NoType.type => reifyMirrorObject(tpe) - case tpe @ NoPrefix => + case tpe : NoPrefix.type => reifyMirrorObject(tpe) case tpe @ ThisType(root) if root.isRoot => mirrorBuildCall(nme.thisPrefix, mirrorMirrorSelect(nme.RootClass)) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index dc4969be43..2893cbdf45 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -16,6 +16,56 @@ trait TreeAndTypeAnalysis extends Debugging { import definitions._ import analyzer.Typer + /** Compute the type T implied for a value `v` matched by a pattern `pat` (with expected type `pt`). + * + * Usually, this is the pattern's type because pattern matching implies instance-of checks. + * + * However, Stable Identifier and Literal patterns are matched using `==`, + * which does not imply a type for the binder that binds the matched value. + * + * See SI-1503, SI-5024: don't cast binders to types we're not sure they have + * + * TODO: update spec as follows (deviation between `**`): + * + * A pattern binder x@p consists of a pattern variable x and a pattern p. + * The type of the variable x is the static type T **IMPLIED BY** the pattern p. + * This pattern matches any value v matched by the pattern p + * **Deleted: , provided the run-time type of v is also an instance of T, ** + * and it binds the variable name to that value. + * + * Addition: + * A pattern `p` _implies_ a type `T` if the pattern matches only values of the type `T`. + */ + def binderTypeImpliedByPattern(pat: Tree, pt: Type, binder: Symbol): Type = + pat match { + // because `==` decides whether these patterns match, stable identifier patterns (ident or selection) + // do not contribute any type information (beyond the pattern's expected type) + // e.g., in case x@Nil => x --> all we know about `x` is that it satisfies Nil == x, which could be anything + case Ident(_) | Select(_, _) => + if (settings.future) pt + else { + // TODO: don't warn unless this unsound assumption is actually used in a cast + // I tried annotating the type returned here with an internal annotation (`pat.tpe withAnnotation UnsoundAssumptionAnnotation`), + // and catching it in the patmat backend when used in a cast (because that would signal the unsound assumption was used), + // but the annotation didn't bubble up... + // This is a pretty poor approximation. + def unsoundAssumptionUsed = binder.name != nme.WILDCARD && !(pt <:< pat.tpe) + if (settings.lint && unsoundAssumptionUsed) + global.currentUnit.warning(pat.pos, + sm"""The value matched by $pat is bound to ${binder.name}, which may be used under the + |unsound assumption that it has type ${pat.tpe}, whereas we can only safely + |count on it having type $pt, as the pattern is matched using `==` (see SI-1503).""") + + pat.tpe + } + + + // the other patterns imply type tests, so we can safely assume the binder has the pattern's type when the pattern matches + // concretely, a literal, type pattern, a case class (the constructor's result type) or extractor (the unapply's argument type) all imply type tests + // (and, inductively, an alternative) + case _ => pat.tpe + } + // we use subtyping as a model for implication between instanceof tests // i.e., when S <:< T we assume x.isInstanceOf[S] implies x.isInstanceOf[T] // unfortunately this is not true in general: diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index fa96d98bcc..8a3ceb3aca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -4080,9 +4080,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } val body1 = typed(body, mode, pt) + val impliedType = patmat.binderTypeImpliedByPattern(body1, pt, sym) // SI-1503, SI-5204 val symTp = - if (treeInfo.isSequenceValued(body)) seqType(body1.tpe) - else body1.tpe + if (treeInfo.isSequenceValued(body)) seqType(impliedType) + else impliedType sym setInfo symTp // have to imperatively set the symbol for this bind to keep it in sync with the symbols used in the body of a case |