Merge pull request scala#2878 from JamesIry/2.10.3

Merge 2.10.2 into 2.10.3

Author: JamesIry

src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala

@@ -44,8 +44,6 @@ abstract class ClassfileParser {
 
   def srcfile = srcfile0
 
-  private def currentIsTopLevel = !(currentClass.decodedName containsChar '$')
-
   private object unpickler extends scala.reflect.internal.pickling.UnPickler {
     val global: ClassfileParser.this.global.type = ClassfileParser.this.global
   }
@@ -515,8 +513,10 @@ abstract class ClassfileParser {
       }
     }
 
-    val c = if (currentIsTopLevel) pool.getClassSymbol(nameIdx) else clazz
-    if (currentIsTopLevel) {
+    val isTopLevel = !(currentClass containsChar '$') // Java class name; *don't* try to to use Scala name decoding (SI-7532)
+
+    val c = if (isTopLevel) pool.getClassSymbol(nameIdx) else clazz
+    if (isTopLevel) {
       if (c != clazz) {
         if ((clazz eq NoSymbol) && (c ne NoSymbol)) clazz = c
         else mismatchError(c)

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -997,22 +997,11 @@ trait Implicits {
             if (settings.Xdivergence211.value) DivergingImplicitExpansionError(tree, pt, DivergentImplicitRecovery.sym)(context)
             else throw DivergentImplicit
           }
-          else if (invalidImplicits.nonEmpty) {
-            val sym = invalidImplicits.head
-            // We don't even dare look if errors are being buffered
-            // !sym.hasFlag(LOCKED) is a hail mary between SI-2206 and SI-7486
-            def isSensibleAddendum = !sym.hasFlag(LOCKED) && (pt match {
-              case Function1(_, out) => out <:< sym.tpe.finalResultType
-              case _                 => pt <:< sym.tpe.finalResultType
-            })
-            // Don't pitch in with this theory unless it looks plausible that the
-            // implicit would have helped
+
+          if (invalidImplicits.nonEmpty)
             setAddendum(pos, () =>
-              if (isSensibleAddendum)
-                s"\n Note: implicit $sym is not applicable here because it comes after the application point and it lacks an explicit result type"
-              else ""
+              s"\n Note: implicit ${invalidImplicits.head} is not applicable here because it comes after the application point and it lacks an explicit result type"
             )
-          }
         }
 
         best

src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala

@@ -284,11 +284,13 @@ trait NamesDefaults { self: Analyzer =>
               case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => expr.tpe
               case _                                       => seqType(arg.tpe)
             }
-            else
-              // Note stabilizing can lead to a non-conformant argument when existentials are involved, e.g. neg/t3507-old.scala, hence the filter.
-              // We have to deconst or types inferred from literal arguments will be Constant(_), e.g. pos/z1730.scala.
-              gen.stableTypeFor(arg).filter(_ <:< paramTpe).getOrElse(arg.tpe).deconst
-          )
+            else {
+              // TODO In 83c9c764b, we tried to a stable type here to fix SI-7234. But the resulting TypeTree over a
+              //      singleton type without an original TypeTree fails to retypecheck after a resetLocalAttrs (SI-7516),
+              //      which is important for (at least) macros.
+              arg.tpe
+            }
+          ).widen // have to widen or types inferred from literal defaults will be singletons
           val s = context.owner.newValue(unit.freshTermName("x$"), arg.pos) setInfo {
             val tp = if (byName) functionType(Nil, argTpe) else argTpe
             uncheckedBounds(tp)
@@ -334,9 +336,12 @@ trait NamesDefaults { self: Analyzer =>
           // type the application without names; put the arguments in definition-site order
           val typedApp = doTypedApply(tree, funOnly, reorderArgs(namelessArgs, argPos), mode, pt)
           typedApp match {
-            // Extract the typed arguments, restore the call-site evaluation order (using
-            // ValDef's in the block), change the arguments to these local values.
-            case Apply(expr, typedArgs) if !(typedApp :: typedArgs).exists(_.isErrorTyped) => // bail out with erroneous args, see SI-7238
+            case Apply(expr, typedArgs) if (typedApp :: typedArgs).exists(_.isErrorTyped) =>
+              setError(tree) // bail out with and erroneous Apply *or* erroneous arguments, see SI-7238, SI-7509
+            case Apply(expr, typedArgs) =>
+              // Extract the typed arguments, restore the call-site evaluation order (using
+              // ValDef's in the block), change the arguments to these local values.
+
               // typedArgs: definition-site order
               val formals = formalTypes(expr.tpe.paramTypes, typedArgs.length, removeByName = false, removeRepeated = false)
               // valDefs: call-site order

src/reflect/scala/reflect/internal/Types.scala

@@ -3226,10 +3226,9 @@ trait Types extends api.Types { self: SymbolTable =>
           sameLength(typeArgs, tp.typeArgs) && {
             val lhs = if (isLowerBound) tp.typeArgs else typeArgs
             val rhs = if (isLowerBound) typeArgs else tp.typeArgs
-            // this is a higher-kinded type var with same arity as tp.
-            // side effect: adds the type constructor itself as a bound
-            addBound(tp.typeConstructor)
-            isSubArgs(lhs, rhs, params, AnyDepth)
+            // This is a higher-kinded type var with same arity as tp.
+            // If so (see SI-7517), side effect: adds the type constructor itself as a bound.
+            isSubArgs(lhs, rhs, params, AnyDepth) && { addBound(tp.typeConstructor); true }
           }
         }
         // The type with which we can successfully unify can be hidden

test/files/neg/t7509.check

@@ -0,0 +1,12 @@
+t7509.scala:3: error: inferred type arguments [Int] do not conform to method crash's type parameter bounds [R <: AnyRef]
+  crash(42)
+  ^
+t7509.scala:3: error: type mismatch;
+ found   : Int(42)
+ required: R
+  crash(42)
+        ^
+t7509.scala:3: error: could not find implicit value for parameter ev: R
+  crash(42)
+       ^
+three errors found

test/files/neg/t7509.scala

@@ -0,0 +1,4 @@
+object NMWE {
+  def crash[R <: AnyRef](f: R)(implicit ev: R): Any = ???
+  crash(42)
+}

test/files/pos/t7516/A_1.scala

@@ -0,0 +1,9 @@
+import scala.reflect._,macros._, scala.language.experimental.macros
+
+object A {
+  def impl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[List[T]] = {
+    val r = c.universe.reify { List(t.splice) }
+    c.Expr[List[T]]( c.resetLocalAttrs(r.tree) )
+  }
+  def demo[T](t: T): List[T] = macro impl[T]
+}

test/files/pos/t7516/B_2.scala

@@ -0,0 +1,4 @@
+object B {
+  final case class CV(p: Int = 3, g: Int = 2)
+  A.demo { val d = 4; CV(g = d); "a" }
+}

test/files/pos/t7517.scala

@@ -0,0 +1,22 @@
+trait Box[ K[A[x]] ]
+
+object Box {
+   // type constructor composition
+   sealed trait ∙[A[_], B[_]] { type l[T] = A[B[T]] }
+
+   // composes type constructors inside K
+   type SplitBox[K[A[x]], B[x]] = Box[ ({ type l[A[x]] = K[ (A ∙ B)#l] })#l ]
+
+   def split[ K[A[x]], B[x] ](base: Box[K]): SplitBox[K,B] = ???
+
+   class Composed[B[_], L[A[x]] ] {
+      val box: Box[L] = ???
+
+      type Split[ A[x] ] = L[ (A ∙ B)#l ]
+      val a: Box[Split] = Box.split(box)
+
+      //Either of these work:
+      val a1: Box[Split] = Box.split[L,B](box)
+      val a2: Box[ ({ type l[A[x]] = L[ (A ∙ B)#l ] })#l ] = Box.split(box)
+   }
+}

test/files/pos/t7532/A_1.java

@@ -0,0 +1,6 @@
+class R {
+	public class attr { // Will have the bytecode name `R$attr`, not to be confused with `R@tr`!
+	}
+	public static class attr1 {
+	}
+}