diff --git a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala index 6158c83c4958..97649426c007 100644 --- a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala +++ b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala @@ -6,6 +6,7 @@ import Settings._ import core.Contexts._ import util.DotClass import Properties._ +import scala.collection.JavaConverters._ object CompilerCommand extends DotClass { @@ -43,10 +44,9 @@ object CompilerCommand extends DotClass { if (!Files.exists(path)) throw new java.io.FileNotFoundException("argument file %s could not be found" format path.getFileName) - import scala.collection.JavaConversions._ val lines = Files.readAllLines(path) // default to UTF-8 encoding - val params = lines map stripComment mkString " " + val params = lines.asScala map stripComment mkString " " CommandLineParser.tokenize(params) } diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala index 552a6e8f3ef5..3d90d7f4a220 100644 --- a/compiler/src/dotty/tools/dotc/core/StdNames.scala +++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala @@ -325,12 +325,15 @@ object StdNames { val ArrayAnnotArg: N = "ArrayAnnotArg" val Constant: N = "Constant" val ConstantType: N = "ConstantType" + val doubleHash: N = "doubleHash" val ExistentialTypeTree: N = "ExistentialTypeTree" val Flag : N = "Flag" + val floatHash: N = "floatHash" val Ident: N = "Ident" val Import: N = "Import" val Literal: N = "Literal" val LiteralAnnotArg: N = "LiteralAnnotArg" + val longHash: N = "longHash" val Modifiers: N = "Modifiers" val NestedAnnotArg: N = "NestedAnnotArg" val NoFlags: N = "NoFlags" @@ -353,6 +356,7 @@ object StdNames { val UNIT : N = "UNIT" val add_ : N = "add" val annotation: N = "annotation" + val anyHash: N = "anyHash" val anyValClass: N = "anyValClass" val append: N = "append" val apply: N = "apply" diff --git a/compiler/src/dotty/tools/dotc/parsing/MarkupParsers.scala b/compiler/src/dotty/tools/dotc/parsing/MarkupParsers.scala index 706d38420ea3..882449412850 100644 --- a/compiler/src/dotty/tools/dotc/parsing/MarkupParsers.scala +++ b/compiler/src/dotty/tools/dotc/parsing/MarkupParsers.scala @@ -85,9 +85,9 @@ object MarkupParsers { var xEmbeddedBlock = false - private var debugLastStartElement = new mutable.Stack[(Int, String)] - private def debugLastPos = debugLastStartElement.top._1 - private def debugLastElem = debugLastStartElement.top._2 + private var debugLastStartElement = List.empty[(Int, String)] + private def debugLastPos = debugLastStartElement.head._1 + private def debugLastElem = debugLastStartElement.head._2 private def errorBraces() = { reportSyntaxError("in XML content, please use '}}' to express '}'") @@ -280,10 +280,10 @@ object MarkupParsers { if (qname == "xml:unparsed") return xUnparsed - debugLastStartElement.push((start, qname)) + debugLastStartElement = (start, qname) :: debugLastStartElement val ts = content xEndTag(qname) - debugLastStartElement.pop() + debugLastStartElement = debugLastStartElement.tail val pos = Position(start, curOffset, start) qname match { case "xml:group" => handle.group(pos, ts) @@ -417,7 +417,7 @@ object MarkupParsers { def xPattern: Tree = { var start = curOffset val qname = xName - debugLastStartElement.push((start, qname)) + debugLastStartElement = (start, qname) :: debugLastStartElement xSpaceOpt() val ts = new ArrayBuffer[Tree] @@ -457,7 +457,7 @@ object MarkupParsers { while (doPattern) { } // call until false xEndTag(qname) - debugLastStartElement.pop() + debugLastStartElement = debugLastStartElement.tail } handle.makeXMLpat(Position(start, curOffset, start), qname, ts) diff --git a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala index 21ca8dbfd132..c1d29e2babe3 100644 --- a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala +++ b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala @@ -21,7 +21,7 @@ import dotty.tools.dotc.ast.Trees._ import dotty.tools.dotc.ast.{untpd, tpd} import dotty.tools.dotc.core.Constants.Constant import dotty.tools.dotc.core.Types.MethodType -import dotty.tools.dotc.core.Names.Name +import dotty.tools.dotc.core.Names.{ Name, TermName } import scala.collection.mutable.ListBuffer import dotty.tools.dotc.core.Denotations.SingleDenotation import dotty.tools.dotc.core.SymDenotations.SymDenotation @@ -64,30 +64,18 @@ class InterceptedMethods extends MiniPhaseTransform { else tree } + // TODO: add missing cases from scalac private def poundPoundValue(tree: Tree)(implicit ctx: Context) = { val s = tree.tpe.widen.typeSymbol - if (s == defn.NullClass) Literal(Constant(0)) - else { - // Since we are past typer, we need to avoid creating trees carrying - // overloaded types. This logic is custom (and technically incomplete, - // although serviceable) for def hash. What is really needed is for - // the overloading logic presently hidden away in a few different - // places to be properly exposed so we can just call "resolveOverload" - // after typer. Until then: - - def alts = defn.ScalaRuntimeModule.info.member(nme.hash_) - - // if tpe is a primitive value type, alt1 will match on the exact value, - // taking in account that null.asInstanceOf[Int] == 0 - def alt1 = alts.suchThat(_.info.firstParamTypes.head =:= tree.tpe.widen) - // otherwise alt2 will match. alt2 also knows how to handle 'null' runtime value - def alt2 = defn.ScalaRuntimeModule.info.member(nme.hash_) - .suchThat(_.info.firstParamTypes.head.typeSymbol == defn.AnyClass) + def staticsCall(methodName: TermName): Tree = + ref(defn.staticsMethodRef(methodName)).appliedTo(tree) - Ident((if (s.isNumericValueClass) alt1 else alt2).termRef) - .appliedTo(tree) - } + if (s == defn.NullClass) Literal(Constant(0)) + else if (s == defn.DoubleClass) staticsCall(nme.doubleHash) + else if (s == defn.LongClass) staticsCall(nme.longHash) + else if (s == defn.FloatClass) staticsCall(nme.floatHash) + else staticsCall(nme.anyHash) } override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = { diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala index 887f051033b7..e4697a3247c1 100644 --- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala +++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala @@ -50,9 +50,18 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisTran /** Copy definitions from implementation class to trait itself */ private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = { + def info_2_12(sym: Symbol) = sym.info match { + case mt @ MethodType(paramNames @ nme.SELF :: _) => + // 2.12 seems to always assume the enclsing mixin class as self type parameter, + // whereas 2.11 used the self type of this class instead. + val selfType :: otherParamTypes = mt.paramInfos + MethodType(paramNames, mixin.typeRef :: otherParamTypes, mt.resType) + case info => info + } def newImpl(sym: TermSymbol): Symbol = sym.copy( owner = mixin, - name = if (sym.isConstructor) sym.name else ImplMethName(sym.name) + name = if (sym.isConstructor) sym.name else ImplMethName(sym.name), + info = info_2_12(sym) ) for (sym <- mixin.implClass.info.decls) newImpl(sym.asTerm).enteredAfter(thisTransform) diff --git a/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala b/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala index f88098519973..9b9866b5b03a 100644 --- a/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala +++ b/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala @@ -112,10 +112,10 @@ class VarianceChecker()(implicit ctx: Context) { case Some(VarianceError(tvar, required)) => def msg = i"${varianceString(tvar.flags)} $tvar occurs in ${varianceString(required)} position in type ${sym.info} of $sym" if (ctx.scala2Mode && sym.owner.isConstructor) { - ctx.migrationWarning(s"According to new variance rules, this is no longer accepted; need to annotate with @uncheckedVariance:\n$msg", sym.pos) + ctx.migrationWarning(s"According to new variance rules, this is no longer accepted; need to annotate with @uncheckedVariance:\n$msg", pos) patch(Position(pos.end), " @scala.annotation.unchecked.uncheckedVariance") // TODO use an import or shorten if possible } - else ctx.error(msg, sym.pos) + else ctx.error(msg, pos) case None => } diff --git a/compiler/test/dotc/scala-collections.blacklist b/compiler/test/dotc/scala-collections.blacklist index f192282d13f8..7b5e913ce69c 100644 --- a/compiler/test/dotc/scala-collections.blacklist +++ b/compiler/test/dotc/scala-collections.blacklist @@ -1,3 +1,6 @@ +scala/runtime/ScalaRunTime.scala +# Doesn't compile since we're not on 2.11 anymore + ## Errors having to do with bootstrap scala/Function1.scala diff --git a/compiler/test/dotc/tests.scala b/compiler/test/dotc/tests.scala index 40b55c6a9343..a7af432610bd 100644 --- a/compiler/test/dotc/tests.scala +++ b/compiler/test/dotc/tests.scala @@ -224,7 +224,7 @@ class tests extends CompilerTest { |../scala2-library/src/library/scala/package.scala |../scala2-library/src/library/scala/collection/GenSeqLike.scala |../scala2-library/src/library/scala/collection/SeqLike.scala - |../scala2-library/src/library/scala/collection/generic/GenSeqFactory.scala""".stripMargin) + |../scala2-library/src/library/scala/collection/generic/GenSeqFactory.scala""".stripMargin)(scala2mode ++ defaultOptions) @Test def compileIndexedSeq = compileLine("../scala2-library/src/library/scala/collection/immutable/IndexedSeq.scala") @Test def compileParSetLike = compileLine("../scala2-library/src/library/scala/collection/parallel/mutable/ParSetLike.scala") @Test def compileParSetSubset = compileLine( diff --git a/compiler/test/dotty/tools/ShowClassTests.scala b/compiler/test/dotty/tools/ShowClassTests.scala index 66ae8016965f..fd01a6b59f34 100644 --- a/compiler/test/dotty/tools/ShowClassTests.scala +++ b/compiler/test/dotty/tools/ShowClassTests.scala @@ -64,14 +64,14 @@ class ShowClassTests extends DottyTest { if (blackList contains path) debug_println(s"blacklisted package: $path") else { - for ( - sym <- pkg.info.decls if sym.owner == pkg.moduleClass && !(sym.name.toString contains '$') - ) { - debug_println(s"showing $sym in ${pkg.fullName}") - if (sym is PackageVal) showPackage(sym.asTerm) - else if (sym.isClass && !(sym is Module)) showClass(sym) - else if (sym is ModuleVal) showClass(sym.moduleClass) - } + pkg.info.decls + .filter(sym => sym.owner == pkg.moduleClass && !(sym.name.toString contains '$')) + .foreach { sym => + debug_println(s"showing $sym in ${pkg.fullName}") + if (sym is PackageVal) showPackage(sym.asTerm) + else if (sym.isClass && !(sym is Module)) showClass(sym) + else if (sym is ModuleVal) showClass(sym.moduleClass) + } } } diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala index 97f9dd612e92..a772434d1093 100644 --- a/compiler/test/dotty/tools/dotc/CompilationTests.scala +++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala @@ -57,7 +57,7 @@ class CompilationTests extends ParallelTesting { "../scala2-library/src/library/scala/collection/SeqLike.scala", "../scala2-library/src/library/scala/collection/generic/GenSeqFactory.scala" ), - defaultOptions + scala2Mode ) + compileFilesInDir("../tests/pos-special/spec-t5545", defaultOptions) + compileFilesInDir("../tests/pos-special/strawman-collections", defaultOptions) + diff --git a/compiler/test/dotty/tools/vulpix/SummaryReport.scala b/compiler/test/dotty/tools/vulpix/SummaryReport.scala index fed36d275d5c..ee323782f29a 100644 --- a/compiler/test/dotty/tools/vulpix/SummaryReport.scala +++ b/compiler/test/dotty/tools/vulpix/SummaryReport.scala @@ -59,7 +59,7 @@ final class NoSummaryReport extends SummaryReporting { * which outputs to a log file in `./testlogs/` */ final class SummaryReport extends SummaryReporting { - import scala.collection.JavaConversions._ + import scala.collection.JavaConverters._ private val startingMessages = new java.util.concurrent.ConcurrentLinkedDeque[String] private val failedTests = new java.util.concurrent.ConcurrentLinkedDeque[String] @@ -102,9 +102,9 @@ final class SummaryReport extends SummaryReporting { |""".stripMargin ) - startingMessages.foreach(rep.append) + startingMessages.asScala.foreach(rep.append) - failedTests.map(x => s" $x\n").foreach(rep.append) + failedTests.asScala.map(x => s" $x\n").foreach(rep.append) // If we're compiling locally, we don't need instructions on how to // reproduce failures @@ -121,7 +121,7 @@ final class SummaryReport extends SummaryReporting { rep += '\n' - reproduceInstructions.foreach(rep.append) + reproduceInstructions.asScala.foreach(rep.append) // If we're on the CI, we want everything if (!isInteractive) println(rep.toString) @@ -129,7 +129,7 @@ final class SummaryReport extends SummaryReporting { TestReporter.logPrintln(rep.toString) // Perform cleanup callback: - if (cleanUps.nonEmpty) cleanUps.foreach(_.apply()) + if (!cleanUps.isEmpty()) cleanUps.asScala.foreach(_.apply()) } private def removeColors(msg: String): String = diff --git a/library/src/dotty/runtime/LazyVals.scala b/library/src/dotty/runtime/LazyVals.scala index 4dea0d34dbe9..2c06a5dd8f05 100644 --- a/library/src/dotty/runtime/LazyVals.scala +++ b/library/src/dotty/runtime/LazyVals.scala @@ -6,7 +6,19 @@ import scala.annotation.tailrec * Helper methods used in thread-safe lazy vals. */ object LazyVals { - private val unsafe = scala.concurrent.util.Unsafe.instance + private val unsafe: sun.misc.Unsafe = + classOf[sun.misc.Unsafe].getDeclaredFields.find { field => + field.getType == classOf[sun.misc.Unsafe] && { + field.setAccessible(true) + true + } + } + .map(_.get(null).asInstanceOf[sun.misc.Unsafe]) + .getOrElse { + throw new ExceptionInInitializerError { + new IllegalStateException("Can't find instance of sun.misc.Unsafe") + } + } final val BITS_PER_LAZY_VAL = 2L final val LAZY_VAL_MASK = 3L @@ -22,7 +34,7 @@ object LazyVals { if (debug) println(s"CAS($t, $offset, $e, $v, $ord)") val mask = ~(LAZY_VAL_MASK << ord * BITS_PER_LAZY_VAL) - val n = (e & mask) | (v << (ord * BITS_PER_LAZY_VAL)) + val n = (e & mask) | (v.toLong << (ord * BITS_PER_LAZY_VAL)) compareAndSet(t, offset, e, n) } @inline def setFlag(t: Object, offset: Long, v: Int, ord: Int) = { diff --git a/library/src/scala/compat/java8/JFunction1.java b/library/src/scala/compat/java8/JFunction1.java index 69176cdea069..e1b02620f0c9 100644 --- a/library/src/scala/compat/java8/JFunction1.java +++ b/library/src/scala/compat/java8/JFunction1.java @@ -13,13 +13,12 @@ public interface JFunction1 extends scala.Function1 { @Override @SuppressWarnings("unchecked") default scala.Function1 andThen(scala.Function1 g) { - return scala.Function1$class.andThen(this, g); + return x -> g.apply(this.apply(x)); } - @Override @SuppressWarnings("unchecked") default scala.Function1 compose(scala.Function1 g) { - return scala.Function1$class.compose(this, g); + return x -> this.apply(g.apply(x)); } @SuppressWarnings("unchecked") default void apply$mcVI$sp(int v1) { diff --git a/library/src/scala/compat/java8/JFunction10.java b/library/src/scala/compat/java8/JFunction10.java index 8519ac2236f9..63e392a8e449 100644 --- a/library/src/scala/compat/java8/JFunction10.java +++ b/library/src/scala/compat/java8/JFunction10.java @@ -12,12 +12,12 @@ public interface JFunction10 extends @SuppressWarnings("unchecked") default scala.Function1>>>>>>>>> curried() { - return scala.Function10$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function10$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction11.java b/library/src/scala/compat/java8/JFunction11.java index 032ee40afb4a..0dd20546192b 100644 --- a/library/src/scala/compat/java8/JFunction11.java +++ b/library/src/scala/compat/java8/JFunction11.java @@ -12,12 +12,12 @@ public interface JFunction11 ex @SuppressWarnings("unchecked") default scala.Function1>>>>>>>>>> curried() { - return scala.Function11$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function11$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction12.java b/library/src/scala/compat/java8/JFunction12.java index 3f3eff492ab3..c992cc43f1b1 100644 --- a/library/src/scala/compat/java8/JFunction12.java +++ b/library/src/scala/compat/java8/JFunction12.java @@ -12,12 +12,12 @@ public interface JFunction12>>>>>>>>>>> curried() { - return scala.Function12$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function12$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction13.java b/library/src/scala/compat/java8/JFunction13.java index 2bed6ee97233..cca43006f26c 100644 --- a/library/src/scala/compat/java8/JFunction13.java +++ b/library/src/scala/compat/java8/JFunction13.java @@ -12,12 +12,12 @@ public interface JFunction13>>>>>>>>>>>> curried() { - return scala.Function13$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function13$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction14.java b/library/src/scala/compat/java8/JFunction14.java index 77fac237dd9a..3e69530a603e 100644 --- a/library/src/scala/compat/java8/JFunction14.java +++ b/library/src/scala/compat/java8/JFunction14.java @@ -12,12 +12,12 @@ public interface JFunction14>>>>>>>>>>>>> curried() { - return scala.Function14$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function14$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction15.java b/library/src/scala/compat/java8/JFunction15.java index 25adc1679d3b..76d70174c876 100644 --- a/library/src/scala/compat/java8/JFunction15.java +++ b/library/src/scala/compat/java8/JFunction15.java @@ -12,12 +12,12 @@ public interface JFunction15>>>>>>>>>>>>>> curried() { - return scala.Function15$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function15$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction16.java b/library/src/scala/compat/java8/JFunction16.java index fda1ea0c7edb..c11b461f5495 100644 --- a/library/src/scala/compat/java8/JFunction16.java +++ b/library/src/scala/compat/java8/JFunction16.java @@ -12,12 +12,12 @@ public interface JFunction16>>>>>>>>>>>>>>> curried() { - return scala.Function16$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function16$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction17.java b/library/src/scala/compat/java8/JFunction17.java index 89cb1b312907..c088f9dce7d6 100644 --- a/library/src/scala/compat/java8/JFunction17.java +++ b/library/src/scala/compat/java8/JFunction17.java @@ -12,12 +12,12 @@ public interface JFunction17>>>>>>>>>>>>>>>> curried() { - return scala.Function17$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function17$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction18.java b/library/src/scala/compat/java8/JFunction18.java index 428cee961208..25600da3ffe1 100644 --- a/library/src/scala/compat/java8/JFunction18.java +++ b/library/src/scala/compat/java8/JFunction18.java @@ -12,12 +12,12 @@ public interface JFunction18>>>>>>>>>>>>>>>>> curried() { - return scala.Function18$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function18$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction19.java b/library/src/scala/compat/java8/JFunction19.java index 95e47df7ef6b..cacc66d08e9e 100644 --- a/library/src/scala/compat/java8/JFunction19.java +++ b/library/src/scala/compat/java8/JFunction19.java @@ -12,12 +12,12 @@ public interface JFunction19>>>>>>>>>>>>>>>>>> curried() { - return scala.Function19$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function19$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction2.java b/library/src/scala/compat/java8/JFunction2.java index bad1493bb418..a0604cc59cd9 100644 --- a/library/src/scala/compat/java8/JFunction2.java +++ b/library/src/scala/compat/java8/JFunction2.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction2 extends scala.Function2 { default void $init$() { @@ -12,12 +14,21 @@ public interface JFunction2 extends scala.Function2 { @SuppressWarnings("unchecked") default scala.Function1> curried() { - return scala.Function2$class.curried(this); + return x1 -> x2 -> apply(x1, x2); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function2$class.tupled(this); + return x0$1 -> { + if (x0$1 == null) { + throw new MatchError(x0$1); + } + T1 x1 = x0$1._1(); + T2 x2 = x0$1._2(); + R r = this.apply(x1, x2); + return r; + } + ; } @SuppressWarnings("unchecked") diff --git a/library/src/scala/compat/java8/JFunction20.java b/library/src/scala/compat/java8/JFunction20.java index ed30b41ef03b..f34574f7f77f 100644 --- a/library/src/scala/compat/java8/JFunction20.java +++ b/library/src/scala/compat/java8/JFunction20.java @@ -12,12 +12,12 @@ public interface JFunction20>>>>>>>>>>>>>>>>>>> curried() { - return scala.Function20$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function20$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction21.java b/library/src/scala/compat/java8/JFunction21.java index aa6da80840f3..0af8db2db3b7 100644 --- a/library/src/scala/compat/java8/JFunction21.java +++ b/library/src/scala/compat/java8/JFunction21.java @@ -12,12 +12,12 @@ public interface JFunction21>>>>>>>>>>>>>>>>>>>> curried() { - return scala.Function21$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function21$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction22.java b/library/src/scala/compat/java8/JFunction22.java index 532145157277..fcd83a05fefd 100644 --- a/library/src/scala/compat/java8/JFunction22.java +++ b/library/src/scala/compat/java8/JFunction22.java @@ -12,12 +12,12 @@ public interface JFunction22>>>>>>>>>>>>>>>>>>>>> curried() { - return scala.Function22$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function22$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction3.java b/library/src/scala/compat/java8/JFunction3.java index 731608b2e434..9122f68198c9 100644 --- a/library/src/scala/compat/java8/JFunction3.java +++ b/library/src/scala/compat/java8/JFunction3.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction3 extends scala.Function3 { default void $init$() { @@ -12,12 +14,22 @@ public interface JFunction3 extends scala.Function3>> curried() { - return scala.Function3$class.curried(this); + return x1 -> x2 -> x3 -> apply(x1, x2, x3); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function3$class.tupled(this); + return x0$1 -> { + if (x0$1 == null) { + throw new MatchError(x0$1); + } + T1 x1 = x0$1._1(); + T2 x2 = x0$1._2(); + T3 x3 = x0$1._3(); + R r = this.apply(x1, x2, x3); + return r; + } + ; } diff --git a/library/src/scala/compat/java8/JFunction4.java b/library/src/scala/compat/java8/JFunction4.java index 9bff4c835132..d7356a0f8f32 100644 --- a/library/src/scala/compat/java8/JFunction4.java +++ b/library/src/scala/compat/java8/JFunction4.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction4 extends scala.Function4 { default void $init$() { @@ -12,12 +14,23 @@ public interface JFunction4 extends scala.Function4>>> curried() { - return scala.Function4$class.curried(this); + return x1 -> x2 -> x3 -> x4 -> apply(x1, x2, x3, x4); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function4$class.tupled(this); + return x0$1 -> { + if (x0$1 == null) { + throw new MatchError(x0$1); + } + T1 x1 = x0$1._1(); + T2 x2 = x0$1._2(); + T3 x3 = x0$1._3(); + T4 x4 = x0$1._4(); + R r = this.apply(x1, x2, x3, x4); + return r; + } + ; } diff --git a/library/src/scala/compat/java8/JFunction5.java b/library/src/scala/compat/java8/JFunction5.java index a5566a5badf7..1e0414bc5dce 100644 --- a/library/src/scala/compat/java8/JFunction5.java +++ b/library/src/scala/compat/java8/JFunction5.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction5 extends scala.Function5 { default void $init$() { @@ -12,12 +14,12 @@ public interface JFunction5 extends scala.Function5>>>> curried() { - return scala.Function5$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function5$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction6.java b/library/src/scala/compat/java8/JFunction6.java index b30fb5f47b93..112c21cbe977 100644 --- a/library/src/scala/compat/java8/JFunction6.java +++ b/library/src/scala/compat/java8/JFunction6.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction6 extends scala.Function6 { default void $init$() { @@ -12,12 +14,12 @@ public interface JFunction6 extends scala.Function6>>>>> curried() { - return scala.Function6$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function6$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction7.java b/library/src/scala/compat/java8/JFunction7.java index 4a4a92cba61b..1f59bc7affd9 100644 --- a/library/src/scala/compat/java8/JFunction7.java +++ b/library/src/scala/compat/java8/JFunction7.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction7 extends scala.Function7 { default void $init$() { @@ -12,12 +14,12 @@ public interface JFunction7 extends scala.Functio @SuppressWarnings("unchecked") default scala.Function1>>>>>> curried() { - return scala.Function7$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function7$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction8.java b/library/src/scala/compat/java8/JFunction8.java index 825236e4854c..10825347af38 100644 --- a/library/src/scala/compat/java8/JFunction8.java +++ b/library/src/scala/compat/java8/JFunction8.java @@ -5,6 +5,8 @@ package scala.compat.java8; +import scala.MatchError; + @FunctionalInterface public interface JFunction8 extends scala.Function8 { default void $init$() { @@ -12,12 +14,12 @@ public interface JFunction8 extends scala.Fun @SuppressWarnings("unchecked") default scala.Function1>>>>>>> curried() { - return scala.Function8$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function8$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/compat/java8/JFunction9.java b/library/src/scala/compat/java8/JFunction9.java index d0e40c316cb8..02fe323c56c6 100644 --- a/library/src/scala/compat/java8/JFunction9.java +++ b/library/src/scala/compat/java8/JFunction9.java @@ -12,12 +12,12 @@ public interface JFunction9 extends scala @SuppressWarnings("unchecked") default scala.Function1>>>>>>>> curried() { - return scala.Function9$class.curried(this); + throw new UnsupportedOperationException("todo"); } @SuppressWarnings("unchecked") default scala.Function1, R> tupled() { - return scala.Function9$class.tupled(this); + throw new UnsupportedOperationException("todo"); } diff --git a/library/src/scala/runtime/ScalaRunTime.scala b/library/src/scala/runtime/ScalaRunTime.scala deleted file mode 100644 index ed1eb82b1b10..000000000000 --- a/library/src/scala/runtime/ScalaRunTime.scala +++ /dev/null @@ -1,377 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala -package runtime - -import dotty.runtime.vc.VCArrayPrototype - -import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator } -import scala.collection.mutable.WrappedArray -import scala.collection.immutable.{ StringLike, NumericRange, List, Stream, Nil, :: } -import scala.collection.generic.{ Sorted, IsTraversableLike } -import scala.reflect.{ ClassTag, classTag } -import scala.util.control.ControlThrowable -import java.lang.{ Class => jClass } - -import java.lang.Double.doubleToLongBits -import java.lang.reflect.{ Modifier, Method => JMethod } - -/** The object ScalaRunTime provides support methods required by - * the scala runtime. All these methods should be considered - * outside the API and subject to change or removal without notice. - */ -object ScalaRunTime { - def isArray(x: Any, atLevel: Int = 1): Boolean = - x != null && isArrayClass(x.getClass, atLevel) - - private def isArrayClass(clazz: jClass[_], atLevel: Int): Boolean = - (clazz.isArray || classOf[VCArrayPrototype[_]].isAssignableFrom(clazz)) && - (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1)) - - def isValueClass(clazz: jClass[_]) = clazz.isPrimitive() - - // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22) - def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple") - def isAnyVal(x: Any) = x match { - case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true - case _ => false - } - - // A helper method to make my life in the pattern matcher a lot easier. - def drop[Repr](coll: Repr, num: Int)(implicit traversable: IsTraversableLike[Repr]): Repr = - traversable conversion coll drop num - - /** Return the class object representing an array with element class `clazz`. - */ - def arrayClass(clazz: jClass[_]): jClass[_] = { - // Dmitry: I want to see where this method is used to know how to fix it - // [Martin] Here's a stacktrace - // Exception in thread "main" scala.NotImplementedError: an implementation is missing - // at scala.Predef$.$qmark$qmark$qmark(Predef.scala:225) - // at scala.runtime.ScalaRunTime$.arrayClass(ScalaRunTime.scala:53) - // at scala.Array$.fill(Array.scala:281) - // at dotty.tools.dotc.core.Flags$.(Flags.scala:139) - // newInstance throws an exception if the erasure is Void.TYPE. see SI-5680 - if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]] - else java.lang.reflect.Array.newInstance(clazz, 0).getClass - } - - /** Return the class object representing elements in arrays described by a given schematic. - */ - def arrayElementClass(schematic: Any): jClass[_] = schematic match { - case cls: jClass[_] => cls.getComponentType - case tag: ClassTag[_] => tag.runtimeClass - case _ => - throw new UnsupportedOperationException(s"unsupported schematic $schematic (${schematic.getClass})") - } - - /** Return the class object representing an unboxed value type, - * e.g., classOf[int], not classOf[java.lang.Integer]. The compiler - * rewrites expressions like 5.getClass to come here. - */ - def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] = - classTag[T].runtimeClass.asInstanceOf[jClass[T]] - - /** Retrieve generic array element */ - def array_apply(xs: AnyRef, idx: Int): Any = { - xs match { - case x: Array[AnyRef] => x(idx).asInstanceOf[Any] - case x: Array[Int] => x(idx).asInstanceOf[Any] - case x: Array[Double] => x(idx).asInstanceOf[Any] - case x: Array[Long] => x(idx).asInstanceOf[Any] - case x: Array[Float] => x(idx).asInstanceOf[Any] - case x: Array[Char] => x(idx).asInstanceOf[Any] - case x: Array[Byte] => x(idx).asInstanceOf[Any] - case x: Array[Short] => x(idx).asInstanceOf[Any] - case x: Array[Boolean] => x(idx).asInstanceOf[Any] - case x: Array[Unit] => x(idx).asInstanceOf[Any] - case x: VCArrayPrototype[_] => x.apply(idx) - case null => throw new NullPointerException - } - } - - /** update generic array element */ - def array_update(xs: AnyRef, idx: Int, value: Any): Unit = { - xs match { - case x: Array[AnyRef] => x(idx) = value.asInstanceOf[AnyRef] - case x: Array[Int] => x(idx) = value.asInstanceOf[Int] - case x: Array[Double] => x(idx) = value.asInstanceOf[Double] - case x: Array[Long] => x(idx) = value.asInstanceOf[Long] - case x: Array[Float] => x(idx) = value.asInstanceOf[Float] - case x: Array[Char] => x(idx) = value.asInstanceOf[Char] - case x: Array[Byte] => x(idx) = value.asInstanceOf[Byte] - case x: Array[Short] => x(idx) = value.asInstanceOf[Short] - case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean] - case x: Array[Unit] => x(idx) = value.asInstanceOf[Unit] - case x: VCArrayPrototype[t] => x.update(idx, value.asInstanceOf[t]) - case null => throw new NullPointerException - } - } - - /** Get generic array length */ - def array_length(xs: AnyRef): Int = xs match { - case x: Array[AnyRef] => x.length - case x: Array[Int] => x.length - case x: Array[Double] => x.length - case x: Array[Long] => x.length - case x: Array[Float] => x.length - case x: Array[Char] => x.length - case x: Array[Byte] => x.length - case x: Array[Short] => x.length - case x: Array[Boolean] => x.length - case x: Array[Unit] => x.length - case x: VCArrayPrototype[_] => x.length - case null => throw new NullPointerException - } - - def array_clone(xs: AnyRef): AnyRef = xs match { - case x: Array[AnyRef] => ArrayRuntime.cloneArray(x) - case x: Array[Int] => ArrayRuntime.cloneArray(x) - case x: Array[Double] => ArrayRuntime.cloneArray(x) - case x: Array[Long] => ArrayRuntime.cloneArray(x) - case x: Array[Float] => ArrayRuntime.cloneArray(x) - case x: Array[Char] => ArrayRuntime.cloneArray(x) - case x: Array[Byte] => ArrayRuntime.cloneArray(x) - case x: Array[Short] => ArrayRuntime.cloneArray(x) - case x: Array[Boolean] => ArrayRuntime.cloneArray(x) - case x: Array[Unit] => x - case x: VCArrayPrototype[_] => x.clone() - case null => throw new NullPointerException - } - - /** Convert an array to an object array. - * Needed to deal with vararg arguments of primitive types that are passed - * to a generic Java vararg parameter T ... - */ - def toObjectArray(src: AnyRef): Array[Object] = src match { - case x: Array[AnyRef] => x - case _ => - val length = array_length(src) - val dest = new Array[Object](length) - for (i <- 0 until length) - array_update(dest, i, array_apply(src, i)) - dest - } - - def toArray[T](xs: scala.collection.Seq[T]) = { - val arr = new Array[AnyRef](xs.length) - var i = 0 - for (x <- xs) { - arr(i) = x.asInstanceOf[AnyRef] - i += 1 - } - arr - } - - // Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957 - // More background at ticket #2318. - def ensureAccessible(m: JMethod): JMethod = scala.reflect.ensureAccessible(m) - - def checkInitialized[T <: AnyRef](x: T): T = - if (x == null) throw new UninitializedError else x - - def _toString(x: Product): String = - x.productIterator.mkString(x.productPrefix + "(", ",", ")") - - def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.productHash(x) - - /** A helper for case classes. */ - def typedProductIterator[T](x: Product): Iterator[T] = { - new AbstractIterator[T] { - private var c: Int = 0 - private val cmax = x.productArity - def hasNext = c < cmax - def next() = { - val result = x.productElement(c) - c += 1 - result.asInstanceOf[T] - } - } - } - - /** Fast path equality method for inlining; used when -optimise is set. - */ - @inline def inlinedEquals(x: Object, y: Object): Boolean = - if (x eq y) true - else if (x eq null) false - else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.equalsNumObject(x.asInstanceOf[java.lang.Number], y) - else if (x.isInstanceOf[java.lang.Character]) BoxesRunTime.equalsCharObject(x.asInstanceOf[java.lang.Character], y) - else x.equals(y) - - def _equals(x: Product, y: Any): Boolean = y match { - case y: Product if x.productArity == y.productArity => x.productIterator sameElements y.productIterator - case _ => false - } - - // hashcode ----------------------------------------------------------- - // - // Note that these are the implementations called by ##, so they - // must not call ## themselves. - - def hash(x: Any): Int = - if (x == null) 0 - else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.hashFromNumber(x.asInstanceOf[java.lang.Number]) - else x.hashCode - - def hash(dv: Double): Int = { - val iv = dv.toInt - if (iv == dv) return iv - - val lv = dv.toLong - if (lv == dv) return lv.hashCode - - val fv = dv.toFloat - if (fv == dv) fv.hashCode else dv.hashCode - } - def hash(fv: Float): Int = { - val iv = fv.toInt - if (iv == fv) return iv - - val lv = fv.toLong - if (lv == fv) hash(lv) - else fv.hashCode - } - def hash(lv: Long): Int = { - val low = lv.toInt - val lowSign = low >>> 31 - val high = (lv >>> 32).toInt - low ^ (high + lowSign) - } - def hash(x: Number): Int = runtime.BoxesRunTime.hashFromNumber(x) - - // The remaining overloads are here for completeness, but the compiler - // inlines these definitions directly so they're not generally used. - def hash(x: Int): Int = x - def hash(x: Short): Int = x.toInt - def hash(x: Byte): Int = x.toInt - def hash(x: Char): Int = x.toInt - def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode - def hash(x: Unit): Int = 0 - - /** A helper method for constructing case class equality methods, - * because existential types get in the way of a clean outcome and - * it's performing a series of Any/Any equals comparisons anyway. - * See ticket #2867 for specifics. - */ - def sameElements(xs1: scala.collection.Seq[Any], xs2: scala.collection.Seq[Any]) = xs1 sameElements xs2 - - /** Given any Scala value, convert it to a String. - * - * The primary motivation for this method is to provide a means for - * correctly obtaining a String representation of a value, while - * avoiding the pitfalls of naïvely calling toString on said value. - * In particular, it addresses the fact that (a) toString cannot be - * called on null and (b) depending on the apparent type of an - * array, toString may or may not print it in a human-readable form. - * - * @param arg the value to stringify - * @return a string representation of arg. - */ - def stringOf(arg: Any): String = stringOf(arg, scala.Int.MaxValue) - def stringOf(arg: Any, maxElements: Int): String = { - def packageOf(x: AnyRef) = x.getClass.getPackage match { - case null => "" - case p => p.getName - } - def isScalaClass(x: AnyRef) = packageOf(x) startsWith "scala." - def isScalaCompilerClass(x: AnyRef) = packageOf(x) startsWith "scala.tools.nsc." - - // We use reflection because the scala.xml package might not be available - def isSubClassOf(potentialSubClass: Class[_], ofClass: String) = - try { - val classLoader = potentialSubClass.getClassLoader - val clazz = Class.forName(ofClass, /*initialize =*/ false, classLoader) - clazz.isAssignableFrom(potentialSubClass) - } catch { - case cnfe: ClassNotFoundException => false - } - def isXmlNode(potentialSubClass: Class[_]) = isSubClassOf(potentialSubClass, "scala.xml.Node") - def isXmlMetaData(potentialSubClass: Class[_]) = isSubClassOf(potentialSubClass, "scala.xml.MetaData") - - // When doing our own iteration is dangerous - def useOwnToString(x: Any) = x match { - // Range/NumericRange have a custom toString to avoid walking a gazillion elements - case _: Range | _: NumericRange[_] => true - // Sorted collections to the wrong thing (for us) on iteration - ticket #3493 - case _: Sorted[_, _] => true - // StringBuilder(a, b, c) and similar not so attractive - case _: StringLike[_] => true - // Don't want to evaluate any elements in a view - case _: TraversableView[_, _] => true - // Node extends NodeSeq extends Seq[Node] and MetaData extends Iterable[MetaData] - // -> catch those by isXmlNode and isXmlMetaData. - // Don't want to a) traverse infinity or b) be overly helpful with peoples' custom - // collections which may have useful toString methods - ticket #3710 - // or c) print AbstractFiles which are somehow also Iterable[AbstractFile]s. - case x: Traversable[_] => !x.hasDefiniteSize || !isScalaClass(x) || isScalaCompilerClass(x) || isXmlNode(x.getClass) || isXmlMetaData(x.getClass) - // Otherwise, nothing could possibly go wrong - case _ => false - } - - // A variation on inner for maps so they print -> instead of bare tuples - def mapInner(arg: Any): String = arg match { - case (k, v) => inner(k) + " -> " + inner(v) - case _ => inner(arg) - } - - // Special casing Unit arrays, the value class which uses a reference array type. - def arrayToString(x: AnyRef) = { - if (x.getClass.getComponentType == classOf[BoxedUnit]) - 0 until (array_length(x) min maxElements) map (_ => "()") mkString ("Array(", ", ", ")") - else - WrappedArray make x take maxElements map inner mkString ("Array(", ", ", ")") - } - - // The recursively applied attempt to prettify Array printing. - // Note that iterator is used if possible and foreach is used as a - // last resort, because the parallel collections "foreach" in a - // random order even on sequences. - def inner(arg: Any): String = arg match { - case null => "null" - case "" => "\"\"" - case x: String => if (x.head.isWhitespace || x.last.isWhitespace) "\"" + x + "\"" else x - case x if useOwnToString(x) => x.toString - case x: AnyRef if isArray(x) => arrayToString(x) - case x: scala.collection.Map[_, _] => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")") - case x: Iterable[_] => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")") - case x: Traversable[_] => x take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")") - case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma - case x: Product if isTuple(x) => x.productIterator map inner mkString ("(", ",", ")") - case x => x.toString - } - - // The try/catch is defense against iterables which aren't actually designed - // to be iterated, such as some scala.tools.nsc.io.AbstractFile derived classes. - try inner(arg) - catch { - case _: UnsupportedOperationException | _: AssertionError => "" + arg - } - } - - /** stringOf formatted for use in a repl result. */ - def replStringOf(arg: Any, maxElements: Int): String = { - val s = stringOf(arg, maxElements) - val nl = if (s contains "\n") "\n" else "" - - nl + s + "\n" - } - - def box[T](clazz: jClass[T]): jClass[_] = clazz match { - case java.lang.Byte.TYPE => classOf[java.lang.Byte] - case java.lang.Short.TYPE => classOf[java.lang.Short] - case java.lang.Character.TYPE => classOf[java.lang.Character] - case java.lang.Integer.TYPE => classOf[java.lang.Integer] - case java.lang.Long.TYPE => classOf[java.lang.Long] - case java.lang.Float.TYPE => classOf[java.lang.Float] - case java.lang.Double.TYPE => classOf[java.lang.Double] - case java.lang.Void.TYPE => classOf[scala.runtime.BoxedUnit] - case java.lang.Boolean.TYPE => classOf[java.lang.Boolean] - case _ => clazz - } -} diff --git a/project/Build.scala b/project/Build.scala index 5ad795a34251..69229dbab7e7 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -35,12 +35,12 @@ object ExposedValues extends AutoPlugin { object Build { - val scalacVersion = "2.11.11" // Do not rename, this is grepped in bin/common. + val scalacVersion = "2.12.3" // Do not rename, this is grepped in bin/common. val dottyOrganization = "ch.epfl.lamp" val dottyGithubUrl = "https://github.com/lampepfl/dotty" val dottyVersion = { - val baseVersion = "0.3.0-RC1" + val baseVersion = "0.4.0" val isNightly = sys.env.get("NIGHTLYBUILD") == Some("yes") val isRelease = sys.env.get("RELEASEBUILD") == Some("yes") if (isNightly) @@ -215,8 +215,8 @@ object Build { configuration = configurationFilter(Configurations.ScalaTool.name), artifact = artifactFilter(extension = "jar") ) - (jars.find(_.getName.startsWith("dotty-library_2.11")).get, - jars.find(_.getName.startsWith("dotty-compiler_2.11")).get) + (jars.find(_.getName.startsWith("dotty-library_2.12")).get, + jars.find(_.getName.startsWith("dotty-compiler_2.12")).get) } else ((packageBin in (`dotty-library`, Compile)).value, (packageBin in (`dotty-compiler`, Compile)).value) @@ -469,7 +469,7 @@ object Build { // get libraries onboard libraryDependencies ++= Seq("com.typesafe.sbt" % "sbt-interface" % sbtVersion.value, - ("org.scala-lang.modules" %% "scala-xml" % "1.0.1").withDottyCompat(), + ("org.scala-lang.modules" %% "scala-xml" % "1.0.6").withDottyCompat(), "com.novocode" % "junit-interface" % "0.11" % "test", "org.scala-lang" % "scala-library" % scalacVersion % "test"), @@ -725,7 +725,8 @@ object Build { libraryDependencies ++= Seq( "com.typesafe.sbt" % "sbt-interface" % sbtVersion.value, "org.scala-sbt" % "api" % sbtVersion.value % "test", - ("org.specs2" %% "specs2" % "2.3.11" % "test").withDottyCompat() + ("org.specs2" %% "specs2-core" % "3.9.1" % "test").withDottyCompat(), + ("org.specs2" %% "specs2-junit" % "3.9.1" % "test").withDottyCompat() ), // The sources should be published with crossPaths := false since they // need to be compiled by the project using the bridge. diff --git a/sbt-bridge/test/xsbt/ExtractAPISpecification.scala b/sbt-bridge/test/xsbt/ExtractAPISpecification.scala index 4b3b2c51aaa9..ce87134bc16d 100644 --- a/sbt-bridge/test/xsbt/ExtractAPISpecification.scala +++ b/sbt-bridge/test/xsbt/ExtractAPISpecification.scala @@ -3,7 +3,7 @@ package xsbt import org.junit.runner.RunWith import xsbti.api._ -import xsbt.api.DefaultShowAPI +import dotty.tools.dotc.sbt.DefaultShowAPI import org.specs2.mutable.Specification import org.specs2.runner.JUnitRunner diff --git a/sbt-bridge/test/xsbt/ScalaCompilerForUnitTesting.scala b/sbt-bridge/test/xsbt/ScalaCompilerForUnitTesting.scala index eaa93875028f..fb27f9b9d276 100644 --- a/sbt-bridge/test/xsbt/ScalaCompilerForUnitTesting.scala +++ b/sbt-bridge/test/xsbt/ScalaCompilerForUnitTesting.scala @@ -3,8 +3,6 @@ package xsbt import xsbti.compile.SingleOutput import java.io.File -import _root_.scala.tools.nsc.reporters.ConsoleReporter -import _root_.scala.tools.nsc.Settings import xsbti._ import xsbti.api.SourceAPI import sbt.IO._ diff --git a/sbt-dotty/sbt-test/sbt-dotty/example-project/build.sbt b/sbt-dotty/sbt-test/sbt-dotty/example-project/build.sbt index b417f0a74f28..07fd238624a3 100644 --- a/sbt-dotty/sbt-test/sbt-dotty/example-project/build.sbt +++ b/sbt-dotty/sbt-test/sbt-dotty/example-project/build.sbt @@ -1,3 +1,3 @@ scalaVersion := sys.props("plugin.scalaVersion") -libraryDependencies += ("org.scala-lang.modules" %% "scala-xml" % "1.0.1").withDottyCompat() +libraryDependencies += ("org.scala-lang.modules" %% "scala-xml" % "1.0.6").withDottyCompat() diff --git a/sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala b/sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala index 8d3260427eea..8b7eedb0b9a6 100644 --- a/sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala +++ b/sbt-dotty/src/dotty/tools/sbtplugin/DottyIDEPlugin.scala @@ -249,6 +249,6 @@ object DottyIDEPlugin extends AutoPlugin { } } } - + ) ++ addCommandAlias("launchIDE", ";configureIDE;runCode") } diff --git a/sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala b/sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala index b11569305132..83455fb4c66a 100644 --- a/sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala +++ b/sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala @@ -14,10 +14,10 @@ object DottyPlugin extends AutoPlugin { // - if this was a settingKey, then this would evaluate even if you don't use it. def dottyLatestNightlyBuild: Option[String] = { println("Fetching latest Dotty nightly version (requires an internet connection)...") - val Version = """ (0.3\..*-bin.*)""".r + val Version = """ (0.4\..*-bin.*)""".r val latest = scala.io.Source .fromURL( - "http://repo1.maven.org/maven2/ch/epfl/lamp/dotty_0.3/maven-metadata.xml") + "http://repo1.maven.org/maven2/ch/epfl/lamp/dotty_0.4/maven-metadata.xml") .getLines() .collect { case Version(version) => version } .toSeq @@ -50,9 +50,15 @@ object DottyPlugin extends AutoPlugin { def withDottyCompat(): ModuleID = moduleID.crossVersion match { case _: CrossVersion.Binary => - moduleID.cross(CrossVersion.binaryMapped { - case version if version.startsWith("0.") => "2.11" - case version => version + moduleID.cross(CrossVersion.binaryMapped { version => + CrossVersion.partialVersion(version) match { + case Some((0, minor)) => + // Dotty v0.4 or greater is compatible with 2.12.x + if (minor >= 4) "2.12" + else "2.11" + case _ => + version + } }) case _ => moduleID diff --git a/scala2-library b/scala2-library index b17a58607842..1497d54101b9 160000 --- a/scala2-library +++ b/scala2-library @@ -1 +1 @@ -Subproject commit b17a58607842333aaf1bd9117d7a64ee45d9ab54 +Subproject commit 1497d54101b918e16f2a43fc769ddabdccf61a00 diff --git a/tests/neg/t5729.scala b/tests/neg/t5729.scala index c7d42ee238ea..69df11fcbbe0 100644 --- a/tests/neg/t5729.scala +++ b/tests/neg/t5729.scala @@ -6,8 +6,8 @@ object Test { } object C { - def join(in: Seq[List[_]]): Int = error("TODO") - def join[S](in: Seq[List[S]]): String = error("TODO") + def join(in: Seq[List[_]]): Int = sys.error("TODO") + def join[S](in: Seq[List[S]]): String = sys.error("TODO") join(Seq[List[Int]]()) // error: ambiguous // diff --git a/tests/neg/t7294.scala b/tests/neg/t7294.scala new file mode 100644 index 000000000000..24cd796b80d5 --- /dev/null +++ b/tests/neg/t7294.scala @@ -0,0 +1,4 @@ +object Test { + // reachability error as Tuple2 is final. + (1, 2) match { case Seq() => 0; case _ => 1 } // error +} diff --git a/tests/pos/t5070.scala b/tests/pos/t5070.scala index 0e5c0ffc06ff..f55ee30f8b5c 100644 --- a/tests/pos/t5070.scala +++ b/tests/pos/t5070.scala @@ -3,7 +3,7 @@ trait A { } object O { - implicit def b(implicit x: A): x.T = error("") + implicit def b(implicit x: A): x.T = sys.error("") } class Test { diff --git a/tests/pos/t7294.scala b/tests/pos/t7294.scala deleted file mode 100644 index ccac2b14005f..000000000000 --- a/tests/pos/t7294.scala +++ /dev/null @@ -1,6 +0,0 @@ -object Test { - // no fruitless warning as Tuple2 isn't (yet) final. - // The corresponding `neg` test will treat it as final - // for the purposes of these tests under -Xfuture. - (1, 2) match { case Seq() => 0; case _ => 1 } -} diff --git a/tests/pos/tcpoly_bounds1.scala b/tests/pos/tcpoly_bounds1.scala index fc05e18d8c72..651ae48a6846 100644 --- a/tests/pos/tcpoly_bounds1.scala +++ b/tests/pos/tcpoly_bounds1.scala @@ -1,11 +1,3 @@ -class Foo[t[x]<: Tuple2[Int, x]] - -// -class MyPair[z](a: Int, b: z) extends Tuple2[Int, z](a,b) - -object foo extends Foo[MyPair] - - trait Monad[m[x <: Bound[x]], Bound[x], a] // TODO: variances! trait ListMonad[a] extends Monad[List, [X] => Any, a] // Dotty difference: Any is not a legal argument for hk type. diff --git a/tests/pos/virtpatmat_exist1.scala b/tests/pos/virtpatmat_exist1.scala index 6cad017b0b30..295e99cfcc8a 100644 --- a/tests/pos/virtpatmat_exist1.scala +++ b/tests/pos/virtpatmat_exist1.scala @@ -1,9 +1,9 @@ import annotation.unchecked.{ uncheckedVariance=> uV } -import scala.collection.immutable.{ListMap, HashMap, ListSet, HashSet} +import scala.collection.mutable.{ListMap, HashMap, HashSet} object Test { class HashMapCollision1[A, +B](var hash: Int, var kvs: ListMap[A, B @uV]) extends HashMap[A, B @uV] - class HashSetCollision1[A](var hash: Int, var ks: ListSet[A]) extends HashSet[A] + class HashSetCollision1[A](var hash: Int, var ks: Set[A]) extends HashSet[A] def splitArray[T](ad: Array[Iterable[T]]): Any = ad(0) match { diff --git a/tests/run/LazyValsLongs.scala b/tests/run/LazyValsLongs.scala index 920a4b887b07..5ef39acd4ebd 100644 --- a/tests/run/LazyValsLongs.scala +++ b/tests/run/LazyValsLongs.scala @@ -60,6 +60,6 @@ object Test { A17, A18) assert(l1.mkString == l2.mkString) - assert(!l1.contains(null)) + assert(!l1.contains(null)) // @odersky - 2.12 encoding seems wonky here as well } } diff --git a/tests/run/hashCodeBoxesRunTime.scala b/tests/run/hashCodeBoxesRunTime.scala deleted file mode 100644 index ba1a30f5fb4a..000000000000 --- a/tests/run/hashCodeBoxesRunTime.scala +++ /dev/null @@ -1,28 +0,0 @@ -// This only tests direct access to the methods in BoxesRunTime, -// not the whole scheme. -object Test -{ - import java.{ lang => jl } - import scala.runtime.BoxesRunTime.{ hashFromNumber, hashFromObject } - - def allSame[T](xs: List[T]) = assert(xs.distinct.size == 1, "failed: " + xs) - - def mkNumbers(x: Int): List[Number] = - List(x.toByte, x.toShort, x, x.toLong, x.toFloat, x.toDouble) - - def testLDF(x: Long) = allSame(List[Number](x, x.toDouble, x.toFloat) map hashFromNumber) - - def main(args: Array[String]): Unit = { - List(Byte.MinValue, -1, 0, 1, Byte.MaxValue) foreach { n => - val hashes = mkNumbers(n) map hashFromNumber - allSame(hashes) - if (n >= 0) { - val charCode = hashFromObject(n.toChar: Character) - assert(charCode == hashes.head) - } - } - - testLDF(Short.MaxValue.toLong) - testLDF(Short.MinValue.toLong) - } -} diff --git a/tests/run/mixins1/A_1.scala b/tests/run/mixins1/A_1.scala index 32c369a1b751..9d1de641ccbf 100644 --- a/tests/run/mixins1/A_1.scala +++ b/tests/run/mixins1/A_1.scala @@ -1,5 +1,4 @@ -trait A { - +trait A[This <: A[This] with B] { self: B => var x = 3 println("hi") val y = x * x @@ -7,5 +6,6 @@ trait A { def f: Int = x + y def f(z: Int): Int = f + z - } + +trait B extends A[B] diff --git a/tests/run/mixins1/C_2.scala b/tests/run/mixins1/C_2.scala index bd9a571ebaf3..ecf9d75ce630 100644 --- a/tests/run/mixins1/C_2.scala +++ b/tests/run/mixins1/C_2.scala @@ -1,5 +1,5 @@ // Intended to be compiled with either 2.11 or 2.12 -class C extends A { +class C extends A[B] with B { x = 4 override def f: Int = super.f @@ -8,5 +8,5 @@ class C extends A { } object Test extends App { - new C().f + println(new C().f) } diff --git a/tests/run/numbereq.scala b/tests/run/numbereq.scala index 7ce4b23cf895..770bf50fee15 100644 --- a/tests/run/numbereq.scala +++ b/tests/run/numbereq.scala @@ -2,7 +2,9 @@ object Test { def mkNumbers(x: Int): List[AnyRef] = { val base = List( BigDecimal(x), - BigInt(x), + // FIXME: breaks ycheck, broken type inferencing. Gets a large union type + // instead of list of Number + (BigInt(x): Number), new java.lang.Double(x.toDouble), new java.lang.Float(x.toFloat), new java.lang.Long(x.toLong), @@ -19,7 +21,9 @@ object Test { def mkNumbers(x: BigInt): List[AnyRef] = { List( - List(BigDecimal(x, java.math.MathContext.UNLIMITED)), + // FIXME: breaks ycheck, broken type inferencing. Gets a large union type + // instead of list of Number + List(BigDecimal(x, java.math.MathContext.UNLIMITED): Number), List(x), if (x.isValidDouble) List(new java.lang.Double(x.toDouble)) else Nil, if (x.isValidFloat) List(new java.lang.Float(x.toFloat)) else Nil, diff --git a/tests/run/t3822.scala b/tests/run/t3822.scala deleted file mode 100644 index c35804035e82..000000000000 --- a/tests/run/t3822.scala +++ /dev/null @@ -1,19 +0,0 @@ -import scala.collection.{ mutable, immutable, generic } -import immutable.ListSet - -object Test { - def main(args: Array[String]): Unit = { - val xs = ListSet(-100000 to 100001: _*) - - assert(xs.size == 200002) - assert(xs.sum == 100001) - - val ys = ListSet[Int]() - val ys1 = (1 to 12).grouped(3).foldLeft(ys)(_ ++ _) - val ys2 = (1 to 12).foldLeft(ys)(_ + _) - - assert(ys1 == ys2) - } -} - - diff --git a/tests/run/t6634.check b/tests/run/t6634.check index f6cbb30c6749..b085f397e630 100644 --- a/tests/run/t6634.check +++ b/tests/run/t6634.check @@ -4,27 +4,31 @@ String OK. Length OK. Trying lb1 ... +java.lang.IndexOutOfBoundsException: at 6 deleting 6 Checking ... String OK. Length OK. Trying lb2 ... +java.lang.IndexOutOfBoundsException: at 99 deleting 6 Checking ... String OK. Length OK. Trying lb3 ... +java.lang.IndexOutOfBoundsException: at 1 deleting 9 Checking ... String OK. Length OK. Trying lb4 ... +java.lang.IndexOutOfBoundsException: at -1 deleting 1 Checking ... String OK. Length OK. Trying lb5 ... -java.lang.IllegalArgumentException: removing negative number (-1) of elements +java.lang.IllegalArgumentException: removing negative number of elements: -1 Checking ... String OK. Length OK. diff --git a/tests/run/t6634.scala b/tests/run/t6634.scala index bc2f00224cc5..37076028329f 100644 --- a/tests/run/t6634.scala +++ b/tests/run/t6634.scala @@ -1,6 +1,7 @@ import collection.mutable.ListBuffer -object Test extends dotty.runtime.LegacyApp { +//object Test extends dotty.runtime.LegacyApp { +object Test extends App { def newLB = ListBuffer('a, 'b, 'c, 'd, 'e) val lb0 = newLB @@ -8,7 +9,7 @@ object Test extends dotty.runtime.LegacyApp { try { lb0.remove(5, 0) } catch { - // Not thrown in 2.10, will be thrown in 2.11 + // Should not be thrown--nothing is deleted so nothing to do case ex: IndexOutOfBoundsException => println(ex) } checkNotCorrupted(lb0) @@ -17,8 +18,8 @@ object Test extends dotty.runtime.LegacyApp { println("Trying lb1 ...") try { lb1.remove(6, 6) - } catch { - // Not thrown in 2.10, will be thrown in 2.11 + } catch { + // Not thrown in 2.11, is thrown in 2.12 case ex: IndexOutOfBoundsException => println(ex) } checkNotCorrupted(lb1) @@ -28,7 +29,7 @@ object Test extends dotty.runtime.LegacyApp { try { lb2.remove(99, 6) } catch { - // Not thrown in 2.10, will be thrown in 2.11 + // Not thrown in 2.11, is thrown in 2.12 case ex: IndexOutOfBoundsException => println(ex) } checkNotCorrupted(lb2) @@ -38,26 +39,27 @@ object Test extends dotty.runtime.LegacyApp { try { lb3.remove(1, 9) } catch { - // Not thrown in 2.10, will be thrown in 2.11 - case ex: IllegalArgumentException => println(ex) + // Not thrown in 2.11, is thrown in 2.12 + case ex: IndexOutOfBoundsException => println(ex) } - checkNotCorrupted(lb3, "ListBuffer('a)", 1) + checkNotCorrupted(lb3) val lb4 = newLB println("Trying lb4 ...") try { lb4.remove(-1, 1) } catch { - // Not thrown in 2.10, will be thrown in 2.11 + // Not thrown in 2.11, is thrown in 2.12 case ex: IndexOutOfBoundsException => println(ex) } - checkNotCorrupted(lb4, "ListBuffer('b, 'c, 'd, 'e)", 4) + checkNotCorrupted(lb4) val lb5 = newLB println("Trying lb5 ...") try { lb5.remove(1, -1) } catch { + // Was thrown prior to 2.12 also case ex: IllegalArgumentException => println(ex) } checkNotCorrupted(lb5) diff --git a/tests/run/t6827.check b/tests/run/t6827.check index 3a3a71c67df2..4889e05be868 100644 --- a/tests/run/t6827.check +++ b/tests/run/t6827.check @@ -1,6 +1,6 @@ -start at -5: java.lang.IllegalArgumentException: requirement failed: start -5 out of range 10 -start at -1: java.lang.IllegalArgumentException: requirement failed: start -1 out of range 10 -start at limit: java.lang.IllegalArgumentException: requirement failed: start 10 out of range 10 +start at -5: java.lang.ArrayIndexOutOfBoundsException: -5 +start at -1: java.lang.ArrayIndexOutOfBoundsException: -1 +start at limit: ok start at limit-1: ok first 10: ok read all: ok @@ -8,8 +8,8 @@ test huge len: ok 5 from 5: ok 20 from 5: ok test len overflow: ok -start beyond limit: java.lang.IllegalArgumentException: requirement failed: start 30 out of range 10 +start beyond limit: ok read 0: ok read -1: ok -invalid read 0: java.lang.IllegalArgumentException: requirement failed: start 30 out of range 10 -invalid read -1: java.lang.IllegalArgumentException: requirement failed: start 30 out of range 10 +invalid read 0: ok +invalid read -1: ok diff --git a/tests/run/t6827.scala b/tests/run/t6827.scala index b7366c90a0f1..43e01831c340 100644 --- a/tests/run/t6827.scala +++ b/tests/run/t6827.scala @@ -1,4 +1,4 @@ -object Test extends dotty.runtime.LegacyApp { +object Test extends App { val ns = (0 until 20) val arr = new Array[Int](10) @@ -29,6 +29,26 @@ object Test extends dotty.runtime.LegacyApp { tryit("invalid read 0", 30, 0) tryit("invalid read -1", 30, -1) - // okay, see SI-7128 + // okay, see scala/bug#7128 "...".toIterator.copyToArray(new Array[Char](0), 0, 0) + + + // Bonus test from @som-snytt to check for overflow in + // index calculations. + def testOverflow(start: Int, len: Int, expected: List[Char]) = { + def copyFromIterator = { + val arr = Array.fill[Char](3)('-') + "abc".toIterator.copyToArray(arr, start, len) + arr.toList + } + def copyFromArray = { + val arr = Array.fill[Char](3)('-') + "abc".toArray.copyToArray(arr, start, len) + arr.toList + } + assert(copyFromIterator == expected) + assert(copyFromArray == expected) + } + testOverflow(1, Int.MaxValue - 1, "-ab".toList) + testOverflow(1, Int.MaxValue, "-ab".toList) } diff --git a/tests/run/unittest_collection.scala b/tests/run/unittest_collection.scala index d10845475b74..8be8ea1a5927 100644 --- a/tests/run/unittest_collection.scala +++ b/tests/run/unittest_collection.scala @@ -5,7 +5,7 @@ object Test { def main(args: Array[String]): Unit = { test(collection.mutable.ArrayBuffer[String]()) test(collection.mutable.ListBuffer[String]()) - class BBuf(z:ListBuffer[String]) extends BufferProxy[String] { + class BBuf(z:ListBuffer[String]) extends BufferProxy[String] { // @odersky - bug here in scala 2.12 trait encoding seems like... def self = z } test(new BBuf(collection.mutable.ListBuffer[String]()))