Permalink
Browse files

Merge remote-tracking branch 'origin/2.11.x' into merge/2.11.x-to-2.1…

…2.x-20161220

 Conflicts:
	bincompat-backward.whitelist.conf
	build.xml
	src/compiler/scala/tools/nsc/typechecker/Typers.scala
	src/library/scala/collection/immutable/NumericRange.scala
  • Loading branch information...
2 parents 56fb917 + 23548c4 commit 079e8dc61704a768792c6b210a5b0cd25522ee55 @retronym retronym committed Dec 20, 2016
Showing with 474 additions and 58 deletions.
  1. +0 −26 bincompat-backward.whitelist.conf
  2. +1 −1 project/plugins.sbt
  3. +3 −3 spec/04-basic-declarations-and-definitions.md
  4. +2 −2 spec/12-the-scala-standard-library.md
  5. +59 −2 src/compiler/scala/tools/nsc/javac/JavaParsers.scala
  6. +2 −0 src/compiler/scala/tools/nsc/javac/JavaScanners.scala
  7. +43 −17 src/compiler/scala/tools/nsc/typechecker/Typers.scala
  8. +7 −2 src/library/scala/collection/immutable/NumericRange.scala
  9. +2 −0 src/reflect/scala/reflect/internal/StdNames.scala
  10. +1 −0 test/files/neg/t0903.check
  11. +1 −0 test/files/neg/t1215.check
  12. +34 −0 test/files/neg/t3236-neg.check
  13. +17 −0 test/files/neg/t3236-neg/AnnotationTest.scala
  14. +7 −0 test/files/neg/t3236-neg/BooleanAnnotation.java
  15. +25 −0 test/files/neg/t3236-neg/Constants.java
  16. +7 −0 test/files/neg/t3236-neg/IntAnnotation.java
  17. +7 −0 test/files/neg/t3236-neg/ShortAnnotation.java
  18. +7 −0 test/files/neg/t3236-neg/StringAnnotation.java
  19. +6 −0 test/files/neg/t8763.check
  20. +11 −0 test/files/neg/t8763.scala
  21. +9 −0 test/files/neg/t9834.check
  22. +6 −0 test/files/neg/t9834.scala
  23. +33 −0 test/files/run/t3236/AnnotationTest.scala
  24. +7 −0 test/files/run/t3236/BooleanAnnotation.java
  25. +7 −0 test/files/run/t3236/ByteAnnotation.java
  26. +7 −0 test/files/run/t3236/CharAnnotation.java
  27. +34 −0 test/files/run/t3236/Constants.java
  28. +7 −0 test/files/run/t3236/DoubleAnnotation.java
  29. +7 −0 test/files/run/t3236/FloatAnnotation.java
  30. +7 −0 test/files/run/t3236/IntAnnotation.java
  31. +7 −0 test/files/run/t3236/LongAnnotation.java
  32. +7 −0 test/files/run/t3236/ShortAnnotation.java
  33. +7 −0 test/files/run/t3236/StringAnnotation.java
  34. +44 −0 test/files/run/t3236/Test.scala
  35. +39 −0 test/junit/scala/collection/immutable/RangeConsistencyTest.scala
  36. +4 −5 test/junit/scala/tools/testing/AssertUtil.scala
@@ -32,32 +32,6 @@ filter {
{
matchName="scala.sys.process.ProcessImpl#CompoundProcess.getExitValue"
problemName=DirectMissingMethodProblem
- },
- # these next seven can be removed once there is a fix for
- # https://github.com/typesafehub/migration-manager/issues/147
- {
- matchName="scala.collection.Iterator#Leading#1.hd_="
- problemName=DirectMissingMethodProblem
- },
- {
- matchName="scala.collection.Iterator#Leading#1.hd"
- problemName=DirectMissingMethodProblem
- },
- {
- matchName="scala.collection.Iterator#Leading#1.status_="
- problemName=DirectMissingMethodProblem
- },
- {
- matchName="scala.collection.Iterator#Leading#1.lookahead_="
- problemName=DirectMissingMethodProblem
- },
- {
- matchName="scala.collection.Iterator#Leading#1.status"
- problemName=DirectMissingMethodProblem
- },
- {
- matchName="scala.collection.Iterator#Leading#1.lookahead"
- problemName=DirectMissingMethodProblem
}
]
}
View
@@ -19,4 +19,4 @@ buildInfoKeys := Seq[BuildInfoKey](buildClasspath)
buildInfoPackage := "scalabuild"
-libraryDependencies += "com.typesafe" %% "mima-reporter" % "0.1.12"
+libraryDependencies += "com.typesafe" %% "mima-reporter" % "0.1.13"
@@ -404,7 +404,7 @@ function definitions. In this section we consider only type parameter
definitions with lower bounds `>: $L$` and upper bounds
`<: $U$` whereas a discussion of context bounds
`: $U$` and view bounds `<% $U$`
-is deferred to [here](07-implicit-parameters-and-views.html#context-bounds-and-view-bounds).
+is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
The most general form of a first-order type parameter is
`$@a_1 \ldots @a_n$ $\pm$ $t$ >: $L$ <: $U$`.
@@ -587,7 +587,7 @@ FunDef ::= FunSig [‘:’ Type] ‘=’ Expr
FunSig ::= id [FunTypeParamClause] ParamClauses
FunTypeParamClause ::= ‘[’ TypeParam {‘,’ TypeParam} ‘]’
ParamClauses ::= {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’]
-ParamClause ::= [nl] ‘(’ [Params] ‘)’}
+ParamClause ::= [nl] ‘(’ [Params] ‘)’
Params ::= Param {‘,’ Param}
Param ::= {Annotation} id [‘:’ ParamType] [‘=’ Expr]
ParamType ::= Type
@@ -686,7 +686,7 @@ The by-name modifier is disallowed for parameters of classes that
carry a `val` or `var` prefix, including parameters of case
classes for which a `val` prefix is implicitly generated. The
by-name modifier is also disallowed for
-[implicit parameters](07-implicit-parameters-and-views.html#implicit-parameters).
+[implicit parameters](07-implicits.html#implicit-parameters).
###### Example
The declaration
@@ -141,7 +141,7 @@ Byte - Short
whereas `Double` is the highest-ranked. Ranking does _not_
imply a [conformance relationship](03-types.html#conformance); for
instance `Int` is not a subtype of `Long`. However, object
-[`Predef`](#the-predef-object) defines [views](07-implicit-parameters-and-views.html#views)
+[`Predef`](#the-predef-object) defines [views](07-implicits.html#views)
from every numeric value type to all higher-ranked numeric value types.
Therefore, lower-ranked types are implicitly converted to higher-ranked types
when required by the [context](06-expressions.html#implicit-conversions).
@@ -467,7 +467,7 @@ val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK
The instantiation of an array with a polymorphic element type $T$ requires
information about type $T$ at runtime.
-This information is synthesized by adding a [context bound](07-implicit-parameters-and-views.html#context-bounds-and-view-bounds)
+This information is synthesized by adding a [context bound](07-implicits.html#context-bounds-and-view-bounds)
of `scala.reflect.ClassTag` to type $T$.
An example is the
following implementation of method `mkArray`, which creates
@@ -572,10 +572,48 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: TermName): ValDef = {
val tpt1 = optArrayBrackets(tpt)
- if (in.token == EQUALS && !mods.isParameter) skipTo(COMMA, SEMI)
+
+ /** Tries to detect final static literals syntactically and returns a constant type replacement */
+ def optConstantTpe(): Tree = {
+ def constantTpe(const: Constant): Tree = TypeTree(ConstantType(const))
+
+ def forConst(const: Constant): Tree = {
+ if (in.token != SEMI) tpt1
+ else {
+ def isStringTyped = tpt1 match {
+ case Ident(TypeName("String")) => true
+ case _ => false
+ }
+ if (const.tag == StringTag && isStringTyped) constantTpe(const)
+ else if (tpt1.tpe != null && (const.tag == BooleanTag || const.isNumeric)) {
+ // for example, literal 'a' is ok for float. 127 is ok for byte, but 128 is not.
+ val converted = const.convertTo(tpt1.tpe)
+ if (converted == null) tpt1
+ else constantTpe(converted)
+ } else tpt1
+ }
+ }
+
+ in.nextToken() // EQUALS
+ if (mods.hasFlag(Flags.STATIC) && mods.isFinal) {
+ val neg = in.token match {
+ case MINUS | BANG => in.nextToken(); true
+ case _ => false
+ }
+ tryLiteral(neg).map(forConst).getOrElse(tpt1)
+ } else tpt1
+ }
+
+ val tpt2: Tree =
+ if (in.token == EQUALS && !mods.isParameter) {
+ val res = optConstantTpe()
+ skipTo(COMMA, SEMI)
+ res
+ } else tpt1
+
val mods1 = if (mods.isFinal) mods &~ Flags.FINAL else mods | Flags.MUTABLE
atPos(pos) {
- ValDef(mods1, name, tpt1, blankExpr)
+ ValDef(mods1, name, tpt2, blankExpr)
}
}
@@ -831,6 +869,25 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
case _ => in.nextToken(); syntaxError("illegal start of type declaration", skipIt = true); List(errorTypeTree)
}
+ def tryLiteral(negate: Boolean = false): Option[Constant] = {
+ val l = in.token match {
+ case TRUE => !negate
+ case FALSE => negate
+ case CHARLIT => in.name.charAt(0)
+ case INTLIT => in.intVal(negate).toInt
+ case LONGLIT => in.intVal(negate)
+ case FLOATLIT => in.floatVal(negate).toFloat
+ case DOUBLELIT => in.floatVal(negate)
+ case STRINGLIT => in.name.toString
+ case _ => null
+ }
+ if (l == null) None
+ else {
+ in.nextToken()
+ Some(Constant(l))
+ }
+ }
+
/** CompilationUnit ::= [package QualId semi] TopStatSeq
*/
def compilationUnit(): Tree = {
@@ -89,6 +89,7 @@ trait JavaScanners extends ast.parser.ScannersCommon {
javanme.ELSEkw -> ELSE,
javanme.ENUMkw -> ENUM,
javanme.EXTENDSkw -> EXTENDS,
+ javanme.FALSEkw -> FALSE,
javanme.FINALkw -> FINAL,
javanme.FINALLYkw -> FINALLY,
javanme.FLOATkw -> FLOAT,
@@ -118,6 +119,7 @@ trait JavaScanners extends ast.parser.ScannersCommon {
javanme.THROWkw -> THROW,
javanme.THROWSkw -> THROWS,
javanme.TRANSIENTkw -> TRANSIENT,
+ javanme.TRUEkw -> TRUE,
javanme.TRYkw -> TRY,
javanme.VOIDkw -> VOID,
javanme.VOLATILEkw -> VOLATILE,
@@ -4624,22 +4624,55 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
val appStart = if (Statistics.canEnable) Statistics.startTimer(failedApplyNanos) else null
val opeqStart = if (Statistics.canEnable) Statistics.startTimer(failedOpEqNanos) else null
- def onError(reportError: => Tree): Tree = fun match {
- case Select(qual, name)
- if !mode.inPatternMode && nme.isOpAssignmentName(newTermName(name.decode)) && !qual.exists(_.isErroneous) =>
+ def isConversionCandidate(qual: Tree, name: Name): Boolean =
+ !mode.inPatternMode && nme.isOpAssignmentName(TermName(name.decode)) && !qual.exists(_.isErroneous)
+ def reportError(error: SilentTypeError): Tree = {
+ error.reportableErrors foreach context.issue
+ error.warnings foreach { case (p, m) => context.warning(p, m) }
+ args foreach (arg => typed(arg, mode, ErrorType))
+ setError(tree)
+ }
+ def advice1(convo: Tree, errors: List[AbsTypeError], err: SilentTypeError): List[AbsTypeError] =
+ errors.map { e =>
+ if (e.errPos == tree.pos) {
+ val header = f"${e.errMsg}%n Expression does not convert to assignment because:%n "
+ val expansion = f"%n expansion: ${show(convo)}"
+ NormalTypeError(tree, err.errors.flatMap(_.errMsg.lines.toList).mkString(header, f"%n ", expansion))
+ } else e
+ }
+ def advice2(errors: List[AbsTypeError]): List[AbsTypeError] =
+ errors.map { e =>
+ if (e.errPos == tree.pos) {
+ val msg = f"${e.errMsg}%n Expression does not convert to assignment because receiver is not assignable."
+ NormalTypeError(tree, msg)
+ } else e
+ }
+ def onError(error: SilentTypeError): Tree = fun match {
+ case Select(qual, name) if isConversionCandidate(qual, name) =>
val qual1 = typedQualifier(qual)
if (treeInfo.isVariableOrGetter(qual1)) {
if (Statistics.canEnable) Statistics.stopTimer(failedOpEqNanos, opeqStart)
- convertToAssignment(fun, qual1, name, args)
+ val erred = qual1.isErroneous || args.exists(_.isErroneous)
+ if (erred) reportError(error) else {
+ val convo = convertToAssignment(fun, qual1, name, args)
+ silent(op = _.typed1(convo, mode, pt)) match {
+ case SilentResultValue(t) => t
+ case err: SilentTypeError => reportError(SilentTypeError(advice1(convo, error.errors, err), error.warnings))
+ }
+ }
}
else {
if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, appStart)
- reportError
+ val Apply(Select(qual2, _), args2) = tree
+ val erred = qual2.isErroneous || args2.exists(_.isErroneous)
+ reportError {
+ if (erred) error else SilentTypeError(advice2(error.errors), error.warnings)
+ }
}
case _ =>
if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, appStart)
- reportError
+ reportError(error)
}
val silentResult = silent(
op = _.typed(fun, mode.forFunMode, funpt),
@@ -4664,13 +4697,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
tryTypedApply(fun2, args)
else
doTypedApply(tree, fun2, args, mode, pt)
- case err: SilentTypeError =>
- onError({
- err.reportableErrors foreach context.issue
- err.warnings foreach { case (p, m) => context.warning(p, m) }
- args foreach (arg => typed(arg, mode, ErrorType))
- setError(tree)
- })
+ case err: SilentTypeError => onError(err)
}
}
@@ -4713,7 +4740,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
Select(vble.duplicate, prefix) setPos fun.pos.focus, args) setPos tree.pos.makeTransparent
) setPos tree.pos
- def mkUpdate(table: Tree, indices: List[Tree]) = {
+ def mkUpdate(table: Tree, indices: List[Tree]) =
gen.evalOnceAll(table :: indices, context.owner, context.unit) {
case tab :: is =>
def mkCall(name: Name, extraArgs: Tree*) = (
@@ -4728,9 +4755,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
)
case _ => EmptyTree
}
- }
- val tree1 = qual match {
+ val assignment = qual match {
case Ident(_) =>
mkAssign(qual)
@@ -4746,7 +4772,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
case _ => UnexpectedTreeAssignmentConversionError(qual)
}
}
- typed1(tree1, mode, pt)
+ assignment
}
def typedSuper(tree: Super) = {
@@ -114,13 +114,18 @@ extends AbstractSeq[T] with IndexedSeq[T] with Serializable {
import NumericRange.defaultOrdering
override def min[T1 >: T](implicit ord: Ordering[T1]): T =
- if (ord eq defaultOrdering(num)) {
+ // We can take the fast path:
+ // - If the Integral of this NumericRange is also the requested Ordering
+ // (Integral <: Ordering). This can happen for custom Integral types.
+ // - The Ordering is the default Ordering of a well-known Integral type.
+ if ((ord eq num) || defaultOrdering.get(num).exists(ord eq _)) {
if (num.signum(step) > 0) head
else last
} else super.min(ord)
override def max[T1 >: T](implicit ord: Ordering[T1]): T =
- if (ord eq defaultOrdering(num)) {
+ // See comment for fast path in min().
+ if ((ord eq num) || defaultOrdering.get(num).exists(ord eq _)) {
if (num.signum(step) > 0) last
else head
} else super.max(ord)
@@ -1110,6 +1110,7 @@ trait StdNames {
final val ELSEkw: TermName = kw("else")
final val ENUMkw: TermName = kw("enum")
final val EXTENDSkw: TermName = kw("extends")
+ final val FALSEkw: TermName = kw("false")
final val FINALkw: TermName = kw("final")
final val FINALLYkw: TermName = kw("finally")
final val FLOATkw: TermName = kw("float")
@@ -1139,6 +1140,7 @@ trait StdNames {
final val THROWkw: TermName = kw("throw")
final val THROWSkw: TermName = kw("throws")
final val TRANSIENTkw: TermName = kw("transient")
+ final val TRUEkw: TermName = kw("true")
final val TRYkw: TermName = kw("try")
final val VOIDkw: TermName = kw("void")
final val VOLATILEkw: TermName = kw("volatile")
@@ -1,4 +1,5 @@
t0903.scala:3: error: value += is not a member of Int
+ Expression does not convert to assignment because receiver is not assignable.
x += 1
^
t0903.scala:4: error: reassignment to val
@@ -1,4 +1,5 @@
t1215.scala:2: error: value += is not a member of Int
+ Expression does not convert to assignment because receiver is not assignable.
val x = 1 += 1
^
one error found
@@ -0,0 +1,34 @@
+AnnotationTest.scala:3: error: annotation argument needs to be a constant; found: Constants.ConstIdent
+ @IntAnnotation(Constants.ConstIdent)
+ ^
+AnnotationTest.scala:4: error: annotation argument needs to be a constant; found: Constants.ConstSelect
+ @IntAnnotation(Constants.ConstSelect)
+ ^
+AnnotationTest.scala:6: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr1
+ @IntAnnotation(Constants.ConstOpExpr1)
+ ^
+AnnotationTest.scala:7: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr2
+ @IntAnnotation(Constants.ConstOpExpr2)
+ ^
+AnnotationTest.scala:8: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr3
+ @BooleanAnnotation(Constants.ConstOpExpr3)
+ ^
+AnnotationTest.scala:9: error: annotation argument needs to be a constant; found: Constants.ConstOpExpr4
+ @IntAnnotation(Constants.ConstOpExpr4)
+ ^
+AnnotationTest.scala:10: error: annotation argument needs to be a constant; found: Constants.NonFinalConst
+ @IntAnnotation(Constants.NonFinalConst)
+ ^
+AnnotationTest.scala:11: error: value NonStaticConst is not a member of object Constants
+ @IntAnnotation(Constants.NonStaticConst)
+ ^
+AnnotationTest.scala:12: error: value NonConst is not a member of object Constants
+ @IntAnnotation(Constants.NonConst)
+ ^
+AnnotationTest.scala:13: error: annotation argument needs to be a constant; found: Constants.ConstCastExpr
+ @ShortAnnotation(Constants.ConstCastExpr)
+ ^
+AnnotationTest.scala:15: error: annotation argument needs to be a constant; found: Constants.StringAdd
+ @StringAnnotation(Constants.StringAdd)
+ ^
+11 errors found
@@ -0,0 +1,17 @@
+trait AnnotationTest {
+ @IntAnnotation(Constants.ConstInt) // ok
+ @IntAnnotation(Constants.ConstIdent)
+ @IntAnnotation(Constants.ConstSelect)
+ @IntAnnotation(Constants.NegatedInt) // ok
+ @IntAnnotation(Constants.ConstOpExpr1)
+ @IntAnnotation(Constants.ConstOpExpr2)
+ @BooleanAnnotation(Constants.ConstOpExpr3)
+ @IntAnnotation(Constants.ConstOpExpr4)
+ @IntAnnotation(Constants.NonFinalConst)
+ @IntAnnotation(Constants.NonStaticConst)
+ @IntAnnotation(Constants.NonConst)
+ @ShortAnnotation(Constants.ConstCastExpr)
+ @StringAnnotation(Constants.ConstString) // ok
+ @StringAnnotation(Constants.StringAdd)
+ def test: Unit
+}
@@ -0,0 +1,7 @@
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface BooleanAnnotation {
+ boolean value();
+}
Oops, something went wrong.

0 comments on commit 079e8dc

Please sign in to comment.