From 226c7cb390d53acc2c18918d5a8f4b7133d4a4ac Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 25 Jul 2016 10:35:59 +0200 Subject: [PATCH 1/2] Fix #1385: Temporarily lift 22 limit for functions --- src/dotty/tools/dotc/core/Definitions.scala | 10 ++++++++-- src/scala/Function23.scala | 21 +++++++++++++++++++++ src/scala/Function24.scala | 21 +++++++++++++++++++++ tests/pos/i1385.scala | 7 +++++++ 4 files changed, 57 insertions(+), 2 deletions(-) create mode 100644 src/scala/Function23.scala create mode 100644 src/scala/Function24.scala create mode 100644 tests/pos/i1385.scala diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala index 6d183fe40ab7..34b2d056246e 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -12,7 +12,13 @@ import collection.mutable import scala.reflect.api.{ Universe => ApiUniverse } object Definitions { - val MaxFunctionArity, MaxTupleArity = 22 + val MaxTupleArity, MaxAbstractFunctionArity = 22 + val MaxFunctionArity = 24 + // Awaiting a definite solution that drops the limit altogether, 44 gives a safety + // margin over the previous 22, so that treecopiers in miniphases are allowed to + // temporarily create larger closures. This is needed in lambda lift where large closures + // are first formed by treecopiers before they are split apart into parameters and + // environment in the lambdalift transform itself. } /** A class defining symbols and types of standard definitions @@ -587,7 +593,7 @@ class Definitions { // ----- Symbol sets --------------------------------------------------- - lazy val AbstractFunctionType = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0) + lazy val AbstractFunctionType = mkArityArray("scala.runtime.AbstractFunction", MaxAbstractFunctionArity, 0) val AbstractFunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => AbstractFunctionType.map(_.symbol.asClass)) def AbstractFunctionClass(n: Int)(implicit ctx: Context) = AbstractFunctionClassPerRun()(ctx)(n) lazy val FunctionType = mkArityArray("scala.Function", MaxFunctionArity, 0) diff --git a/src/scala/Function23.scala b/src/scala/Function23.scala new file mode 100644 index 000000000000..254772d53ff2 --- /dev/null +++ b/src/scala/Function23.scala @@ -0,0 +1,21 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ +package scala + + +/** A function of 23 parameters. Used as a temporary fix until arity limit is dropped. + * + */ +trait Function23[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, +R] extends AnyRef { self => + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23): R + + override def toString() = "" +} diff --git a/src/scala/Function24.scala b/src/scala/Function24.scala new file mode 100644 index 000000000000..8af8ed995983 --- /dev/null +++ b/src/scala/Function24.scala @@ -0,0 +1,21 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ +package scala + + +/** A function of 24 parameters. Used as a temporary fix until arity limit is dropped. + * + */ +trait Function24[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, +R] extends AnyRef { self => + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24): R + + override def toString() = "" +} diff --git a/tests/pos/i1385.scala b/tests/pos/i1385.scala new file mode 100644 index 000000000000..d9fc015ce498 --- /dev/null +++ b/tests/pos/i1385.scala @@ -0,0 +1,7 @@ +object Test { +def foo22[T](c1:T, c2:T, c3:T, c4:T, c5:T, c6:T, c7:T, c8:T, c9:T, c10:T, c11:T, c12:T, c13:T, c14:T, c15:T, c16:T, c17:T, c18:T, c19:T, c20:T, c21:T, c22:T): Int => T = { + (a: Int) => { // This labda ends with 23 parameters (c1 to c22 and a) + c22; c21; c20; c19; c18; c17; c16; c15; c14; c13; c12; c11; c10; c9; c8; c7; c6; c5; c4; c3; c2; c1 + } + } +} From a42c4eccdbb623d4f00b406e6985336deb4f3922 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 25 Jul 2016 12:26:33 +0200 Subject: [PATCH 2/2] Adress reviewers comments --- src/dotty/tools/dotc/core/Definitions.scala | 2 +- tests/pos/i1385.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala index 34b2d056246e..5a19903bef29 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -14,7 +14,7 @@ import scala.reflect.api.{ Universe => ApiUniverse } object Definitions { val MaxTupleArity, MaxAbstractFunctionArity = 22 val MaxFunctionArity = 24 - // Awaiting a definite solution that drops the limit altogether, 44 gives a safety + // Awaiting a definite solution that drops the limit altogether, 24 gives a safety // margin over the previous 22, so that treecopiers in miniphases are allowed to // temporarily create larger closures. This is needed in lambda lift where large closures // are first formed by treecopiers before they are split apart into parameters and diff --git a/tests/pos/i1385.scala b/tests/pos/i1385.scala index d9fc015ce498..87a0127cb54e 100644 --- a/tests/pos/i1385.scala +++ b/tests/pos/i1385.scala @@ -1,6 +1,6 @@ object Test { def foo22[T](c1:T, c2:T, c3:T, c4:T, c5:T, c6:T, c7:T, c8:T, c9:T, c10:T, c11:T, c12:T, c13:T, c14:T, c15:T, c16:T, c17:T, c18:T, c19:T, c20:T, c21:T, c22:T): Int => T = { - (a: Int) => { // This labda ends with 23 parameters (c1 to c22 and a) + (a: Int) => { // This lambda ends with 23 parameters (c1 to c22 and a) c22; c21; c20; c19; c18; c17; c16; c15; c14; c13; c12; c11; c10; c9; c8; c7; c6; c5; c4; c3; c2; c1 } }