diff options
110 files changed, 5465 insertions, 390 deletions
@@ -1377,6 +1377,7 @@ QUICK BUILD (QUICK) <pathelement location="${ant.jar}"/> <path refid="forkjoin.classpath"/> <path refid="fjbg.classpath"/> + <path refid="asm.classpath"/> <pathelement location="${scalacheck.jar}"/> </compilationpath> </scalacfork> diff --git a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala index 8a3c531ff0..caf6ad14cf 100644 --- a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala @@ -33,7 +33,7 @@ class OfflineCompilerCommand(arguments: List[String], settings: FscSettings) ext } else { // Otherwise we're on the server and will use it to absolutize the paths. - settings.absolutize(currentDir.value) + settings.absolutize() } } diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index 54402f0903..def1198dae 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -111,7 +111,7 @@ trait Trees extends scala.reflect.internal.Trees { self: Global => rhs = EmptyTree ) } - val lvdefs = evdefs collect { case vdef: ValDef => copyValDef(vdef)(mods = Modifiers(PRESUPER)) } + val lvdefs = evdefs collect { case vdef: ValDef => copyValDef(vdef)(mods = vdef.mods | PRESUPER) } val constrs = { if (constrMods hasFlag TRAIT) { diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 33db4ee2d5..c508e14343 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -980,11 +980,8 @@ self => /** Assumed (provisionally) to be TermNames. */ def ident(skipIt: Boolean): Name = - if (isIdent) { - val name = in.name.encode - in.nextToken() - name - } else { + if (isIdent) rawIdent().encode + else { syntaxErrorOrIncomplete(expectedMsg(IDENTIFIER), skipIt) nme.ERROR } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 4f564c5d0b..046122d83b 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -113,6 +113,11 @@ trait Scanners extends ScannersCommon { cbuf.append(c) } + /** Determines whether this scanner should emit identifier deprecation warnings, + * e.g. when seeing `macro` or `then`, which are planned to become keywords in future versions of Scala. + */ + protected def emitIdentifierDeprecationWarnings = true + /** Clear buffer and set name and token */ private def finishNamed(idtoken: Int = IDENTIFIER) { name = newTermName(cbuf.toString) @@ -122,7 +127,7 @@ trait Scanners extends ScannersCommon { val idx = name.start - kwOffset if (idx >= 0 && idx < kwArray.length) { token = kwArray(idx) - if (token == IDENTIFIER && allowIdent != name) + if (token == IDENTIFIER && allowIdent != name && emitIdentifierDeprecationWarnings) deprecationWarning(name+" is now a reserved word; usage as an identifier is deprecated") } } @@ -607,7 +612,10 @@ trait Scanners extends ScannersCommon { if (ch == '`') { nextChar() finishNamed(BACKQUOTED_IDENT) - if (name.length == 0) syntaxError("empty quoted identifier") + if (name.length == 0) + syntaxError("empty quoted identifier") + else if (name == nme.WILDCARD) + syntaxError("wildcard invalid as backquoted identifier") } else syntaxError("unclosed quoted identifier") } @@ -1488,6 +1496,10 @@ trait Scanners extends ScannersCommon { def improves(patches1: List[BracePatch]): Boolean = imbalanceMeasure > new ParensAnalyzer(unit, patches1).imbalanceMeasure + // don't emit deprecation warnings about identifiers like `macro` or `then` + // when skimming through the source file trying to heal braces + override def emitIdentifierDeprecationWarnings = false + override def error(offset: Int, msg: String) {} } } diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index f94055f666..ac8ab493e0 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -258,7 +258,7 @@ abstract class TreeBuilder { /** Create tree representing a while loop */ def makeWhile(lname: TermName, cond: Tree, body: Tree): Tree = { - val continu = atPos(o2p(body.pos.endOrPoint)) { Apply(Ident(lname), Nil) } + val continu = atPos(o2p(body.pos pointOrElse wrappingPos(List(cond, body)).pos.endOrPoint)) { Apply(Ident(lname), Nil) } val rhs = If(cond, Block(List(body), continu), Literal(Constant())) LabelDef(lname, Nil, rhs) } diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index fd2b11898c..44d7a1929b 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -1164,34 +1164,28 @@ abstract class GenICode extends SubComponent { resCtx } - private def adapt(from: TypeKind, to: TypeKind, ctx: Context, pos: Position): Unit = { - if (!(from <:< to) && !(from == NullReference && to == NothingReference)) { - to match { - case UNIT => - ctx.bb.emit(DROP(from), pos) - debuglog("Dropped an " + from); - - case _ => - debugassert(from != UNIT, "Can't convert from UNIT to " + to + " at: " + pos) - assert(!from.isReferenceType && !to.isReferenceType, - "type error: can't convert from " + from + " to " + to +" in unit " + unit.source + " at " + pos) - - ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)), pos) - } - } else if (from == NothingReference) { - ctx.bb.emit(THROW(ThrowableClass)) - ctx.bb.enterIgnoreMode - } else if (from == NullReference) { - ctx.bb.emit(DROP(from)) - ctx.bb.emit(CONSTANT(Constant(null))) + private def adapt(from: TypeKind, to: TypeKind, ctx: Context, pos: Position) { + // An awful lot of bugs explode here - let's leave ourselves more clues. + // A typical example is an overloaded type assigned after typer. + log(s"GenICode#adapt($from, $to, $ctx, $pos)") + + val conforms = (from <:< to) || (from == NullReference && to == NothingReference) + def coerce(from: TypeKind, to: TypeKind) = ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)), pos) + def checkAssertions() { + def msg = s"Can't convert from $from to $to in unit ${unit.source} at $pos" + debugassert(from != UNIT, msg) + assert(!from.isReferenceType && !to.isReferenceType, msg) } - else if (from == ThrowableReference && !(ThrowableClass.tpe <:< to.toType)) { - log("Inserted check-cast on throwable to " + to + " at " + pos) - ctx.bb.emit(CHECK_CAST(to)) + if (conforms) from match { + case NothingReference => ctx.bb.emit(THROW(ThrowableClass)) ; ctx.bb.enterIgnoreMode + case NullReference => ctx.bb.emit(Seq(DROP(from), CONSTANT(Constant(null)))) + case ThrowableReference if !(ThrowableClass.tpe <:< to.toType) => ctx.bb.emit(CHECK_CAST(to)) // downcast throwables + case BYTE | SHORT | CHAR | INT if to == LONG => coerce(INT, LONG) // widen subrange types + case _ => () } - else (from, to) match { - case (BYTE, LONG) | (SHORT, LONG) | (CHAR, LONG) | (INT, LONG) => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, LONG))) - case _ => () + else to match { + case UNIT => ctx.bb.emit(DROP(from), pos) // value discarding + case _ => checkAssertions() ; coerce(from, to) // other primitive coercions } } @@ -1907,18 +1901,8 @@ abstract class GenICode extends SubComponent { var handlerCount = 0 - override def toString(): String = { - val buf = new StringBuilder() - buf.append("\tpackage: ").append(packg).append('\n') - buf.append("\tclazz: ").append(clazz).append('\n') - buf.append("\tmethod: ").append(method).append('\n') - buf.append("\tbb: ").append(bb).append('\n') - buf.append("\tlabels: ").append(labels).append('\n') - buf.append("\texception handlers: ").append(handlers).append('\n') - buf.append("\tcleanups: ").append(cleanups).append('\n') - buf.append("\tscope: ").append(scope).append('\n') - buf.toString() - } + override def toString = + s"package $packg { class $clazz { def $method { bb=$bb } } }" def loadException(ctx: Context, exh: ExceptionHandler, pos: Position) = { debuglog("Emitting LOAD_EXCEPTION for class: " + exh.loadExceptionClass) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index d185ed0c34..0abbe44b02 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -1018,7 +1018,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { if (needsAnnotation) { val c = Constant(RemoteExceptionClass.tpe) val arg = Literal(c) setType c.tpe - meth.addAnnotation(ThrowsClass, arg) + meth.addAnnotation(appliedType(ThrowsClass, c.tpe), arg) } } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index fe0020e074..598965b982 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -888,7 +888,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with if (needsAnnotation) { val c = Constant(RemoteExceptionClass.tpe) val arg = Literal(c) setType c.tpe - meth.addAnnotation(ThrowsClass, arg) + meth.addAnnotation(appliedType(ThrowsClass, c.tpe), arg) } } diff --git a/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala index 10e2f23142..4ee6daf73e 100755 --- a/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala +++ b/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala @@ -20,7 +20,7 @@ object IndexModelFactory { /* Owner template ordering */ implicit def orderingSet = math.Ordering.String.on { x: MemberEntity => x.name.toLowerCase } /* symbol name ordering */ - implicit def orderingMap = math.Ordering.String.on { x: String => x.toLowerCase } + implicit def orderingMap = math.Ordering.String def addMember(d: MemberEntity) = { val firstLetter = { diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala index 10f972452f..5fd5b41625 100644 --- a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala @@ -37,6 +37,9 @@ class JLineReader(_completion: => Completion) extends InteractiveReader { } class JLineConsoleReader extends ConsoleReader with ConsoleReaderHelper { + if ((history: History) ne NoHistory) + this setHistory history + // working around protected/trait/java insufficiencies. def goBack(num: Int): Unit = back(num) def readOneKey(prompt: String) = { @@ -51,8 +54,6 @@ class JLineReader(_completion: => Completion) extends InteractiveReader { // A hook for running code after the repl is done initializing. lazy val postInit: Unit = { this setBellEnabled false - if ((history: History) ne NoHistory) - this setHistory history if (completion ne NoCompletion) { val argCompletor: ArgumentCompleter = diff --git a/src/compiler/scala/tools/nsc/settings/FscSettings.scala b/src/compiler/scala/tools/nsc/settings/FscSettings.scala index 06ebc20d3e..5c852ae07c 100644 --- a/src/compiler/scala/tools/nsc/settings/FscSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/FscSettings.scala @@ -38,14 +38,25 @@ class FscSettings(error: String => Unit) extends Settings(error) { private def holdsPath = Set[Settings#Setting]( d, dependencyfile, pluginsDir, Ygenjavap ) + + override def processArguments(arguments: List[String], processAll: Boolean): (Boolean, List[String]) = { + val (r, args) = super.processArguments(arguments, processAll) + // we need to ensure the files specified with relative locations are absolutized based on the currentDir + (r, args map {a => absolutizePath(a)}) + } + + /** + * Take an individual path and if it's not absolute turns it into an absolute path based on currentDir. + * If it's already absolute then it's left alone. + */ + private[this] def absolutizePath(p: String) = (Path(currentDir.value) resolve Path(p)).normalize.path - /** All user set settings rewritten with absolute paths. */ - def absolutize(root: Path) { - def rewrite(p: String) = (root resolve Path(p)).normalize.path + /** All user set settings rewritten with absolute paths based on currentDir */ + def absolutize() { userSetSettings foreach { - case p: OutputSetting => p.outputDirs setSingleOutput AbstractFile.getDirectory(rewrite(p.value)) - case p: PathSetting => p.value = ClassPath.map(p.value, rewrite) - case p: StringSetting => if (holdsPath(p)) p.value = rewrite(p.value) + case p: OutputSetting => p.outputDirs setSingleOutput AbstractFile.getDirectory(absolutizePath(p.value)) + case p: PathSetting => p.value = ClassPath.map(p.value, absolutizePath) + case p: StringSetting => if (holdsPath(p)) p.value = absolutizePath(p.value) case _ => () } } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index a708a262e7..4b1d3c34f3 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -1043,7 +1043,13 @@ abstract class ClassfileParser { val nClasses = in.nextChar for (n <- 0 until nClasses) { val cls = pool.getClassSymbol(in.nextChar.toInt) - sym.addAnnotation(definitions.ThrowsClass, Literal(Constant(cls.tpe))) + val tp = if (cls.isMonomorphicType) cls.tpe else { + debuglog(s"Encountered polymorphic exception `${cls.fullName}` while parsing class file.") + // in case we encounter polymorphic exception the best we can do is to convert that type to + // monomorphic one by introducing existientals, see SI-7009 for details + typer.packSymbols(cls.typeParams, cls.tpe) + } + sym.addAnnotation(appliedType(definitions.ThrowsClass, tp), Literal(Constant(tp))) } } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 25b7813646..e8b0cd2696 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -71,8 +71,8 @@ abstract class Pickler extends SubComponent { if (!t.isDef && t.hasSymbol && t.symbol.isTermMacro) { unit.error(t.pos, t.symbol.typeParams.length match { case 0 => "macro has not been expanded" - case 1 => "type parameter not specified" - case _ => "type parameters not specified" + case 1 => "this type parameter must be specified" + case _ => "these type parameters must be specified" }) return } diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index 44510ab0c2..7a0b034fd0 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -450,19 +450,31 @@ abstract class CleanUp extends Transform with ast.TreeDSL { * is a value type (int et al.) in which case it must cast to the boxed version * because invoke only returns object and erasure made sure the result is * expected to be an AnyRef. */ - val t: Tree = ad.symbol.tpe match { - case MethodType(mparams, resType) => - assert(params.length == mparams.length, mparams) - - typedPos { - val sym = currentOwner.newValue(mkTerm("qual"), ad.pos) setInfo qual0.tpe - qual = REF(sym) + val t: Tree = { + val (mparams, resType) = ad.symbol.tpe match { + case MethodType(mparams, resType) => + assert(params.length == mparams.length, ((params, mparams))) + (mparams, resType) + case tpe @ OverloadedType(pre, alts) => + unit.warning(ad.pos, s"Overloaded type reached the backend! This is a bug in scalac.\n Symbol: ${ad.symbol}\n Overloads: $tpe\n Arguments: " + ad.args.map(_.tpe)) + alts filter (_.paramss.flatten.size == params.length) map (_.tpe) match { + case mt @ MethodType(mparams, resType) :: Nil => + unit.warning(NoPosition, "Only one overload has the right arity, proceeding with overload " + mt) + (mparams, resType) + case _ => + unit.error(ad.pos, "Cannot resolve overload.") + (Nil, NoType) + } + } + typedPos { + val sym = currentOwner.newValue(mkTerm("qual"), ad.pos) setInfo qual0.tpe + qual = REF(sym) - BLOCK( - VAL(sym) === qual0, - callAsReflective(mparams map (_.tpe), resType) - ) - } + BLOCK( + VAL(sym) === qual0, + callAsReflective(mparams map (_.tpe), resType) + ) + } } /* For testing purposes, the dynamic application's condition diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala index 39e16c3f58..589aa43ac2 100644 --- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala +++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala @@ -75,7 +75,19 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { val candidates = extensionNames(imeth) map (companionInfo.decl(_)) filter (_.exists) val matching = candidates filter (alt => normalize(alt.tpe, imeth.owner) matches imeth.tpe) assert(matching.nonEmpty, - s"no extension method found for $imeth:${imeth.tpe} among ${candidates.map(c => c.name+":"+c.tpe).toList} / ${extensionNames(imeth).toList}") + sm"""|no extension method found for: + | + | $imeth:${imeth.tpe} + | + | Candidates: + | + | ${candidates.map(c => c.name+":"+c.tpe).mkString("\n")} + | + | Candidates (signatures normalized): + | + | ${candidates.map(c => c.name+":"+normalize(c.tpe, imeth.owner)).mkString("\n")} + | + | Eligible Names: ${extensionNames(imeth).mkString(",")}"""") matching.head } @@ -94,11 +106,18 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { */ private def normalize(stpe: Type, clazz: Symbol): Type = stpe match { case PolyType(tparams, restpe) => - GenPolyType(tparams dropRight clazz.typeParams.length, normalize(restpe.substSym(tparams takeRight clazz.typeParams.length, clazz.typeParams), clazz)) + // Split the type parameters of the extension method into two groups, + // corresponding the to class and method type parameters. + val numClassParams = clazz.typeParams.length + val methTParams = tparams dropRight numClassParams + val classTParams = tparams takeRight numClassParams + + GenPolyType(methTParams, + normalize(restpe.substSym(classTParams, clazz.typeParams), clazz)) case MethodType(List(thiz), restpe) if thiz.name == nme.SELF => - restpe - case MethodType(tparams, restpe) => - MethodType(tparams.drop(1), restpe) + restpe.substituteTypes(thiz :: Nil, clazz.thisType :: Nil) + case MethodType(thiz :: params, restpe) => + MethodType(params, restpe) case _ => stpe } @@ -128,7 +147,11 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { MethodType(List(thisParam), restpe) } val GenPolyType(tparams, restpe) = origInfo cloneInfo extensionMeth - GenPolyType(tparams ::: newTypeParams, transform(restpe) substSym (clazz.typeParams, newTypeParams)) + val selfParamSingletonType = singleType(currentOwner.companionModule.thisType, thisParam) + GenPolyType( + tparams ::: newTypeParams, + transform(restpe) substThisAndSym (clazz, selfParamSingletonType, clazz.typeParams, newTypeParams) + ) } private def allParams(tpe: Type): List[Symbol] = tpe match { @@ -162,7 +185,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { origMeth.defString, extensionMeth.defString)) // extensionMeth.defStringSeenAs(origInfo - def thisParamRef = gen.mkAttributedIdent(extensionMeth.info.params.head setPos extensionMeth.pos) + def thisParamRef = gen.mkAttributedStableRef(extensionMeth.info.params.head setPos extensionMeth.pos) val GenPolyType(extensionTpeParams, extensionMono) = extensionMeth.info val origTpeParams = (tparams map (_.symbol)) ::: currentOwner.typeParams val extensionBody = rhs diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 3cd943aa74..c9c68d080d 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -867,7 +867,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { rhs match { case Block(List(assign), returnTree) => val Assign(moduleVarRef, _) = assign - val cond = Apply(Select(moduleVarRef, nme.eq), List(NULL)) + val cond = Apply(Select(moduleVarRef, Object_eq), List(NULL)) mkFastPathBody(clazz, moduleSym, cond, List(assign), List(NULL), returnTree, attrThis, args) case _ => abort("Invalid getter " + rhs + " for module in class " + clazz) diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 64051b56ec..232148676c 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -178,6 +178,14 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { case class Overload(sym: Symbol, env: TypeEnv) { override def toString = "specialized overload " + sym + " in " + env + def matchesSym(other: Symbol) = sym.tpe =:= other.tpe + def matchesEnv(env1: TypeEnv) = TypeEnv.includes(env, env1) + } + private def newOverload(method: Symbol, specializedMethod: Symbol, env: TypeEnv) = { + assert(!specializedMethod.isOverloaded, specializedMethod.defString) + val om = Overload(specializedMethod, env) + overloads(method) ::= om + om } /** Just to mark uncheckable */ @@ -289,10 +297,6 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } } - /** Return the specialized overload of sym in the given env, if any. */ - def overload(sym: Symbol, env: TypeEnv) = - overloads(sym).find(ov => TypeEnv.includes(ov.env, env)) - /** Return the specialized name of 'sym' in the given environment. It * guarantees the same result regardless of the map order by sorting * type variables alphabetically. @@ -628,7 +632,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { info(om) = if (original.isDeferred) Forward(original) else Implementation(original) typeEnv(om) = env ++ typeEnv(m) // add the environment for any method tparams - overloads(specMember) ::= Overload(om, typeEnv(om)) + newOverload(specMember, om, typeEnv(om)) enterMember(om) } @@ -835,7 +839,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { debuglog("%s expands to %s in %s".format(sym, specMember.name.decode, pp(env))) info(specMember) = NormalizedMember(sym) - overloads(sym) ::= Overload(specMember, env) + newOverload(sym, specMember, env) owner.info.decls.enter(specMember) specMember } @@ -877,9 +881,8 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { if (wasSpec.nonEmpty) debuglog("specialized overload for %s in %s".format(specMember, pp(typeEnv(specMember)))) - overloads(sym) ::= Overload(specMember, spec) + newOverload(sym, specMember, spec) info(specMember) = SpecialOverload(sym, typeEnv(specMember)) - specMember } @@ -994,7 +997,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { SpecialOverride(impl) } ) - overloads(overriding) ::= Overload(om, env) + newOverload(overriding, om, env) ifDebug(afterSpecialize(assert( overridden.owner.info.decl(om.name) != NoSymbol, "Could not find " + om.name + " in " + overridden.owner.info.decls)) @@ -1476,54 +1479,41 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { } transformTypeApply - case Select(qual, name) => - def transformSelect = { - qual match { - case _: Super if illegalSpecializedInheritance(currentClass) => - val pos = tree.pos - debuglog(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.") - debuglog(pos.lineContent) - tree - case _ => + case Select(Super(_, _), _) if illegalSpecializedInheritance(currentClass) => + val pos = tree.pos + debuglog(pos.source.file.name+":"+pos.line+": not specializing call to super inside illegal specialized inheritance class.\n" + pos.lineContent) + tree + case Select(qual, name) if name != nme.CONSTRUCTOR && specializedTypeVars(symbol.info).nonEmpty => debuglog("specializing Select %s [tree.tpe: %s]".format(symbol.defString, tree.tpe)) - - //log("!!! select " + tree + " -> " + symbol.info + " specTypeVars: " + specializedTypeVars(symbol.info)) - if (specializedTypeVars(symbol.info).nonEmpty && name != nme.CONSTRUCTOR) { - // log("!!! unifying " + (symbol, symbol.tpe) + " and " + (tree, tree.tpe)) - val env = unify(symbol.tpe, tree.tpe, emptyEnv, false) - // log("!!! found env: " + env + "; overloads: " + overloads(symbol)) - if (!env.isEmpty) { - // debuglog("checking for rerouting: " + tree + " with sym.tpe: " + symbol.tpe + " tree.tpe: " + tree.tpe + " env: " + env) - val specMember = overload(symbol, env) - if (specMember.isDefined) { - localTyper.typedOperator(atPos(tree.pos)(Select(transform(qual), specMember.get.sym.name))) - } - else { - val qual1 = transform(qual) + val env = unify(symbol.tpe, tree.tpe, emptyEnv, false) + if (env.isEmpty) super.transform(tree) + else { + val qual1 = transform(qual) + def reselect(member: Symbol) = { + val newSelect = atPos(tree.pos)(Select(qual1, member)) + if (member.isMethod) localTyper typedOperator newSelect + else localTyper typed newSelect + } + overloads(symbol) find (_ matchesEnv env) match { + case Some(Overload(member, _)) => reselect(member) + case _ => val specMember = qual1.tpe.member(specializedName(symbol, env)).suchThat(_.tpe matches subst(env, symbol.tpe)) - if (specMember ne NoSymbol) { - val tree1 = atPos(tree.pos)(Select(qual1, specMember)) - if (specMember.isMethod) - localTyper.typedOperator(tree1) - else - localTyper.typed(tree1) - } else + if (specMember ne NoSymbol) + reselect(specMember) + else treeCopy.Select(tree, qual1, name) - } - } else - super.transform(tree) - } else overloads(symbol).find(_.sym.info =:= symbol.info) match { - case Some(specMember) => - val qual1 = transform(qual) - debuglog("** routing " + tree + " to " + specMember.sym.fullName + " tree: " + Select(qual1, specMember.sym)) - localTyper.typedOperator(atPos(tree.pos)(Select(qual1, specMember.sym))) - case None => - super.transform(tree) - } + } } + case Select(qual, _) => + overloads(symbol) find (_ matchesSym symbol) match { + case Some(Overload(member, _)) => + val newTree = Select(transform(qual), member) + debuglog(s"** routing $tree to ${member.fullName} tree: $newTree") + localTyper.typedOperator(atPos(tree.pos)(newTree)) + case None => + super.transform(tree) } - transformSelect case PackageDef(pid, stats) => tree.symbol.info // make sure specializations have been performed diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index c07177ec10..f338e390bb 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -627,7 +627,7 @@ abstract class UnCurry extends InfoTransform } } - case Assign(Select(_, _), _) => + case Assign(_: RefTree, _) => withNeedLift(true) { super.transform(tree) } case Assign(lhs, _) if lhs.symbol.owner != currentMethod || lhs.symbol.hasFlag(LAZY | ACCESSOR) => diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index dc367b11fd..2e5d61cc6b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -273,9 +273,6 @@ trait ContextErrors { def VolatileValueError(vdef: Tree) = issueNormalTypeError(vdef, "values cannot be volatile") - def FinalVolatileVarError(vdef: Tree) = - issueNormalTypeError(vdef, "final vars cannot be volatile") - def LocalVarUninitializedError(vdef: Tree) = issueNormalTypeError(vdef, "local variables must be initialized") diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index df753ba53c..0b46582cbf 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -317,15 +317,33 @@ abstract class Duplicators extends Analyzer { super.typed(tree, mode, pt) case Select(th @ This(_), sel) if (oldClassOwner ne null) && (th.symbol == oldClassOwner) => - // log("selection on this, no type ascription required") - // we use the symbol name instead of the tree name because the symbol may have been - // name mangled, rendering the tree name obsolete - // log(tree) - val t = super.typedPos(tree.pos, mode, pt) { - Select(This(newClassOwner), tree.symbol.name) - } - // log("typed to: " + t + "; tpe = " + t.tpe + "; " + inspectTpe(t.tpe)) - t + // We use the symbol name instead of the tree name because the symbol + // may have been name mangled, rendering the tree name obsolete. + // ...but you can't just do a Select on a name because if the symbol is + // overloaded, you will crash in the backend. + val memberByName = newClassOwner.thisType.member(tree.symbol.name) + def nameSelection = Select(This(newClassOwner), tree.symbol.name) + val newTree = ( + if (memberByName.isOverloaded) { + // Find the types of the overload alternatives as seen in the new class, + // and filter the list down to those which match the old type (after + // fixing the old type so it is seen as if from the new class.) + val typeInNewClass = fixType(oldClassOwner.info memberType tree.symbol) + val alts = memberByName.alternatives + val memberTypes = alts map (newClassOwner.info memberType _) + val memberString = memberByName.defString + alts zip memberTypes filter (_._2 =:= typeInNewClass) match { + case ((alt, tpe)) :: Nil => + log(s"Arrested overloaded type in Duplicators, narrowing to ${alt.defStringSeenAs(tpe)}\n Overload was: $memberString") + Select(This(newClassOwner), alt) + case _ => + log(s"Could not disambiguate $memberString in Duplicators. Attempting name-based selection, but this may not end well...") + nameSelection + } + } + else nameSelection + ) + super.typed(atPos(tree.pos)(newTree), mode, pt) case This(_) if (oldClassOwner ne null) && (tree.symbol == oldClassOwner) => // val tree1 = Typed(This(newClassOwner), TypeTree(fixType(tree.tpe.widen))) diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 2c2aa03d24..581f9f3bfa 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -1578,10 +1578,10 @@ trait Infer extends Checkable { } // Drop those that use a default; keep those that use vararg/tupling conversion. mtypes exists (t => - !t.typeSymbol.hasDefaultFlag && { - compareLengths(t.params, argtpes) < 0 || // tupling (*) - hasExactlyNumParams(t, argtpes.length) // same nb or vararg - } + !t.typeSymbol.hasDefaultFlag && ( + compareLengths(t.params, argtpes) < 0 // tupling (*) + || hasExactlyNumParams(t, argtpes.length) // same nb or vararg + ) ) // (*) more arguments than parameters, but still applicable: tupling conversion works. // todo: should not return "false" when paramTypes = (Unit) no argument is given @@ -1608,15 +1608,18 @@ trait Infer extends Checkable { case OverloadedType(pre, alts) => val pt = if (pt0.typeSymbol == UnitClass) WildcardType else pt0 tryTwice { isSecondTry => - debuglog("infer method alt "+ tree.symbol +" with alternatives "+ - (alts map pre.memberType) +", argtpes = "+ argtpes +", pt = "+ pt) + debuglog(s"infer method alt ${tree.symbol} with alternatives ${alts map pre.memberType} argtpes=$argtpes pt=$pt") - val applicable = resolveOverloadedMethod(argtpes, { - alts filter { alt => - inSilentMode(context)(isApplicable(undetparams, followApply(pre.memberType(alt)), argtpes, pt)) && - (!varArgsOnly || isVarArgsList(alt.tpe.params)) - } - }) + def varargsApplicableCheck(alt: Symbol) = !varArgsOnly || ( + isVarArgsList(alt.tpe.params) + && (argtpes.size >= alt.tpe.params.size) // must be checked now due to SI-5859 + ) + val applicable = resolveOverloadedMethod(argtpes, + alts filter (alt => + varargsApplicableCheck(alt) + && inSilentMode(context)(isApplicable(undetparams, followApply(pre memberType alt), argtpes, pt)) + ) + ) def improves(sym1: Symbol, sym2: Symbol) = { // util.trace("improve "+sym1+sym1.locationString+" on "+sym2+sym2.locationString) diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index b20a9ea626..0ba76643ca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -452,7 +452,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { if (aparam.name != rparam.name && !rparam.isSynthetic) MacroImplParamNameMismatchError(aparam, rparam) if (isRepeated(aparam) ^ isRepeated(rparam)) MacroImplVarargMismatchError(aparam, rparam) val aparamtpe = aparam.tpe.dealias match { - case RefinedType(List(tpe), Scope(sym)) if tpe == MacroContextClass.tpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe + case RefinedType(List(tpe), Scope(sym)) if tpe =:= MacroContextClass.tpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe case tpe => tpe } checkMacroImplParamTypeMismatch(atpeToRtpe(aparamtpe), rparam) diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index be218fcb02..2340c78f8c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -268,26 +268,32 @@ trait NamesDefaults { self: Analyzer => * * For by-name parameters, create a value * x$n: () => T = () => arg + * + * For Ident(<unapply-selector>) arguments, no ValDef is created (SI-3353). */ - def argValDefs(args: List[Tree], paramTypes: List[Type], blockTyper: Typer): List[ValDef] = { + def argValDefs(args: List[Tree], paramTypes: List[Type], blockTyper: Typer): List[Option[ValDef]] = { val context = blockTyper.context - val symPs = map2(args, paramTypes)((arg, tpe) => { - val byName = isByNameParamType(tpe) - val repeated = isScalaRepeatedParamType(tpe) - val argTpe = ( - if (repeated) arg match { - case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => expr.tpe - case _ => seqType(arg.tpe) - } - else 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 ( - if (byName) functionType(Nil, argTpe) else argTpe - ) - (context.scope.enter(s), byName, repeated) + val symPs = map2(args, paramTypes)((arg, tpe) => arg match { + case Ident(nme.SELECTOR_DUMMY) => + None // don't create a local ValDef if the argument is <unapply-selector> + case _ => + val byName = isByNameParamType(tpe) + val repeated = isScalaRepeatedParamType(tpe) + val argTpe = ( + if (repeated) arg match { + case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => expr.tpe + case _ => seqType(arg.tpe) + } + else 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 ( + if (byName) functionType(Nil, argTpe) else argTpe + ) + Some((context.scope.enter(s), byName, repeated)) }) map2(symPs, args) { - case ((sym, byName, repeated), arg) => + case (None, _) => None + case (Some((sym, byName, repeated)), arg) => val body = if (byName) { val res = blockTyper.typed(Function(List(), arg)) @@ -303,7 +309,7 @@ trait NamesDefaults { self: Analyzer => blockTyper.typed(Apply(factory, List(resetLocalAttrs(arg)))) } else arg } - atPos(body.pos)(ValDef(sym, body).setType(NoType)) + Some(atPos(body.pos)(ValDef(sym, body).setType(NoType))) } } @@ -329,27 +335,29 @@ trait NamesDefaults { self: Analyzer => // ValDef's in the block), change the arguments to these local values. case Apply(expr, typedArgs) => // typedArgs: definition-site order - val formals = formalTypes(expr.tpe.paramTypes, typedArgs.length, false, false) + val formals = formalTypes(expr.tpe.paramTypes, typedArgs.length, removeByName = false, removeRepeated = false) // valDefs: call-site order val valDefs = argValDefs(reorderArgsInv(typedArgs, argPos), reorderArgsInv(formals, argPos), blockTyper) // refArgs: definition-site order again - val refArgs = map2(reorderArgs(valDefs, argPos), formals)((vDef, tpe) => { - val ref = gen.mkAttributedRef(vDef.symbol) - atPos(vDef.pos.focus) { - // for by-name parameters, the local value is a nullary function returning the argument - tpe.typeSymbol match { - case ByNameParamClass => Apply(ref, Nil) - case RepeatedParamClass => Typed(ref, Ident(tpnme.WILDCARD_STAR)) - case _ => ref + val refArgs = map3(reorderArgs(valDefs, argPos), formals, typedArgs)((vDefOpt, tpe, origArg) => vDefOpt match { + case None => origArg + case Some(vDef) => + val ref = gen.mkAttributedRef(vDef.symbol) + atPos(vDef.pos.focus) { + // for by-name parameters, the local value is a nullary function returning the argument + tpe.typeSymbol match { + case ByNameParamClass => Apply(ref, Nil) + case RepeatedParamClass => Typed(ref, Ident(tpnme.WILDCARD_STAR)) + case _ => ref + } } - } }) // cannot call blockTyper.typedBlock here, because the method expr might be partially applied only val res = blockTyper.doTypedApply(tree, expr, refArgs, mode, pt) res.setPos(res.pos.makeTransparent) - val block = Block(stats ::: valDefs, res).setType(res.tpe).setPos(tree.pos.makeTransparent) + val block = Block(stats ::: valDefs.flatten, res).setType(res.tpe).setPos(tree.pos.makeTransparent) context.namedApplyBlockInfo = Some((block, NamedApplyInfo(qual, targs, vargss :+ refArgs, blockTyper))) block diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala index 69bbab6e42..b0745b4c09 100644 --- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala +++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala @@ -746,26 +746,8 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL // reference the (i-1)th case accessor if it exists, otherwise the (i-1)th tuple component override protected def tupleSel(binder: Symbol)(i: Int): Tree = { import CODE._ - // caseFieldAccessors is messed up after typers (reversed, names mangled for non-public fields) - // TODO: figure out why... val accessors = binder.caseFieldAccessors - // luckily, the constrParamAccessors are still sorted properly, so sort the field-accessors using them - // (need to undo name-mangling, including the sneaky trailing whitespace) - val constrParamAccessors = binder.constrParamAccessors - - def indexInCPA(acc: Symbol) = - constrParamAccessors indexWhere { orig => - // patmatDebug("compare: "+ (orig, acc, orig.name, acc.name, (acc.name == orig.name), (acc.name startsWith (orig.name append "$")))) - val origName = orig.name.toString.trim - val accName = acc.name.toString.trim - (accName == origName) || (accName startsWith (origName + "$")) - } - - // patmatDebug("caseFieldAccessors: "+ (accessors, binder.caseFieldAccessors map indexInCPA)) - // patmatDebug("constrParamAccessors: "+ constrParamAccessors) - - val accessorsSorted = accessors sortBy indexInCPA - if (accessorsSorted isDefinedAt (i-1)) REF(binder) DOT accessorsSorted(i-1) + if (accessors isDefinedAt (i-1)) REF(binder) DOT accessors(i-1) else codegen.tupleSel(binder)(i) // this won't type check for case classes, as they do not inherit ProductN } @@ -1897,17 +1879,24 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL case object False extends Prop // symbols are propositions - case class Sym(val variable: Var, val const: Const) extends Prop { - private[this] val id = nextSymId + abstract case class Sym(val variable: Var, val const: Const) extends Prop { + private[this] val id = Sym.nextSymId + override def toString = variable +"="+ const +"#"+ id } - private def nextSymId = {_symId += 1; _symId}; private var _symId = 0 - + class UniqueSym(variable: Var, const: Const) extends Sym(variable, const) + object Sym { + private val uniques: util.HashSet[Sym] = new util.HashSet("uniques", 512) + def apply(variable: Var, const: Const): Sym = { + val newSym = new UniqueSym(variable, const) + (uniques findEntryOrUpdate newSym) + } + private def nextSymId = {_symId += 1; _symId}; private var _symId = 0 + } def /\(props: Iterable[Prop]) = if (props.isEmpty) True else props.reduceLeft(And(_, _)) def \/(props: Iterable[Prop]) = if (props.isEmpty) False else props.reduceLeft(Or(_, _)) - trait PropTraverser { def apply(x: Prop): Unit = x match { case And(a, b) => apply(a); apply(b) @@ -2063,6 +2052,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL import scala.collection.mutable.ArrayBuffer type FormulaBuilder = ArrayBuffer[Clause] def formulaBuilder = ArrayBuffer[Clause]() + def formulaBuilderSized(init: Int) = new ArrayBuffer[Clause](init) def addFormula(buff: FormulaBuilder, f: Formula): Unit = buff ++= f def toFormula(buff: FormulaBuilder): Formula = buff @@ -2167,7 +2157,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL class Lit(val sym: Sym, val pos: Boolean) { override def toString = if (!pos) "-"+ sym.toString else sym.toString override def equals(o: Any) = o match { - case o: Lit => (o.sym == sym) && (o.pos == pos) + case o: Lit => (o.sym eq sym) && (o.pos == pos) case _ => false } override def hashCode = sym.hashCode + pos.hashCode @@ -2216,13 +2206,18 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL } private def withLit(res: Model, l: Lit): Model = if (res eq NoModel) NoModel else res + (l.sym -> l.pos) - private def dropUnit(f: Formula, unitLit: Lit) = { + private def dropUnit(f: Formula, unitLit: Lit): Formula = { val negated = -unitLit // drop entire clauses that are trivially true // (i.e., disjunctions that contain the literal we're making true in the returned model), // and simplify clauses by dropping the negation of the literal we're making true // (since False \/ X == X) - f.filterNot(_.contains(unitLit)).map(_ - negated) + val dropped = formulaBuilderSized(f.size) + for { + clause <- f + if !(clause contains unitLit) + } dropped += (clause - negated) + dropped } def findModelFor(f: Formula): Model = { diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index d1d70370d2..65ba8b1303 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -63,23 +63,8 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans super.transformInfo(sym, tp) } - val toJavaRepeatedParam = new TypeMap { - def apply(tp: Type) = tp match { - case TypeRef(pre, RepeatedParamClass, args) => - typeRef(pre, JavaRepeatedParamClass, args) - case _ => - mapOver(tp) - } - } - - val toScalaRepeatedParam = new TypeMap { - def apply(tp: Type): Type = tp match { - case TypeRef(pre, JavaRepeatedParamClass, args) => - typeRef(pre, RepeatedParamClass, args) - case _ => - mapOver(tp) - } - } + val toJavaRepeatedParam = new SubstSymMap(RepeatedParamClass -> JavaRepeatedParamClass) + val toScalaRepeatedParam = new SubstSymMap(JavaRepeatedParamClass -> RepeatedParamClass) def accessFlagsToString(sym: Symbol) = flagsToString( sym getFlag (PRIVATE | PROTECTED), @@ -159,27 +144,22 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // Override checking ------------------------------------------------------------ - def isJavaVarargsAncestor(clazz: Symbol) = ( - clazz.isClass - && clazz.isJavaDefined - && (clazz.info.nonPrivateDecls exists isJavaVarArgsMethod) - ) - /** Add bridges for vararg methods that extend Java vararg methods */ def addVarargBridges(clazz: Symbol): List[Tree] = { // This is quite expensive, so attempt to skip it completely. // Insist there at least be a java-defined ancestor which // defines a varargs method. TODO: Find a cheaper way to exclude. - if (clazz.thisType.baseClasses exists isJavaVarargsAncestor) { + if (inheritsJavaVarArgsMethod(clazz)) { log("Found java varargs ancestor in " + clazz.fullLocationString + ".") val self = clazz.thisType val bridges = new ListBuffer[Tree] def varargBridge(member: Symbol, bridgetpe: Type): Tree = { - log("Generating varargs bridge for " + member.fullLocationString + " of type " + bridgetpe) + log(s"Generating varargs bridge for ${member.fullLocationString} of type $bridgetpe") - val bridge = member.cloneSymbolImpl(clazz, member.flags | VBRIDGE) setPos clazz.pos + val newFlags = (member.flags | VBRIDGE | ARTIFACT) & ~PRIVATE + val bridge = member.cloneSymbolImpl(clazz, newFlags) setPos clazz.pos bridge.setInfo(bridgetpe.cloneInfo(bridge)) clazz.info.decls enter bridge @@ -192,26 +172,35 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans localTyper typed DefDef(bridge, body) } - // For all concrete non-private members that have a (Scala) repeated parameter: - // compute the corresponding method type `jtpe` with a Java repeated parameter + // For all concrete non-private members (but: see below) that have a (Scala) repeated + // parameter: compute the corresponding method type `jtpe` with a Java repeated parameter // if a method with type `jtpe` exists and that method is not a varargs bridge // then create a varargs bridge of type `jtpe` that forwards to the // member method with the Scala vararg type. - for (member <- clazz.info.nonPrivateMembers) { + // + // @PP: Can't call nonPrivateMembers because we will miss refinement members, + // which have been marked private. See SI-4729. + for (member <- nonTrivialMembers(clazz)) { + log(s"Considering $member for java varargs bridge in $clazz") if (!member.isDeferred && member.isMethod && hasRepeatedParam(member.info)) { val inherited = clazz.info.nonPrivateMemberAdmitting(member.name, VBRIDGE) + // Delaying calling memberType as long as possible if (inherited ne NoSymbol) { - val jtpe = toJavaRepeatedParam(self.memberType(member)) + val jtpe = toJavaRepeatedParam(self memberType member) // this is a bit tortuous: we look for non-private members or bridges // if we find a bridge everything is OK. If we find another member, // we need to create a bridge - if (inherited filter (sym => (self.memberType(sym) matches jtpe) && !(sym hasFlag VBRIDGE)) exists) + val inherited1 = inherited filter (sym => !(sym hasFlag VBRIDGE) && (self memberType sym matches jtpe)) + if (inherited1.exists) bridges += varargBridge(member, jtpe) } } } + if (bridges.size > 0) + log(s"Adding ${bridges.size} bridges for methods extending java varargs.") + bridges.toList } else Nil @@ -908,13 +897,15 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans * the type occurs itself at variance position given by `variance` */ def validateVariance(tp: Type, variance: Int): Unit = tp match { - case ErrorType => ; - case WildcardType => ; - case NoType => ; - case NoPrefix => ; - case ThisType(_) => ; - case ConstantType(_) => ; - // case DeBruijnIndex(_, _) => ; + case ErrorType => + case WildcardType => + case BoundedWildcardType(bounds) => + validateVariance(bounds, variance) + case NoType => + case NoPrefix => + case ThisType(_) => + case ConstantType(_) => + // case DeBruijnIndex(_, _) => case SingleType(pre, sym) => validateVariance(pre, variance) case TypeRef(pre, sym, args) => @@ -1484,8 +1475,11 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } private def isRepeatedParamArg(tree: Tree) = currentApplication match { case Apply(fn, args) => - !args.isEmpty && (args.last eq tree) && - fn.tpe.params.length == args.length && isRepeatedParamType(fn.tpe.params.last.tpe) + ( args.nonEmpty + && (args.last eq tree) + && (fn.tpe.params.length == args.length) + && isRepeatedParamType(fn.tpe.params.last.tpe) + ) case _ => false } diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index a907ab6c66..39f6f764e7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -78,14 +78,7 @@ trait SyntheticMethods extends ast.TreeDSL { else templ } - val originalAccessors = clazz.caseFieldAccessors - // private ones will have been renamed -- make sure they are entered - // in the original order. - def accessors = clazz.caseFieldAccessors sortBy { acc => - originalAccessors indexWhere { orig => - (acc.name == orig.name) || (acc.name startsWith (orig.name append "$")) - } - } + def accessors = clazz.caseFieldAccessors val arity = accessors.size // If this is ProductN[T1, T2, ...], accessorLub is the lub of T1, T2, ..., . // !!! Hidden behind -Xexperimental due to bummer type inference bugs. diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala index 48a5a36b00..c5c3c560ea 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala @@ -117,7 +117,8 @@ abstract class TreeCheckers extends Analyzer { try p.source.path + ":" + p.line catch { case _: UnsupportedOperationException => p.toString } - def errorFn(msg: Any): Unit = println("[check: %s] %s".format(phase.prev, msg)) + private var hasError: Boolean = false + def errorFn(msg: Any): Unit = {hasError = true; println("[check: %s] %s".format(phase.prev, msg))} def errorFn(pos: Position, msg: Any): Unit = errorFn(posstr(pos) + ": " + msg) def informFn(msg: Any) { if (settings.verbose.value || settings.debug.value) @@ -151,6 +152,7 @@ abstract class TreeCheckers extends Analyzer { result } def runWithUnit[T](unit: CompilationUnit)(body: => Unit): Unit = { + hasError = false val unit0 = currentUnit currentRun.currentUnit = unit body @@ -169,6 +171,7 @@ abstract class TreeCheckers extends Analyzer { checker.precheck.traverse(unit.body) checker.typed(unit.body) checker.postcheck.traverse(unit.body) + if (hasError) unit.warning(NoPosition, "TreeCheckers detected non-compliant trees in " + unit) } } @@ -217,8 +220,11 @@ abstract class TreeCheckers extends Analyzer { case _ => () } - object precheck extends Traverser { + object precheck extends TreeStackTraverser { override def traverse(tree: Tree) { + checkSymbolRefsRespectScope(tree) + checkReturnReferencesDirectlyEnclosingDef(tree) + val sym = tree.symbol def accessed = sym.accessed def fail(msg: String) = errorFn(tree.pos, msg + classstr(tree) + " / " + tree) @@ -289,6 +295,41 @@ abstract class TreeCheckers extends Analyzer { } super.traverse(tree) } + + private def checkSymbolRefsRespectScope(tree: Tree) { + def symbolOf(t: Tree): Symbol = Option(tree.symbol).getOrElse(NoSymbol) + def definedSymbolOf(t: Tree): Symbol = if (t.isDef) symbolOf(t) else NoSymbol + val info = Option(symbolOf(tree).info).getOrElse(NoType) + val referencedSymbols: List[Symbol] = { + val directRef = tree match { + case _: RefTree => symbolOf(tree).toOption + case _ => None + } + def referencedSyms(tp: Type) = (tp collect { + case TypeRef(_, sym, _) => sym + }).toList + val indirectRefs = referencedSyms(info) + (indirectRefs ++ directRef).distinct + } + for { + sym <- referencedSymbols + if (sym.isTypeParameter || sym.isLocal) && !(tree.symbol hasTransOwner sym.owner) + } errorFn(s"The symbol, tpe or info of tree `(${tree}) : ${info}` refers to a out-of-scope symbol, ${sym.fullLocationString}. tree.symbol.ownerChain: ${tree.symbol.ownerChain.mkString(", ")}") + } + + private def checkReturnReferencesDirectlyEnclosingDef(tree: Tree) { + tree match { + case _: Return => + path.collectFirst { + case dd: DefDef => dd + } match { + case None => errorFn(s"Return node ($tree) must be enclosed in a DefDef") + case Some(dd) => + if (tree.symbol != dd.symbol) errorFn(s"Return symbol (${tree.symbol}} does not reference directly enclosing DefDef (${dd.symbol})") + } + case _ => + } + } } object postcheck extends Traverser { diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 553583e6b7..a68a084d8f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1452,7 +1452,7 @@ trait Typers extends Modes with Adaptations with Tags { case DefDef(_, name, _, _, _, rhs) => if (stat.symbol.isAuxiliaryConstructor) notAllowed("secondary constructor") - else if (isValueClass && (name == nme.equals_ || name == nme.hashCode_)) + else if (isValueClass && (name == nme.equals_ || name == nme.hashCode_) && !stat.symbol.isSynthetic) notAllowed(s"redefinition of $name method. See SIP-15, criterion 4.") else if (stat.symbol != null && stat.symbol.isParamAccessor) notAllowed("additional parameter") @@ -1903,7 +1903,7 @@ trait Typers extends Modes with Adaptations with Tags { }) } val impl2 = finishMethodSynthesis(impl1, clazz, context) - + // SI-5954. On second compile of a companion class contained in a package object we end up // with some confusion of names which leads to having two symbols with the same name in the // same owner. Until that can be straightened out we can't allow companion objects in package @@ -1916,20 +1916,20 @@ trait Typers extends Modes with Adaptations with Tags { // can't handle case classes in package objects if (m.isCaseClass) pkgObjectRestriction(m, mdef, "case") // can't handle companion class/object pairs in package objects - else if ((m.isClass && m.companionModule != NoSymbol && !m.companionModule.isSynthetic) || - (m.isModule && m.companionClass != NoSymbol && !m.companionClass.isSynthetic)) + else if ((m.isClass && m.companionModule != NoSymbol && !m.companionModule.isSynthetic) || + (m.isModule && m.companionClass != NoSymbol && !m.companionClass.isSynthetic)) pkgObjectRestriction(m, mdef, "companion") } def pkgObjectRestriction(m : Symbol, mdef : ModuleDef, restricted : String) = { val pkgName = mdef.symbol.ownerChain find (_.isPackage) map (_.decodedName) getOrElse mdef.symbol.toString context.error(if (m.pos.isDefined) m.pos else mdef.pos, s"implementation restriction: package object ${pkgName} cannot contain ${restricted} ${m}. Instead, ${m} should be placed directly in package ${pkgName}.") - } + } } if (!settings.companionsInPkgObjs.value && mdef.symbol.isPackageObject) restrictPackageObjectMembers(mdef) - + treeCopy.ModuleDef(mdef, typedMods, mdef.name, impl2) setType NoType } /** In order to override this in the TreeCheckers Typer so synthetics aren't re-added @@ -2067,12 +2067,9 @@ trait Typers extends Modes with Adaptations with Tags { var tpt1 = checkNoEscaping.privates(sym, typer1.typedType(vdef.tpt)) checkNonCyclic(vdef, tpt1) - if (sym.hasAnnotation(definitions.VolatileAttr)) { - if (!sym.isMutable) - VolatileValueError(vdef) - else if (sym.isFinal) - FinalVolatileVarError(vdef) - } + if (sym.hasAnnotation(definitions.VolatileAttr) && !sym.isMutable) + VolatileValueError(vdef) + val rhs1 = if (vdef.rhs.isEmpty) { if (sym.isVariable && sym.owner.isTerm && !sym.isLazy && !isPastTyper) @@ -2213,37 +2210,58 @@ trait Typers extends Modes with Adaptations with Tags { */ def checkMethodStructuralCompatible(ddef: DefDef): Unit = { val meth = ddef.symbol - def fail(pos: Position, msg: String) = unit.error(pos, msg) - val tp: Type = meth.tpe match { - case mt @ MethodType(_, _) => mt - case NullaryMethodType(restpe) => restpe // TODO_NMT: drop NullaryMethodType from resultType? - case PolyType(_, restpe) => restpe - case _ => NoType - } - def nthParamPos(n: Int) = ddef.vparamss match { - case xs :: _ if xs.length > n => xs(n).pos - case _ => meth.pos - } - def failStruct(pos: Position, what: String, where: String = "Parameter") = - fail(pos, s"$where type in structural refinement may not refer to $what") - - foreachWithIndex(tp.paramTypes) { (paramType, idx) => - val sym = paramType.typeSymbol - def paramPos = nthParamPos(idx) - - if (sym.isAbstractType) { - if (!sym.hasTransOwner(meth.owner)) - failStruct(paramPos, "an abstract type defined outside that refinement") - else if (!sym.hasTransOwner(meth)) - failStruct(paramPos, "a type member of that refinement") + def parentString = meth.owner.parentSymbols filterNot (_ == ObjectClass) match { + case Nil => "" + case xs => xs.map(_.nameString).mkString(" (of ", " with ", ")") + } + def fail(pos: Position, msg: String): Boolean = { + unit.error(pos, msg) + false + } + /** Have to examine all parameters in all lists. + */ + def paramssTypes(tp: Type): List[List[Type]] = tp match { + case mt @ MethodType(_, restpe) => mt.paramTypes :: paramssTypes(restpe) + case PolyType(_, restpe) => paramssTypes(restpe) + case _ => Nil + } + def resultType = meth.tpe.finalResultType + def nthParamPos(n1: Int, n2: Int) = + try ddef.vparamss(n1)(n2).pos catch { case _: IndexOutOfBoundsException => meth.pos } + + def failStruct(pos: Position, what: String, where: String = "Parameter type") = + fail(pos, s"$where in structural refinement may not refer to $what") + + foreachWithIndex(paramssTypes(meth.tpe)) { (paramList, listIdx) => + foreachWithIndex(paramList) { (paramType, paramIdx) => + val sym = paramType.typeSymbol + def paramPos = nthParamPos(listIdx, paramIdx) + + /** Not enough to look for abstract types; have to recursively check the bounds + * of each abstract type for more abstract types. Almost certainly there are other + * exploitable type soundness bugs which can be seen by bounding a type parameter + * by an abstract type which itself is bounded by an abstract type. + */ + def checkAbstract(tp0: Type, what: String): Boolean = { + def check(sym: Symbol): Boolean = !sym.isAbstractType || { + log(s"""checking $tp0 in refinement$parentString at ${meth.owner.owner.fullLocationString}""") + ( (!sym.hasTransOwner(meth.owner) && failStruct(paramPos, "an abstract type defined outside that refinement", what)) + || (!sym.hasTransOwner(meth) && failStruct(paramPos, "a type member of that refinement", what)) + || checkAbstract(sym.info.bounds.hi, "Type bound") + ) + } + tp0.dealiasWidenChain forall (t => check(t.typeSymbol)) + } + checkAbstract(paramType, "Parameter type") + + if (sym.isDerivedValueClass) + failStruct(paramPos, "a user-defined value class") + if (paramType.isInstanceOf[ThisType] && sym == meth.owner) + failStruct(paramPos, "the type of that refinement (self type)") } - if (sym.isDerivedValueClass) - failStruct(paramPos, "a user-defined value class") - if (paramType.isInstanceOf[ThisType] && sym == meth.owner) - failStruct(paramPos, "the type of that refinement (self type)") } - if (tp.resultType.typeSymbol.isDerivedValueClass) - failStruct(ddef.tpt.pos, "a user-defined value class", where = "Result") + if (resultType.typeSymbol.isDerivedValueClass) + failStruct(ddef.tpt.pos, "a user-defined value class", where = "Result type") } def typedUseCase(useCase: UseCase) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Variances.scala b/src/compiler/scala/tools/nsc/typechecker/Variances.scala index 7d97b0c782..ea436a71fb 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Variances.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Variances.scala @@ -67,6 +67,8 @@ trait Variances { def varianceInType(tp: Type)(tparam: Symbol): Int = tp match { case ErrorType | WildcardType | NoType | NoPrefix | ThisType(_) | ConstantType(_) => VARIANCES + case BoundedWildcardType(bounds) => + varianceInType(bounds)(tparam) case SingleType(pre, sym) => varianceInType(pre)(tparam) case TypeRef(pre, sym, args) => diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 1c461973e4..5bb4ef5f21 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -841,9 +841,16 @@ self => * // produces: "1, 2, 3, 4, 5, 6" * }}} */ - override def distinct: Stream[A] = - if (isEmpty) this - else cons(head, tail.filter(head != _).distinct) + override def distinct: Stream[A] = { + // This should use max memory proportional to N, whereas + // recursively calling distinct on the tail is N^2. + def loop(seen: Set[A], rest: Stream[A]): Stream[A] = { + if (rest.isEmpty) rest + else if (seen(rest.head)) loop(seen, rest.tail) + else cons(rest.head, loop(seen + rest.head, rest.tail)) + } + loop(Set(), this) + } /** Returns a new sequence of given length containing the elements of this * sequence followed by zero or more occurrences of given elements. diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala index 212ee917c5..7f05deffc8 100644 --- a/src/library/scala/collection/mutable/ListMap.scala +++ b/src/library/scala/collection/mutable/ListMap.scala @@ -12,6 +12,7 @@ package scala.collection package mutable import generic._ +import annotation.tailrec /** A simple mutable map backed by a list. * @@ -47,13 +48,17 @@ extends AbstractMap[A, B] def get(key: A): Option[B] = elems find (_._1 == key) map (_._2) def iterator: Iterator[(A, B)] = elems.iterator - def += (kv: (A, B)) = { elems = remove(kv._1, elems); elems = kv :: elems; siz += 1; this } - def -= (key: A) = { elems = remove(key, elems); this } - private def remove(key: A, elems: List[(A, B)]): List[(A, B)] = - if (elems.isEmpty) elems - else if (elems.head._1 == key) { siz -= 1; elems.tail } - else elems.head :: remove(key, elems.tail) + def += (kv: (A, B)) = { elems = remove(kv._1, elems, List()); elems = kv :: elems; siz += 1; this } + def -= (key: A) = { elems = remove(key, elems, List()); this } + + @tailrec + private def remove(key: A, elems: List[(A, B)], acc: List[(A, B)]): List[(A, B)] = { + if (elems.isEmpty) acc + else if (elems.head._1 == key) { siz -= 1; acc ::: elems.tail } + else remove(key, elems.tail, elems.head :: acc) + } + override def clear() = { elems = List(); siz = 0 } override def size: Int = siz diff --git a/src/partest/scala/tools/partest/BytecodeTest.scala b/src/partest/scala/tools/partest/BytecodeTest.scala new file mode 100644 index 0000000000..93183c2095 --- /dev/null +++ b/src/partest/scala/tools/partest/BytecodeTest.scala @@ -0,0 +1,61 @@ +package scala.tools.partest + +import scala.tools.nsc.util.JavaClassPath +import scala.collection.JavaConverters._ +import scala.tools.asm +import asm.ClassReader +import asm.tree.{ClassNode, MethodNode, InsnList} +import java.io.InputStream + +/** + * Providies utilities for inspecting bytecode using ASM library. + * + * HOW TO USE + * 1. Create subdirectory in test/files/jvm for your test. Let's name it $TESTDIR. + * 2. Create $TESTDIR/BytecodeSrc_1.scala that contains Scala source file which you + * want to inspect the bytecode for. The '_1' suffix signals to partest that it + * should compile this file first. + * 3. Create $TESTDIR/Test.scala: + * import scala.tools.partest.BytecodeTest + * object Test extends BytecodeTest { + * def show { + * // your code that inspect ASM trees and prints values + * } + * } + * 4. Create corresponding check file. + * + * EXAMPLE + * See test/files/jvm/bytecode-test-example for an example of bytecode test. + * + */ +abstract class BytecodeTest { + + /** produce the output to be compared against a checkfile */ + protected def show(): Unit + + def main(args: Array[String]): Unit = show + + protected def getMethod(classNode: ClassNode, name: String): MethodNode = + classNode.methods.asScala.find(_.name == name) getOrElse + sys.error(s"Didn't find method '$name' in class '${classNode.name}'") + + protected def loadClassNode(name: String): ClassNode = { + val classBytes: InputStream = (for { + classRep <- classpath.findClass(name) + binary <- classRep.binary + } yield binary.input) getOrElse sys.error(s"failed to load class '$name'; classpath = $classpath") + + val cr = new ClassReader(classBytes) + val cn = new ClassNode() + cr.accept(cn, 0) + cn + } + + protected lazy val classpath: JavaClassPath = { + import scala.tools.nsc.util.ClassPath.DefaultJavaContext + import scala.tools.util.PathResolver.Defaults + // logic inspired by scala.tools.util.PathResolver implementation + val containers = DefaultJavaContext.classesInExpandedPath(Defaults.javaUserClassPath) + new JavaClassPath(containers, DefaultJavaContext) + } +} diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index a4287fb181..1dec11548f 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -1583,8 +1583,21 @@ trait Symbols extends api.Symbols { self: SymbolTable => setAnnotations(annot :: annotations) // Convenience for the overwhelmingly common case - def addAnnotation(sym: Symbol, args: Tree*): this.type = + def addAnnotation(sym: Symbol, args: Tree*): this.type = { + // The assertion below is meant to prevent from issues like SI-7009 but it's disabled + // due to problems with cycles while compiling Scala library. It's rather shocking that + // just checking if sym is monomorphic type introduces nasty cycles. We are definitively + // forcing too much because monomorphism is a local property of a type that can be checked + // syntactically + // assert(sym.initialize.isMonomorphicType, sym) addAnnotation(AnnotationInfo(sym.tpe, args.toList, Nil)) + } + + /** Use that variant if you want to pass (for example) an applied type */ + def addAnnotation(tp: Type, args: Tree*): this.type = { + assert(tp.typeParams.isEmpty, tp) + addAnnotation(AnnotationInfo(tp, args.toList, Nil)) + } // ------ comparisons ---------------------------------------------------------------- @@ -1651,6 +1664,8 @@ trait Symbols extends api.Symbols { self: SymbolTable => @inline final def map(f: Symbol => Symbol): Symbol = if (this eq NoSymbol) this else f(this) + final def toOption: Option[Symbol] = if (exists) Some(this) else None + // ------ cloneing ------------------------------------------------------------------- /** A clone of this symbol. */ @@ -1728,8 +1743,27 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** For a case class, the symbols of the accessor methods, one for each * argument in the first parameter list of the primary constructor. * The empty list for all other classes. - */ - final def caseFieldAccessors: List[Symbol] = + * + * This list will be sorted to correspond to the declaration order + * in the constructor parameter + */ + final def caseFieldAccessors: List[Symbol] = { + // We can't rely on the ordering of the case field accessors within decls -- + // handling of non-public parameters seems to change the order (see SI-7035.) + // + // Luckily, the constrParamAccessors are still sorted properly, so sort the field-accessors using them + // (need to undo name-mangling, including the sneaky trailing whitespace) + // + // The slightly more principled approach of using the paramss of the + // primary constructor leads to cycles in, for example, pos/t5084.scala. + val primaryNames = constrParamAccessors.map(acc => nme.dropLocalSuffix(acc.name)) + caseFieldAccessorsUnsorted.sortBy { acc => + primaryNames indexWhere { orig => + (acc.name == orig) || (acc.name startsWith (orig append "$")) + } + } + } + private final def caseFieldAccessorsUnsorted: List[Symbol] = (info.decls filter (_.isCaseAccessorMethod)).toList final def constrParamAccessors: List[Symbol] = diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala index ebf0998573..c1753fc5a1 100644 --- a/src/reflect/scala/reflect/internal/TreeGen.scala +++ b/src/reflect/scala/reflect/internal/TreeGen.scala @@ -172,10 +172,29 @@ abstract class TreeGen extends macros.TreeBuilder { if (qual.symbol != null && (qual.symbol.isEffectiveRoot || qual.symbol.isEmptyPackage)) mkAttributedIdent(sym) else { + // Have to recognize anytime a selection is made on a package + // so it can be rewritten to foo.bar.`package`.name rather than + // foo.bar.name if name is in the package object. + // TODO - factor out the common logic between this and + // the Typers method "isInPackageObject", used in typedIdent. + val qualsym = ( + if (qual.tpe ne null) qual.tpe.typeSymbol + else if (qual.symbol ne null) qual.symbol + else NoSymbol + ) + val needsPackageQualifier = ( + (sym ne null) + && qualsym.isPackage + && !sym.isDefinedInPackage + ) val pkgQualifier = - if (sym != null && sym.owner.isPackageObjectClass && sym.effectiveOwner == qual.tpe.typeSymbol) { - val obj = sym.owner.sourceModule - Select(qual, nme.PACKAGE) setSymbol obj setType singleType(qual.tpe, obj) + if (needsPackageQualifier) { + // The owner of a symbol which requires package qualification may be the + // package object iself, but it also could be any superclass of the package + // object. In the latter case, we must go through the qualifier's info + // to obtain the right symbol. + val packageObject = if (sym.owner.isModuleClass) sym.owner.sourceModule else qual.tpe member nme.PACKAGE + Select(qual, nme.PACKAGE) setSymbol packageObject setType singleType(qual.tpe, packageObject) } else qual diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index e1a18570b2..98c1afb323 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -261,22 +261,24 @@ abstract class TreeInfo { * in the position `for { <tree> <- expr }` based only * on information at the `parser` phase? To qualify, there * may be no subtree that will be interpreted as a - * Stable Identifier Pattern. + * Stable Identifier Pattern, nor any type tests, even + * on TupleN. See SI-6968. * * For instance: * * {{{ - * foo @ (bar, (baz, quux)) + * (foo @ (bar @ _)) = 0 * }}} * - * is a variable pattern; if the structure matches, - * then the remainder is inevitable. + * is a not a variable pattern; if only binds names. * * The following are not variable patterns. * * {{{ - * foo @ (bar, (`baz`, quux)) // back quoted ident, not at top level - * foo @ (bar, Quux) // UpperCase ident, not at top level + * `bar` + * Bar + * (a, b) + * _: T * }}} * * If the pattern is a simple identifier, it is always @@ -305,10 +307,6 @@ abstract class TreeInfo { tree match { case Bind(name, pat) => isVarPatternDeep0(pat) case Ident(name) => isVarPattern(tree) - case Apply(sel, args) => - ( isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName) - && (args forall isVarPatternDeep0) - ) case _ => false } } diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala index 431afd286d..a528a9ced8 100644 --- a/src/reflect/scala/reflect/internal/Trees.scala +++ b/src/reflect/scala/reflect/internal/Trees.scala @@ -1440,6 +1440,22 @@ trait Trees extends api.Trees { self: SymbolTable => if (tree.hasSymbol) { subst(from, to) tree match { + case _: DefTree => + val newInfo = symSubst(tree.symbol.info) + if (!(newInfo =:= tree.symbol.info)) { + debuglog(sm""" + |TreeSymSubstituter: updated info of symbol ${tree.symbol} + | Old: ${showRaw(tree.symbol.info, printTypes = true, printIds = true)} + | New: ${showRaw(newInfo, printTypes = true, printIds = true)}""") + tree.symbol updateInfo newInfo + } + case _ => + // no special handling is required for Function or Import nodes here. + // as they don't have interesting infos attached to their symbols. + // Subsitution of the referenced symbol of Return nodes is handled + // in .ChangeOwnerTraverser + } + tree match { case Ident(name0) if tree.symbol != NoSymbol => treeCopy.Ident(tree, tree.symbol.name) case Select(qual, name0) if tree.symbol != NoSymbol => @@ -1488,6 +1504,15 @@ trait Trees extends api.Trees { self: SymbolTable => } } + trait TreeStackTraverser extends Traverser { + import collection.mutable + val path: mutable.Stack[Tree] = mutable.Stack() + abstract override def traverse(t: Tree) = { + path push t + try super.traverse(t) finally path.pop() + } + } + private lazy val duplicator = new Transformer { override val treeCopy = newStrictTreeCopier override def transform(t: Tree) = { diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index dbc00edb1a..3136b227db 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -22,6 +22,8 @@ import util.ThreeValues._ // internal: error case WildcardType => // internal: unknown + case BoundedWildcardType(bounds) => + // internal: unknown case NoType => case NoPrefix => case ThisType(sym) => @@ -744,7 +746,7 @@ trait Types extends api.Types { self: SymbolTable => val trivial = ( this.isTrivial || phase.erasedTypes && pre.typeSymbol != ArrayClass - || pre.normalize.isTrivial && !isPossiblePrefix(clazz) + || skipPrefixOf(pre, clazz) ) if (trivial) this else { @@ -3590,12 +3592,6 @@ trait Types extends api.Types { self: SymbolTable => val pre1 = pre match { case x: SuperType if sym1.isEffectivelyFinal || sym1.isDeferred => x.thistpe - case _: CompoundType if sym1.isClass => - // sharpen prefix so that it is maximal and still contains the class. - pre.parents.reverse dropWhile (_.member(sym1.name) != sym1) match { - case Nil => pre - case parent :: _ => parent - } case _ => pre } if (pre eq pre1) TypeRef(pre, sym1, args) @@ -3852,12 +3848,16 @@ trait Types extends api.Types { self: SymbolTable => // This is the specified behavior. protected def etaExpandKeepsStar = false + /** Turn any T* types into Seq[T] except when + * in method parameter position. + */ object dropRepeatedParamType extends TypeMap { def apply(tp: Type): Type = tp match { case MethodType(params, restpe) => - MethodType(params, apply(restpe)) - case PolyType(tparams, restpe) => - PolyType(tparams, apply(restpe)) + // Not mapping over params + val restpe1 = apply(restpe) + if (restpe eq restpe1) tp + else MethodType(params, restpe1) case TypeRef(_, RepeatedParamClass, arg :: Nil) => seqType(arg) case _ => @@ -4469,14 +4469,15 @@ trait Types extends api.Types { self: SymbolTable => */ def isPossiblePrefix(clazz: Symbol) = clazz.isClass && !clazz.isPackageClass + private def skipPrefixOf(pre: Type, clazz: Symbol) = ( + (pre eq NoType) || (pre eq NoPrefix) || !isPossiblePrefix(clazz) + ) + /** A map to compute the asSeenFrom method */ class AsSeenFromMap(pre: Type, clazz: Symbol) extends TypeMap with KeepOnlyTypeConstraints { var capturedSkolems: List[Symbol] = List() var capturedParams: List[Symbol] = List() - private def skipPrefixOf(pre: Type, clazz: Symbol) = ( - (pre eq NoType) || (pre eq NoPrefix) || !isPossiblePrefix(clazz) - ) override def mapOver(tree: Tree, giveup: ()=>Nothing): Tree = { object annotationArgRewriter extends TypeMapTransformer { private def canRewriteThis(sym: Symbol) = ( @@ -4509,8 +4510,7 @@ trait Types extends api.Types { self: SymbolTable => } def apply(tp: Type): Type = - if (skipPrefixOf(pre, clazz)) tp - else tp match { + tp match { case ThisType(sym) => def toPrefix(pre: Type, clazz: Symbol): Type = if (skipPrefixOf(pre, clazz)) tp @@ -4672,6 +4672,8 @@ trait Types extends api.Types { self: SymbolTable => /** A map to implement the `substSym` method. */ class SubstSymMap(from: List[Symbol], to: List[Symbol]) extends SubstMap(from, to) { + def this(pairs: (Symbol, Symbol)*) = this(pairs.toList.map(_._1), pairs.toList.map(_._2)) + protected def toType(fromtp: Type, sym: Symbol) = fromtp match { case TypeRef(pre, _, args) => copyTypeRef(fromtp, pre, sym, args) case SingleType(pre, _) => singleType(pre, sym) @@ -7112,6 +7114,14 @@ trait Types extends api.Types { self: SymbolTable => } } + def isJavaVarargsAncestor(clazz: Symbol) = ( + clazz.isClass + && clazz.isJavaDefined + && (clazz.info.nonPrivateDecls exists isJavaVarArgsMethod) + ) + def inheritsJavaVarArgsMethod(clazz: Symbol) = + clazz.thisType.baseClasses exists isJavaVarargsAncestor + /** All types in list must be polytypes with type parameter lists of * same length as tparams. * Returns list of list of bounds infos, where corresponding type @@ -7224,6 +7234,12 @@ trait Types extends api.Types { self: SymbolTable => else (ps :+ SerializableClass.tpe).toList ) + /** Members of the given class, other than those inherited + * from Any or AnyRef. + */ + def nonTrivialMembers(clazz: Symbol): Iterable[Symbol] = + clazz.info.members filterNot (sym => sym.owner == ObjectClass || sym.owner == AnyClass) + def objToAny(tp: Type): Type = if (!phase.erasedTypes && tp.typeSymbol == ObjectClass) AnyClass.tpe else tp diff --git a/src/reflect/scala/reflect/internal/util/Position.scala b/src/reflect/scala/reflect/internal/util/Position.scala index 3d10d4c9ce..8f287a1640 100644 --- a/src/reflect/scala/reflect/internal/util/Position.scala +++ b/src/reflect/scala/reflect/internal/util/Position.scala @@ -91,7 +91,7 @@ abstract class Position extends scala.reflect.api.Position { self => /** An optional value containing the source file referred to by this position, or * None if not defined. */ - def source: SourceFile = throw new UnsupportedOperationException("Position.source") + def source: SourceFile = throw new UnsupportedOperationException(s"Position.source on ${this.getClass}") /** Is this position neither a NoPosition nor a FakePosition? * If isDefined is true, offset and source are both defined. @@ -111,19 +111,19 @@ abstract class Position extends scala.reflect.api.Position { self => def makeTransparent: Position = this /** The start of the position's range, error if not a range position */ - def start: Int = throw new UnsupportedOperationException("Position.start") + def start: Int = throw new UnsupportedOperationException(s"Position.start on ${this.getClass}") /** The start of the position's range, or point if not a range position */ def startOrPoint: Int = point /** The point (where the ^ is) of the position */ - def point: Int = throw new UnsupportedOperationException("Position.point") + def point: Int = throw new UnsupportedOperationException(s"Position.point on ${this.getClass}") /** The point (where the ^ is) of the position, or else `default` if undefined */ def pointOrElse(default: Int): Int = default /** The end of the position's range, error if not a range position */ - def end: Int = throw new UnsupportedOperationException("Position.end") + def end: Int = throw new UnsupportedOperationException(s"Position.end on ${this.getClass}") /** The end of the position's range, or point if not a range position */ def endOrPoint: Int = point diff --git a/src/scalap/scala/tools/scalap/Main.scala b/src/scalap/scala/tools/scalap/Main.scala index 7c84279699..90f8cb8d71 100644 --- a/src/scalap/scala/tools/scalap/Main.scala +++ b/src/scalap/scala/tools/scalap/Main.scala @@ -184,7 +184,7 @@ object Main extends Main { val cparg = List("-classpath", "-cp") map (arguments getArgument _) reduceLeft (_ orElse _) val path = cparg match { case Some(cp) => new JavaClassPath(DefaultJavaContext.classesInExpandedPath(cp), DefaultJavaContext) - case _ => PathResolver.fromPathString("") + case _ => PathResolver.fromPathString(".") // include '.' in the default classpath SI-6669 } // print the classpath if output is verbose if (verbose) diff --git a/test/benchmarking/t6726-patmat-analysis.scala b/test/benchmarking/t6726-patmat-analysis.scala new file mode 100644 index 0000000000..bcb7f6c6b2 --- /dev/null +++ b/test/benchmarking/t6726-patmat-analysis.scala @@ -0,0 +1,4005 @@ +trait Foo{ +abstract class Base +case class Dummy0(x: Int) extends Base +case class Dummy1(x: Int) extends Base +case class Dummy2(x: Int) extends Base +case class Dummy3(x: Int) extends Base +case class Dummy4(x: Int) extends Base +case class Dummy5(x: Int) extends Base +case class Dummy6(x: Int) extends Base +case class Dummy7(x: Int) extends Base +case class Dummy8(x: Int) extends Base +case class Dummy9(x: Int) extends Base +case class Dummy10(x: Int) extends Base +case class Dummy11(x: Int) extends Base +case class Dummy12(x: Int) extends Base +case class Dummy13(x: Int) extends Base +case class Dummy14(x: Int) extends Base +case class Dummy15(x: Int) extends Base +case class Dummy16(x: Int) extends Base +case class Dummy17(x: Int) extends Base +case class Dummy18(x: Int) extends Base +case class Dummy19(x: Int) extends Base +case class Dummy20(x: Int) extends Base +case class Dummy21(x: Int) extends Base +case class Dummy22(x: Int) extends Base +case class Dummy23(x: Int) extends Base +case class Dummy24(x: Int) extends Base +case class Dummy25(x: Int) extends Base +case class Dummy26(x: Int) extends Base +case class Dummy27(x: Int) extends Base +case class Dummy28(x: Int) extends Base +case class Dummy29(x: Int) extends Base +case class Dummy30(x: Int) extends Base +case class Dummy31(x: Int) extends Base +case class Dummy32(x: Int) extends Base +case class Dummy33(x: Int) extends Base +case class Dummy34(x: Int) extends Base +case class Dummy35(x: Int) extends Base +case class Dummy36(x: Int) extends Base +case class Dummy37(x: Int) extends Base +case class Dummy38(x: Int) extends Base +case class Dummy39(x: Int) extends Base +case class Dummy40(x: Int) extends Base +case class Dummy41(x: Int) extends Base +case class Dummy42(x: Int) extends Base +case class Dummy43(x: Int) extends Base +case class Dummy44(x: Int) extends Base +case class Dummy45(x: Int) extends Base +case class Dummy46(x: Int) extends Base +case class Dummy47(x: Int) extends Base +case class Dummy48(x: Int) extends Base +case class Dummy49(x: Int) extends Base +case class Dummy50(x: Int) extends Base +case class Dummy51(x: Int) extends Base +case class Dummy52(x: Int) extends Base +case class Dummy53(x: Int) extends Base +case class Dummy54(x: Int) extends Base +case class Dummy55(x: Int) extends Base +case class Dummy56(x: Int) extends Base +case class Dummy57(x: Int) extends Base +case class Dummy58(x: Int) extends Base +case class Dummy59(x: Int) extends Base +case class Dummy60(x: Int) extends Base +case class Dummy61(x: Int) extends Base +case class Dummy62(x: Int) extends Base +case class Dummy63(x: Int) extends Base +case class Dummy64(x: Int) extends Base +case class Dummy65(x: Int) extends Base +case class Dummy66(x: Int) extends Base +case class Dummy67(x: Int) extends Base +case class Dummy68(x: Int) extends Base +case class Dummy69(x: Int) extends Base +case class Dummy70(x: Int) extends Base +case class Dummy71(x: Int) extends Base +case class Dummy72(x: Int) extends Base +case class Dummy73(x: Int) extends Base +case class Dummy74(x: Int) extends Base +case class Dummy75(x: Int) extends Base +case class Dummy76(x: Int) extends Base +case class Dummy77(x: Int) extends Base +case class Dummy78(x: Int) extends Base +case class Dummy79(x: Int) extends Base +case class Dummy80(x: Int) extends Base +case class Dummy81(x: Int) extends Base +case class Dummy82(x: Int) extends Base +case class Dummy83(x: Int) extends Base +case class Dummy84(x: Int) extends Base +case class Dummy85(x: Int) extends Base +case class Dummy86(x: Int) extends Base +case class Dummy87(x: Int) extends Base +case class Dummy88(x: Int) extends Base +case class Dummy89(x: Int) extends Base +case class Dummy90(x: Int) extends Base +case class Dummy91(x: Int) extends Base +case class Dummy92(x: Int) extends Base +case class Dummy93(x: Int) extends Base +case class Dummy94(x: Int) extends Base +case class Dummy95(x: Int) extends Base +case class Dummy96(x: Int) extends Base +case class Dummy97(x: Int) extends Base +case class Dummy98(x: Int) extends Base +case class Dummy99(x: Int) extends Base +case class Dummy100(x: Int) extends Base +case class Dummy101(x: Int) extends Base +case class Dummy102(x: Int) extends Base +case class Dummy103(x: Int) extends Base +case class Dummy104(x: Int) extends Base +case class Dummy105(x: Int) extends Base +case class Dummy106(x: Int) extends Base +case class Dummy107(x: Int) extends Base +case class Dummy108(x: Int) extends Base +case class Dummy109(x: Int) extends Base +case class Dummy110(x: Int) extends Base +case class Dummy111(x: Int) extends Base +case class Dummy112(x: Int) extends Base +case class Dummy113(x: Int) extends Base +case class Dummy114(x: Int) extends Base +case class Dummy115(x: Int) extends Base +case class Dummy116(x: Int) extends Base +case class Dummy117(x: Int) extends Base +case class Dummy118(x: Int) extends Base +case class Dummy119(x: Int) extends Base +case class Dummy120(x: Int) extends Base +case class Dummy121(x: Int) extends Base +case class Dummy122(x: Int) extends Base +case class Dummy123(x: Int) extends Base +case class Dummy124(x: Int) extends Base +case class Dummy125(x: Int) extends Base +case class Dummy126(x: Int) extends Base +case class Dummy127(x: Int) extends Base +case class Dummy128(x: Int) extends Base +case class Dummy129(x: Int) extends Base +case class Dummy130(x: Int) extends Base +case class Dummy131(x: Int) extends Base +case class Dummy132(x: Int) extends Base +case class Dummy133(x: Int) extends Base +case class Dummy134(x: Int) extends Base +case class Dummy135(x: Int) extends Base +case class Dummy136(x: Int) extends Base +case class Dummy137(x: Int) extends Base +case class Dummy138(x: Int) extends Base +case class Dummy139(x: Int) extends Base +case class Dummy140(x: Int) extends Base +case class Dummy141(x: Int) extends Base +case class Dummy142(x: Int) extends Base +case class Dummy143(x: Int) extends Base +case class Dummy144(x: Int) extends Base +case class Dummy145(x: Int) extends Base +case class Dummy146(x: Int) extends Base +case class Dummy147(x: Int) extends Base +case class Dummy148(x: Int) extends Base +case class Dummy149(x: Int) extends Base +case class Dummy150(x: Int) extends Base +case class Dummy151(x: Int) extends Base +case class Dummy152(x: Int) extends Base +case class Dummy153(x: Int) extends Base +case class Dummy154(x: Int) extends Base +case class Dummy155(x: Int) extends Base +case class Dummy156(x: Int) extends Base +case class Dummy157(x: Int) extends Base +case class Dummy158(x: Int) extends Base +case class Dummy159(x: Int) extends Base +case class Dummy160(x: Int) extends Base +case class Dummy161(x: Int) extends Base +case class Dummy162(x: Int) extends Base +case class Dummy163(x: Int) extends Base +case class Dummy164(x: Int) extends Base +case class Dummy165(x: Int) extends Base +case class Dummy166(x: Int) extends Base +case class Dummy167(x: Int) extends Base +case class Dummy168(x: Int) extends Base +case class Dummy169(x: Int) extends Base +case class Dummy170(x: Int) extends Base +case class Dummy171(x: Int) extends Base +case class Dummy172(x: Int) extends Base +case class Dummy173(x: Int) extends Base +case class Dummy174(x: Int) extends Base +case class Dummy175(x: Int) extends Base +case class Dummy176(x: Int) extends Base +case class Dummy177(x: Int) extends Base +case class Dummy178(x: Int) extends Base +case class Dummy179(x: Int) extends Base +case class Dummy180(x: Int) extends Base +case class Dummy181(x: Int) extends Base +case class Dummy182(x: Int) extends Base +case class Dummy183(x: Int) extends Base +case class Dummy184(x: Int) extends Base +case class Dummy185(x: Int) extends Base +case class Dummy186(x: Int) extends Base +case class Dummy187(x: Int) extends Base +case class Dummy188(x: Int) extends Base +case class Dummy189(x: Int) extends Base +case class Dummy190(x: Int) extends Base +case class Dummy191(x: Int) extends Base +case class Dummy192(x: Int) extends Base +case class Dummy193(x: Int) extends Base +case class Dummy194(x: Int) extends Base +case class Dummy195(x: Int) extends Base +case class Dummy196(x: Int) extends Base +case class Dummy197(x: Int) extends Base +case class Dummy198(x: Int) extends Base +case class Dummy199(x: Int) extends Base +case class Dummy200(x: Int) extends Base +case class Dummy201(x: Int) extends Base +case class Dummy202(x: Int) extends Base +case class Dummy203(x: Int) extends Base +case class Dummy204(x: Int) extends Base +case class Dummy205(x: Int) extends Base +case class Dummy206(x: Int) extends Base +case class Dummy207(x: Int) extends Base +case class Dummy208(x: Int) extends Base +case class Dummy209(x: Int) extends Base +case class Dummy210(x: Int) extends Base +case class Dummy211(x: Int) extends Base +case class Dummy212(x: Int) extends Base +case class Dummy213(x: Int) extends Base +case class Dummy214(x: Int) extends Base +case class Dummy215(x: Int) extends Base +case class Dummy216(x: Int) extends Base +case class Dummy217(x: Int) extends Base +case class Dummy218(x: Int) extends Base +case class Dummy219(x: Int) extends Base +case class Dummy220(x: Int) extends Base +case class Dummy221(x: Int) extends Base +case class Dummy222(x: Int) extends Base +case class Dummy223(x: Int) extends Base +case class Dummy224(x: Int) extends Base +case class Dummy225(x: Int) extends Base +case class Dummy226(x: Int) extends Base +case class Dummy227(x: Int) extends Base +case class Dummy228(x: Int) extends Base +case class Dummy229(x: Int) extends Base +case class Dummy230(x: Int) extends Base +case class Dummy231(x: Int) extends Base +case class Dummy232(x: Int) extends Base +case class Dummy233(x: Int) extends Base +case class Dummy234(x: Int) extends Base +case class Dummy235(x: Int) extends Base +case class Dummy236(x: Int) extends Base +case class Dummy237(x: Int) extends Base +case class Dummy238(x: Int) extends Base +case class Dummy239(x: Int) extends Base +case class Dummy240(x: Int) extends Base +case class Dummy241(x: Int) extends Base +case class Dummy242(x: Int) extends Base +case class Dummy243(x: Int) extends Base +case class Dummy244(x: Int) extends Base +case class Dummy245(x: Int) extends Base +case class Dummy246(x: Int) extends Base +case class Dummy247(x: Int) extends Base +case class Dummy248(x: Int) extends Base +case class Dummy249(x: Int) extends Base +case class Dummy250(x: Int) extends Base +case class Dummy251(x: Int) extends Base +case class Dummy252(x: Int) extends Base +case class Dummy253(x: Int) extends Base +case class Dummy254(x: Int) extends Base +case class Dummy255(x: Int) extends Base +case class Dummy256(x: Int) extends Base +case class Dummy257(x: Int) extends Base +case class Dummy258(x: Int) extends Base +case class Dummy259(x: Int) extends Base +case class Dummy260(x: Int) extends Base +case class Dummy261(x: Int) extends Base +case class Dummy262(x: Int) extends Base +case class Dummy263(x: Int) extends Base +case class Dummy264(x: Int) extends Base +case class Dummy265(x: Int) extends Base +case class Dummy266(x: Int) extends Base +case class Dummy267(x: Int) extends Base +case class Dummy268(x: Int) extends Base +case class Dummy269(x: Int) extends Base +case class Dummy270(x: Int) extends Base +case class Dummy271(x: Int) extends Base +case class Dummy272(x: Int) extends Base +case class Dummy273(x: Int) extends Base +case class Dummy274(x: Int) extends Base +case class Dummy275(x: Int) extends Base +case class Dummy276(x: Int) extends Base +case class Dummy277(x: Int) extends Base +case class Dummy278(x: Int) extends Base +case class Dummy279(x: Int) extends Base +case class Dummy280(x: Int) extends Base +case class Dummy281(x: Int) extends Base +case class Dummy282(x: Int) extends Base +case class Dummy283(x: Int) extends Base +case class Dummy284(x: Int) extends Base +case class Dummy285(x: Int) extends Base +case class Dummy286(x: Int) extends Base +case class Dummy287(x: Int) extends Base +case class Dummy288(x: Int) extends Base +case class Dummy289(x: Int) extends Base +case class Dummy290(x: Int) extends Base +case class Dummy291(x: Int) extends Base +case class Dummy292(x: Int) extends Base +case class Dummy293(x: Int) extends Base +case class Dummy294(x: Int) extends Base +case class Dummy295(x: Int) extends Base +case class Dummy296(x: Int) extends Base +case class Dummy297(x: Int) extends Base +case class Dummy298(x: Int) extends Base +case class Dummy299(x: Int) extends Base +case class Dummy300(x: Int) extends Base +case class Dummy301(x: Int) extends Base +case class Dummy302(x: Int) extends Base +case class Dummy303(x: Int) extends Base +case class Dummy304(x: Int) extends Base +case class Dummy305(x: Int) extends Base +case class Dummy306(x: Int) extends Base +case class Dummy307(x: Int) extends Base +case class Dummy308(x: Int) extends Base +case class Dummy309(x: Int) extends Base +case class Dummy310(x: Int) extends Base +case class Dummy311(x: Int) extends Base +case class Dummy312(x: Int) extends Base +case class Dummy313(x: Int) extends Base +case class Dummy314(x: Int) extends Base +case class Dummy315(x: Int) extends Base +case class Dummy316(x: Int) extends Base +case class Dummy317(x: Int) extends Base +case class Dummy318(x: Int) extends Base +case class Dummy319(x: Int) extends Base +case class Dummy320(x: Int) extends Base +case class Dummy321(x: Int) extends Base +case class Dummy322(x: Int) extends Base +case class Dummy323(x: Int) extends Base +case class Dummy324(x: Int) extends Base +case class Dummy325(x: Int) extends Base +case class Dummy326(x: Int) extends Base +case class Dummy327(x: Int) extends Base +case class Dummy328(x: Int) extends Base +case class Dummy329(x: Int) extends Base +case class Dummy330(x: Int) extends Base +case class Dummy331(x: Int) extends Base +case class Dummy332(x: Int) extends Base +case class Dummy333(x: Int) extends Base +case class Dummy334(x: Int) extends Base +case class Dummy335(x: Int) extends Base +case class Dummy336(x: Int) extends Base +case class Dummy337(x: Int) extends Base +case class Dummy338(x: Int) extends Base +case class Dummy339(x: Int) extends Base +case class Dummy340(x: Int) extends Base +case class Dummy341(x: Int) extends Base +case class Dummy342(x: Int) extends Base +case class Dummy343(x: Int) extends Base +case class Dummy344(x: Int) extends Base +case class Dummy345(x: Int) extends Base +case class Dummy346(x: Int) extends Base +case class Dummy347(x: Int) extends Base +case class Dummy348(x: Int) extends Base +case class Dummy349(x: Int) extends Base +case class Dummy350(x: Int) extends Base +case class Dummy351(x: Int) extends Base +case class Dummy352(x: Int) extends Base +case class Dummy353(x: Int) extends Base +case class Dummy354(x: Int) extends Base +case class Dummy355(x: Int) extends Base +case class Dummy356(x: Int) extends Base +case class Dummy357(x: Int) extends Base +case class Dummy358(x: Int) extends Base +case class Dummy359(x: Int) extends Base +case class Dummy360(x: Int) extends Base +case class Dummy361(x: Int) extends Base +case class Dummy362(x: Int) extends Base +case class Dummy363(x: Int) extends Base +case class Dummy364(x: Int) extends Base +case class Dummy365(x: Int) extends Base +case class Dummy366(x: Int) extends Base +case class Dummy367(x: Int) extends Base +case class Dummy368(x: Int) extends Base +case class Dummy369(x: Int) extends Base +case class Dummy370(x: Int) extends Base +case class Dummy371(x: Int) extends Base +case class Dummy372(x: Int) extends Base +case class Dummy373(x: Int) extends Base +case class Dummy374(x: Int) extends Base +case class Dummy375(x: Int) extends Base +case class Dummy376(x: Int) extends Base +case class Dummy377(x: Int) extends Base +case class Dummy378(x: Int) extends Base +case class Dummy379(x: Int) extends Base +case class Dummy380(x: Int) extends Base +case class Dummy381(x: Int) extends Base +case class Dummy382(x: Int) extends Base +case class Dummy383(x: Int) extends Base +case class Dummy384(x: Int) extends Base +case class Dummy385(x: Int) extends Base +case class Dummy386(x: Int) extends Base +case class Dummy387(x: Int) extends Base +case class Dummy388(x: Int) extends Base +case class Dummy389(x: Int) extends Base +case class Dummy390(x: Int) extends Base +case class Dummy391(x: Int) extends Base +case class Dummy392(x: Int) extends Base +case class Dummy393(x: Int) extends Base +case class Dummy394(x: Int) extends Base +case class Dummy395(x: Int) extends Base +case class Dummy396(x: Int) extends Base +case class Dummy397(x: Int) extends Base +case class Dummy398(x: Int) extends Base +case class Dummy399(x: Int) extends Base +case class Dummy400(x: Int) extends Base +case class Dummy401(x: Int) extends Base +case class Dummy402(x: Int) extends Base +case class Dummy403(x: Int) extends Base +case class Dummy404(x: Int) extends Base +case class Dummy405(x: Int) extends Base +case class Dummy406(x: Int) extends Base +case class Dummy407(x: Int) extends Base +case class Dummy408(x: Int) extends Base +case class Dummy409(x: Int) extends Base +case class Dummy410(x: Int) extends Base +case class Dummy411(x: Int) extends Base +case class Dummy412(x: Int) extends Base +case class Dummy413(x: Int) extends Base +case class Dummy414(x: Int) extends Base +case class Dummy415(x: Int) extends Base +case class Dummy416(x: Int) extends Base +case class Dummy417(x: Int) extends Base +case class Dummy418(x: Int) extends Base +case class Dummy419(x: Int) extends Base +case class Dummy420(x: Int) extends Base +case class Dummy421(x: Int) extends Base +case class Dummy422(x: Int) extends Base +case class Dummy423(x: Int) extends Base +case class Dummy424(x: Int) extends Base +case class Dummy425(x: Int) extends Base +case class Dummy426(x: Int) extends Base +case class Dummy427(x: Int) extends Base +case class Dummy428(x: Int) extends Base +case class Dummy429(x: Int) extends Base +case class Dummy430(x: Int) extends Base +case class Dummy431(x: Int) extends Base +case class Dummy432(x: Int) extends Base +case class Dummy433(x: Int) extends Base +case class Dummy434(x: Int) extends Base +case class Dummy435(x: Int) extends Base +case class Dummy436(x: Int) extends Base +case class Dummy437(x: Int) extends Base +case class Dummy438(x: Int) extends Base +case class Dummy439(x: Int) extends Base +case class Dummy440(x: Int) extends Base +case class Dummy441(x: Int) extends Base +case class Dummy442(x: Int) extends Base +case class Dummy443(x: Int) extends Base +case class Dummy444(x: Int) extends Base +case class Dummy445(x: Int) extends Base +case class Dummy446(x: Int) extends Base +case class Dummy447(x: Int) extends Base +case class Dummy448(x: Int) extends Base +case class Dummy449(x: Int) extends Base +case class Dummy450(x: Int) extends Base +case class Dummy451(x: Int) extends Base +case class Dummy452(x: Int) extends Base +case class Dummy453(x: Int) extends Base +case class Dummy454(x: Int) extends Base +case class Dummy455(x: Int) extends Base +case class Dummy456(x: Int) extends Base +case class Dummy457(x: Int) extends Base +case class Dummy458(x: Int) extends Base +case class Dummy459(x: Int) extends Base +case class Dummy460(x: Int) extends Base +case class Dummy461(x: Int) extends Base +case class Dummy462(x: Int) extends Base +case class Dummy463(x: Int) extends Base +case class Dummy464(x: Int) extends Base +case class Dummy465(x: Int) extends Base +case class Dummy466(x: Int) extends Base +case class Dummy467(x: Int) extends Base +case class Dummy468(x: Int) extends Base +case class Dummy469(x: Int) extends Base +case class Dummy470(x: Int) extends Base +case class Dummy471(x: Int) extends Base +case class Dummy472(x: Int) extends Base +case class Dummy473(x: Int) extends Base +case class Dummy474(x: Int) extends Base +case class Dummy475(x: Int) extends Base +case class Dummy476(x: Int) extends Base +case class Dummy477(x: Int) extends Base +case class Dummy478(x: Int) extends Base +case class Dummy479(x: Int) extends Base +case class Dummy480(x: Int) extends Base +case class Dummy481(x: Int) extends Base +case class Dummy482(x: Int) extends Base +case class Dummy483(x: Int) extends Base +case class Dummy484(x: Int) extends Base +case class Dummy485(x: Int) extends Base +case class Dummy486(x: Int) extends Base +case class Dummy487(x: Int) extends Base +case class Dummy488(x: Int) extends Base +case class Dummy489(x: Int) extends Base +case class Dummy490(x: Int) extends Base +case class Dummy491(x: Int) extends Base +case class Dummy492(x: Int) extends Base +case class Dummy493(x: Int) extends Base +case class Dummy494(x: Int) extends Base +case class Dummy495(x: Int) extends Base +case class Dummy496(x: Int) extends Base +case class Dummy497(x: Int) extends Base +case class Dummy498(x: Int) extends Base +case class Dummy499(x: Int) extends Base +case class Dummy500(x: Int) extends Base +case class Dummy501(x: Int) extends Base +case class Dummy502(x: Int) extends Base +case class Dummy503(x: Int) extends Base +case class Dummy504(x: Int) extends Base +case class Dummy505(x: Int) extends Base +case class Dummy506(x: Int) extends Base +case class Dummy507(x: Int) extends Base +case class Dummy508(x: Int) extends Base +case class Dummy509(x: Int) extends Base +case class Dummy510(x: Int) extends Base +case class Dummy511(x: Int) extends Base +case class Dummy512(x: Int) extends Base +case class Dummy513(x: Int) extends Base +case class Dummy514(x: Int) extends Base +case class Dummy515(x: Int) extends Base +case class Dummy516(x: Int) extends Base +case class Dummy517(x: Int) extends Base +case class Dummy518(x: Int) extends Base +case class Dummy519(x: Int) extends Base +case class Dummy520(x: Int) extends Base +case class Dummy521(x: Int) extends Base +case class Dummy522(x: Int) extends Base +case class Dummy523(x: Int) extends Base +case class Dummy524(x: Int) extends Base +case class Dummy525(x: Int) extends Base +case class Dummy526(x: Int) extends Base +case class Dummy527(x: Int) extends Base +case class Dummy528(x: Int) extends Base +case class Dummy529(x: Int) extends Base +case class Dummy530(x: Int) extends Base +case class Dummy531(x: Int) extends Base +case class Dummy532(x: Int) extends Base +case class Dummy533(x: Int) extends Base +case class Dummy534(x: Int) extends Base +case class Dummy535(x: Int) extends Base +case class Dummy536(x: Int) extends Base +case class Dummy537(x: Int) extends Base +case class Dummy538(x: Int) extends Base +case class Dummy539(x: Int) extends Base +case class Dummy540(x: Int) extends Base +case class Dummy541(x: Int) extends Base +case class Dummy542(x: Int) extends Base +case class Dummy543(x: Int) extends Base +case class Dummy544(x: Int) extends Base +case class Dummy545(x: Int) extends Base +case class Dummy546(x: Int) extends Base +case class Dummy547(x: Int) extends Base +case class Dummy548(x: Int) extends Base +case class Dummy549(x: Int) extends Base +case class Dummy550(x: Int) extends Base +case class Dummy551(x: Int) extends Base +case class Dummy552(x: Int) extends Base +case class Dummy553(x: Int) extends Base +case class Dummy554(x: Int) extends Base +case class Dummy555(x: Int) extends Base +case class Dummy556(x: Int) extends Base +case class Dummy557(x: Int) extends Base +case class Dummy558(x: Int) extends Base +case class Dummy559(x: Int) extends Base +case class Dummy560(x: Int) extends Base +case class Dummy561(x: Int) extends Base +case class Dummy562(x: Int) extends Base +case class Dummy563(x: Int) extends Base +case class Dummy564(x: Int) extends Base +case class Dummy565(x: Int) extends Base +case class Dummy566(x: Int) extends Base +case class Dummy567(x: Int) extends Base +case class Dummy568(x: Int) extends Base +case class Dummy569(x: Int) extends Base +case class Dummy570(x: Int) extends Base +case class Dummy571(x: Int) extends Base +case class Dummy572(x: Int) extends Base +case class Dummy573(x: Int) extends Base +case class Dummy574(x: Int) extends Base +case class Dummy575(x: Int) extends Base +case class Dummy576(x: Int) extends Base +case class Dummy577(x: Int) extends Base +case class Dummy578(x: Int) extends Base +case class Dummy579(x: Int) extends Base +case class Dummy580(x: Int) extends Base +case class Dummy581(x: Int) extends Base +case class Dummy582(x: Int) extends Base +case class Dummy583(x: Int) extends Base +case class Dummy584(x: Int) extends Base +case class Dummy585(x: Int) extends Base +case class Dummy586(x: Int) extends Base +case class Dummy587(x: Int) extends Base +case class Dummy588(x: Int) extends Base +case class Dummy589(x: Int) extends Base +case class Dummy590(x: Int) extends Base +case class Dummy591(x: Int) extends Base +case class Dummy592(x: Int) extends Base +case class Dummy593(x: Int) extends Base +case class Dummy594(x: Int) extends Base +case class Dummy595(x: Int) extends Base +case class Dummy596(x: Int) extends Base +case class Dummy597(x: Int) extends Base +case class Dummy598(x: Int) extends Base +case class Dummy599(x: Int) extends Base +case class Dummy600(x: Int) extends Base +case class Dummy601(x: Int) extends Base +case class Dummy602(x: Int) extends Base +case class Dummy603(x: Int) extends Base +case class Dummy604(x: Int) extends Base +case class Dummy605(x: Int) extends Base +case class Dummy606(x: Int) extends Base +case class Dummy607(x: Int) extends Base +case class Dummy608(x: Int) extends Base +case class Dummy609(x: Int) extends Base +case class Dummy610(x: Int) extends Base +case class Dummy611(x: Int) extends Base +case class Dummy612(x: Int) extends Base +case class Dummy613(x: Int) extends Base +case class Dummy614(x: Int) extends Base +case class Dummy615(x: Int) extends Base +case class Dummy616(x: Int) extends Base +case class Dummy617(x: Int) extends Base +case class Dummy618(x: Int) extends Base +case class Dummy619(x: Int) extends Base +case class Dummy620(x: Int) extends Base +case class Dummy621(x: Int) extends Base +case class Dummy622(x: Int) extends Base +case class Dummy623(x: Int) extends Base +case class Dummy624(x: Int) extends Base +case class Dummy625(x: Int) extends Base +case class Dummy626(x: Int) extends Base +case class Dummy627(x: Int) extends Base +case class Dummy628(x: Int) extends Base +case class Dummy629(x: Int) extends Base +case class Dummy630(x: Int) extends Base +case class Dummy631(x: Int) extends Base +case class Dummy632(x: Int) extends Base +case class Dummy633(x: Int) extends Base +case class Dummy634(x: Int) extends Base +case class Dummy635(x: Int) extends Base +case class Dummy636(x: Int) extends Base +case class Dummy637(x: Int) extends Base +case class Dummy638(x: Int) extends Base +case class Dummy639(x: Int) extends Base +case class Dummy640(x: Int) extends Base +case class Dummy641(x: Int) extends Base +case class Dummy642(x: Int) extends Base +case class Dummy643(x: Int) extends Base +case class Dummy644(x: Int) extends Base +case class Dummy645(x: Int) extends Base +case class Dummy646(x: Int) extends Base +case class Dummy647(x: Int) extends Base +case class Dummy648(x: Int) extends Base +case class Dummy649(x: Int) extends Base +case class Dummy650(x: Int) extends Base +case class Dummy651(x: Int) extends Base +case class Dummy652(x: Int) extends Base +case class Dummy653(x: Int) extends Base +case class Dummy654(x: Int) extends Base +case class Dummy655(x: Int) extends Base +case class Dummy656(x: Int) extends Base +case class Dummy657(x: Int) extends Base +case class Dummy658(x: Int) extends Base +case class Dummy659(x: Int) extends Base +case class Dummy660(x: Int) extends Base +case class Dummy661(x: Int) extends Base +case class Dummy662(x: Int) extends Base +case class Dummy663(x: Int) extends Base +case class Dummy664(x: Int) extends Base +case class Dummy665(x: Int) extends Base +case class Dummy666(x: Int) extends Base +case class Dummy667(x: Int) extends Base +case class Dummy668(x: Int) extends Base +case class Dummy669(x: Int) extends Base +case class Dummy670(x: Int) extends Base +case class Dummy671(x: Int) extends Base +case class Dummy672(x: Int) extends Base +case class Dummy673(x: Int) extends Base +case class Dummy674(x: Int) extends Base +case class Dummy675(x: Int) extends Base +case class Dummy676(x: Int) extends Base +case class Dummy677(x: Int) extends Base +case class Dummy678(x: Int) extends Base +case class Dummy679(x: Int) extends Base +case class Dummy680(x: Int) extends Base +case class Dummy681(x: Int) extends Base +case class Dummy682(x: Int) extends Base +case class Dummy683(x: Int) extends Base +case class Dummy684(x: Int) extends Base +case class Dummy685(x: Int) extends Base +case class Dummy686(x: Int) extends Base +case class Dummy687(x: Int) extends Base +case class Dummy688(x: Int) extends Base +case class Dummy689(x: Int) extends Base +case class Dummy690(x: Int) extends Base +case class Dummy691(x: Int) extends Base +case class Dummy692(x: Int) extends Base +case class Dummy693(x: Int) extends Base +case class Dummy694(x: Int) extends Base +case class Dummy695(x: Int) extends Base +case class Dummy696(x: Int) extends Base +case class Dummy697(x: Int) extends Base +case class Dummy698(x: Int) extends Base +case class Dummy699(x: Int) extends Base +case class Dummy700(x: Int) extends Base +case class Dummy701(x: Int) extends Base +case class Dummy702(x: Int) extends Base +case class Dummy703(x: Int) extends Base +case class Dummy704(x: Int) extends Base +case class Dummy705(x: Int) extends Base +case class Dummy706(x: Int) extends Base +case class Dummy707(x: Int) extends Base +case class Dummy708(x: Int) extends Base +case class Dummy709(x: Int) extends Base +case class Dummy710(x: Int) extends Base +case class Dummy711(x: Int) extends Base +case class Dummy712(x: Int) extends Base +case class Dummy713(x: Int) extends Base +case class Dummy714(x: Int) extends Base +case class Dummy715(x: Int) extends Base +case class Dummy716(x: Int) extends Base +case class Dummy717(x: Int) extends Base +case class Dummy718(x: Int) extends Base +case class Dummy719(x: Int) extends Base +case class Dummy720(x: Int) extends Base +case class Dummy721(x: Int) extends Base +case class Dummy722(x: Int) extends Base +case class Dummy723(x: Int) extends Base +case class Dummy724(x: Int) extends Base +case class Dummy725(x: Int) extends Base +case class Dummy726(x: Int) extends Base +case class Dummy727(x: Int) extends Base +case class Dummy728(x: Int) extends Base +case class Dummy729(x: Int) extends Base +case class Dummy730(x: Int) extends Base +case class Dummy731(x: Int) extends Base +case class Dummy732(x: Int) extends Base +case class Dummy733(x: Int) extends Base +case class Dummy734(x: Int) extends Base +case class Dummy735(x: Int) extends Base +case class Dummy736(x: Int) extends Base +case class Dummy737(x: Int) extends Base +case class Dummy738(x: Int) extends Base +case class Dummy739(x: Int) extends Base +case class Dummy740(x: Int) extends Base +case class Dummy741(x: Int) extends Base +case class Dummy742(x: Int) extends Base +case class Dummy743(x: Int) extends Base +case class Dummy744(x: Int) extends Base +case class Dummy745(x: Int) extends Base +case class Dummy746(x: Int) extends Base +case class Dummy747(x: Int) extends Base +case class Dummy748(x: Int) extends Base +case class Dummy749(x: Int) extends Base +case class Dummy750(x: Int) extends Base +case class Dummy751(x: Int) extends Base +case class Dummy752(x: Int) extends Base +case class Dummy753(x: Int) extends Base +case class Dummy754(x: Int) extends Base +case class Dummy755(x: Int) extends Base +case class Dummy756(x: Int) extends Base +case class Dummy757(x: Int) extends Base +case class Dummy758(x: Int) extends Base +case class Dummy759(x: Int) extends Base +case class Dummy760(x: Int) extends Base +case class Dummy761(x: Int) extends Base +case class Dummy762(x: Int) extends Base +case class Dummy763(x: Int) extends Base +case class Dummy764(x: Int) extends Base +case class Dummy765(x: Int) extends Base +case class Dummy766(x: Int) extends Base +case class Dummy767(x: Int) extends Base +case class Dummy768(x: Int) extends Base +case class Dummy769(x: Int) extends Base +case class Dummy770(x: Int) extends Base +case class Dummy771(x: Int) extends Base +case class Dummy772(x: Int) extends Base +case class Dummy773(x: Int) extends Base +case class Dummy774(x: Int) extends Base +case class Dummy775(x: Int) extends Base +case class Dummy776(x: Int) extends Base +case class Dummy777(x: Int) extends Base +case class Dummy778(x: Int) extends Base +case class Dummy779(x: Int) extends Base +case class Dummy780(x: Int) extends Base +case class Dummy781(x: Int) extends Base +case class Dummy782(x: Int) extends Base +case class Dummy783(x: Int) extends Base +case class Dummy784(x: Int) extends Base +case class Dummy785(x: Int) extends Base +case class Dummy786(x: Int) extends Base +case class Dummy787(x: Int) extends Base +case class Dummy788(x: Int) extends Base +case class Dummy789(x: Int) extends Base +case class Dummy790(x: Int) extends Base +case class Dummy791(x: Int) extends Base +case class Dummy792(x: Int) extends Base +case class Dummy793(x: Int) extends Base +case class Dummy794(x: Int) extends Base +case class Dummy795(x: Int) extends Base +case class Dummy796(x: Int) extends Base +case class Dummy797(x: Int) extends Base +case class Dummy798(x: Int) extends Base +case class Dummy799(x: Int) extends Base +case class Dummy800(x: Int) extends Base +case class Dummy801(x: Int) extends Base +case class Dummy802(x: Int) extends Base +case class Dummy803(x: Int) extends Base +case class Dummy804(x: Int) extends Base +case class Dummy805(x: Int) extends Base +case class Dummy806(x: Int) extends Base +case class Dummy807(x: Int) extends Base +case class Dummy808(x: Int) extends Base +case class Dummy809(x: Int) extends Base +case class Dummy810(x: Int) extends Base +case class Dummy811(x: Int) extends Base +case class Dummy812(x: Int) extends Base +case class Dummy813(x: Int) extends Base +case class Dummy814(x: Int) extends Base +case class Dummy815(x: Int) extends Base +case class Dummy816(x: Int) extends Base +case class Dummy817(x: Int) extends Base +case class Dummy818(x: Int) extends Base +case class Dummy819(x: Int) extends Base +case class Dummy820(x: Int) extends Base +case class Dummy821(x: Int) extends Base +case class Dummy822(x: Int) extends Base +case class Dummy823(x: Int) extends Base +case class Dummy824(x: Int) extends Base +case class Dummy825(x: Int) extends Base +case class Dummy826(x: Int) extends Base +case class Dummy827(x: Int) extends Base +case class Dummy828(x: Int) extends Base +case class Dummy829(x: Int) extends Base +case class Dummy830(x: Int) extends Base +case class Dummy831(x: Int) extends Base +case class Dummy832(x: Int) extends Base +case class Dummy833(x: Int) extends Base +case class Dummy834(x: Int) extends Base +case class Dummy835(x: Int) extends Base +case class Dummy836(x: Int) extends Base +case class Dummy837(x: Int) extends Base +case class Dummy838(x: Int) extends Base +case class Dummy839(x: Int) extends Base +case class Dummy840(x: Int) extends Base +case class Dummy841(x: Int) extends Base +case class Dummy842(x: Int) extends Base +case class Dummy843(x: Int) extends Base +case class Dummy844(x: Int) extends Base +case class Dummy845(x: Int) extends Base +case class Dummy846(x: Int) extends Base +case class Dummy847(x: Int) extends Base +case class Dummy848(x: Int) extends Base +case class Dummy849(x: Int) extends Base +case class Dummy850(x: Int) extends Base +case class Dummy851(x: Int) extends Base +case class Dummy852(x: Int) extends Base +case class Dummy853(x: Int) extends Base +case class Dummy854(x: Int) extends Base +case class Dummy855(x: Int) extends Base +case class Dummy856(x: Int) extends Base +case class Dummy857(x: Int) extends Base +case class Dummy858(x: Int) extends Base +case class Dummy859(x: Int) extends Base +case class Dummy860(x: Int) extends Base +case class Dummy861(x: Int) extends Base +case class Dummy862(x: Int) extends Base +case class Dummy863(x: Int) extends Base +case class Dummy864(x: Int) extends Base +case class Dummy865(x: Int) extends Base +case class Dummy866(x: Int) extends Base +case class Dummy867(x: Int) extends Base +case class Dummy868(x: Int) extends Base +case class Dummy869(x: Int) extends Base +case class Dummy870(x: Int) extends Base +case class Dummy871(x: Int) extends Base +case class Dummy872(x: Int) extends Base +case class Dummy873(x: Int) extends Base +case class Dummy874(x: Int) extends Base +case class Dummy875(x: Int) extends Base +case class Dummy876(x: Int) extends Base +case class Dummy877(x: Int) extends Base +case class Dummy878(x: Int) extends Base +case class Dummy879(x: Int) extends Base +case class Dummy880(x: Int) extends Base +case class Dummy881(x: Int) extends Base +case class Dummy882(x: Int) extends Base +case class Dummy883(x: Int) extends Base +case class Dummy884(x: Int) extends Base +case class Dummy885(x: Int) extends Base +case class Dummy886(x: Int) extends Base +case class Dummy887(x: Int) extends Base +case class Dummy888(x: Int) extends Base +case class Dummy889(x: Int) extends Base +case class Dummy890(x: Int) extends Base +case class Dummy891(x: Int) extends Base +case class Dummy892(x: Int) extends Base +case class Dummy893(x: Int) extends Base +case class Dummy894(x: Int) extends Base +case class Dummy895(x: Int) extends Base +case class Dummy896(x: Int) extends Base +case class Dummy897(x: Int) extends Base +case class Dummy898(x: Int) extends Base +case class Dummy899(x: Int) extends Base +case class Dummy900(x: Int) extends Base +case class Dummy901(x: Int) extends Base +case class Dummy902(x: Int) extends Base +case class Dummy903(x: Int) extends Base +case class Dummy904(x: Int) extends Base +case class Dummy905(x: Int) extends Base +case class Dummy906(x: Int) extends Base +case class Dummy907(x: Int) extends Base +case class Dummy908(x: Int) extends Base +case class Dummy909(x: Int) extends Base +case class Dummy910(x: Int) extends Base +case class Dummy911(x: Int) extends Base +case class Dummy912(x: Int) extends Base +case class Dummy913(x: Int) extends Base +case class Dummy914(x: Int) extends Base +case class Dummy915(x: Int) extends Base +case class Dummy916(x: Int) extends Base +case class Dummy917(x: Int) extends Base +case class Dummy918(x: Int) extends Base +case class Dummy919(x: Int) extends Base +case class Dummy920(x: Int) extends Base +case class Dummy921(x: Int) extends Base +case class Dummy922(x: Int) extends Base +case class Dummy923(x: Int) extends Base +case class Dummy924(x: Int) extends Base +case class Dummy925(x: Int) extends Base +case class Dummy926(x: Int) extends Base +case class Dummy927(x: Int) extends Base +case class Dummy928(x: Int) extends Base +case class Dummy929(x: Int) extends Base +case class Dummy930(x: Int) extends Base +case class Dummy931(x: Int) extends Base +case class Dummy932(x: Int) extends Base +case class Dummy933(x: Int) extends Base +case class Dummy934(x: Int) extends Base +case class Dummy935(x: Int) extends Base +case class Dummy936(x: Int) extends Base +case class Dummy937(x: Int) extends Base +case class Dummy938(x: Int) extends Base +case class Dummy939(x: Int) extends Base +case class Dummy940(x: Int) extends Base +case class Dummy941(x: Int) extends Base +case class Dummy942(x: Int) extends Base +case class Dummy943(x: Int) extends Base +case class Dummy944(x: Int) extends Base +case class Dummy945(x: Int) extends Base +case class Dummy946(x: Int) extends Base +case class Dummy947(x: Int) extends Base +case class Dummy948(x: Int) extends Base +case class Dummy949(x: Int) extends Base +case class Dummy950(x: Int) extends Base +case class Dummy951(x: Int) extends Base +case class Dummy952(x: Int) extends Base +case class Dummy953(x: Int) extends Base +case class Dummy954(x: Int) extends Base +case class Dummy955(x: Int) extends Base +case class Dummy956(x: Int) extends Base +case class Dummy957(x: Int) extends Base +case class Dummy958(x: Int) extends Base +case class Dummy959(x: Int) extends Base +case class Dummy960(x: Int) extends Base +case class Dummy961(x: Int) extends Base +case class Dummy962(x: Int) extends Base +case class Dummy963(x: Int) extends Base +case class Dummy964(x: Int) extends Base +case class Dummy965(x: Int) extends Base +case class Dummy966(x: Int) extends Base +case class Dummy967(x: Int) extends Base +case class Dummy968(x: Int) extends Base +case class Dummy969(x: Int) extends Base +case class Dummy970(x: Int) extends Base +case class Dummy971(x: Int) extends Base +case class Dummy972(x: Int) extends Base +case class Dummy973(x: Int) extends Base +case class Dummy974(x: Int) extends Base +case class Dummy975(x: Int) extends Base +case class Dummy976(x: Int) extends Base +case class Dummy977(x: Int) extends Base +case class Dummy978(x: Int) extends Base +case class Dummy979(x: Int) extends Base +case class Dummy980(x: Int) extends Base +case class Dummy981(x: Int) extends Base +case class Dummy982(x: Int) extends Base +case class Dummy983(x: Int) extends Base +case class Dummy984(x: Int) extends Base +case class Dummy985(x: Int) extends Base +case class Dummy986(x: Int) extends Base +case class Dummy987(x: Int) extends Base +case class Dummy988(x: Int) extends Base +case class Dummy989(x: Int) extends Base +case class Dummy990(x: Int) extends Base +case class Dummy991(x: Int) extends Base +case class Dummy992(x: Int) extends Base +case class Dummy993(x: Int) extends Base +case class Dummy994(x: Int) extends Base +case class Dummy995(x: Int) extends Base +case class Dummy996(x: Int) extends Base +case class Dummy997(x: Int) extends Base +case class Dummy998(x: Int) extends Base +case class Dummy999(x: Int) extends Base +case class Dummy1000(x: Int) extends Base +case class Dummy1001(x: Int) extends Base +case class Dummy1002(x: Int) extends Base +case class Dummy1003(x: Int) extends Base +case class Dummy1004(x: Int) extends Base +case class Dummy1005(x: Int) extends Base +case class Dummy1006(x: Int) extends Base +case class Dummy1007(x: Int) extends Base +case class Dummy1008(x: Int) extends Base +case class Dummy1009(x: Int) extends Base +case class Dummy1010(x: Int) extends Base +case class Dummy1011(x: Int) extends Base +case class Dummy1012(x: Int) extends Base +case class Dummy1013(x: Int) extends Base +case class Dummy1014(x: Int) extends Base +case class Dummy1015(x: Int) extends Base +case class Dummy1016(x: Int) extends Base +case class Dummy1017(x: Int) extends Base +case class Dummy1018(x: Int) extends Base +case class Dummy1019(x: Int) extends Base +case class Dummy1020(x: Int) extends Base +case class Dummy1021(x: Int) extends Base +case class Dummy1022(x: Int) extends Base +case class Dummy1023(x: Int) extends Base +case class Dummy1024(x: Int) extends Base +case class Dummy1025(x: Int) extends Base +case class Dummy1026(x: Int) extends Base +case class Dummy1027(x: Int) extends Base +case class Dummy1028(x: Int) extends Base +case class Dummy1029(x: Int) extends Base +case class Dummy1030(x: Int) extends Base +case class Dummy1031(x: Int) extends Base +case class Dummy1032(x: Int) extends Base +case class Dummy1033(x: Int) extends Base +case class Dummy1034(x: Int) extends Base +case class Dummy1035(x: Int) extends Base +case class Dummy1036(x: Int) extends Base +case class Dummy1037(x: Int) extends Base +case class Dummy1038(x: Int) extends Base +case class Dummy1039(x: Int) extends Base +case class Dummy1040(x: Int) extends Base +case class Dummy1041(x: Int) extends Base +case class Dummy1042(x: Int) extends Base +case class Dummy1043(x: Int) extends Base +case class Dummy1044(x: Int) extends Base +case class Dummy1045(x: Int) extends Base +case class Dummy1046(x: Int) extends Base +case class Dummy1047(x: Int) extends Base +case class Dummy1048(x: Int) extends Base +case class Dummy1049(x: Int) extends Base +case class Dummy1050(x: Int) extends Base +case class Dummy1051(x: Int) extends Base +case class Dummy1052(x: Int) extends Base +case class Dummy1053(x: Int) extends Base +case class Dummy1054(x: Int) extends Base +case class Dummy1055(x: Int) extends Base +case class Dummy1056(x: Int) extends Base +case class Dummy1057(x: Int) extends Base +case class Dummy1058(x: Int) extends Base +case class Dummy1059(x: Int) extends Base +case class Dummy1060(x: Int) extends Base +case class Dummy1061(x: Int) extends Base +case class Dummy1062(x: Int) extends Base +case class Dummy1063(x: Int) extends Base +case class Dummy1064(x: Int) extends Base +case class Dummy1065(x: Int) extends Base +case class Dummy1066(x: Int) extends Base +case class Dummy1067(x: Int) extends Base +case class Dummy1068(x: Int) extends Base +case class Dummy1069(x: Int) extends Base +case class Dummy1070(x: Int) extends Base +case class Dummy1071(x: Int) extends Base +case class Dummy1072(x: Int) extends Base +case class Dummy1073(x: Int) extends Base +case class Dummy1074(x: Int) extends Base +case class Dummy1075(x: Int) extends Base +case class Dummy1076(x: Int) extends Base +case class Dummy1077(x: Int) extends Base +case class Dummy1078(x: Int) extends Base +case class Dummy1079(x: Int) extends Base +case class Dummy1080(x: Int) extends Base +case class Dummy1081(x: Int) extends Base +case class Dummy1082(x: Int) extends Base +case class Dummy1083(x: Int) extends Base +case class Dummy1084(x: Int) extends Base +case class Dummy1085(x: Int) extends Base +case class Dummy1086(x: Int) extends Base +case class Dummy1087(x: Int) extends Base +case class Dummy1088(x: Int) extends Base +case class Dummy1089(x: Int) extends Base +case class Dummy1090(x: Int) extends Base +case class Dummy1091(x: Int) extends Base +case class Dummy1092(x: Int) extends Base +case class Dummy1093(x: Int) extends Base +case class Dummy1094(x: Int) extends Base +case class Dummy1095(x: Int) extends Base +case class Dummy1096(x: Int) extends Base +case class Dummy1097(x: Int) extends Base +case class Dummy1098(x: Int) extends Base +case class Dummy1099(x: Int) extends Base +case class Dummy1100(x: Int) extends Base +case class Dummy1101(x: Int) extends Base +case class Dummy1102(x: Int) extends Base +case class Dummy1103(x: Int) extends Base +case class Dummy1104(x: Int) extends Base +case class Dummy1105(x: Int) extends Base +case class Dummy1106(x: Int) extends Base +case class Dummy1107(x: Int) extends Base +case class Dummy1108(x: Int) extends Base +case class Dummy1109(x: Int) extends Base +case class Dummy1110(x: Int) extends Base +case class Dummy1111(x: Int) extends Base +case class Dummy1112(x: Int) extends Base +case class Dummy1113(x: Int) extends Base +case class Dummy1114(x: Int) extends Base +case class Dummy1115(x: Int) extends Base +case class Dummy1116(x: Int) extends Base +case class Dummy1117(x: Int) extends Base +case class Dummy1118(x: Int) extends Base +case class Dummy1119(x: Int) extends Base +case class Dummy1120(x: Int) extends Base +case class Dummy1121(x: Int) extends Base +case class Dummy1122(x: Int) extends Base +case class Dummy1123(x: Int) extends Base +case class Dummy1124(x: Int) extends Base +case class Dummy1125(x: Int) extends Base +case class Dummy1126(x: Int) extends Base +case class Dummy1127(x: Int) extends Base +case class Dummy1128(x: Int) extends Base +case class Dummy1129(x: Int) extends Base +case class Dummy1130(x: Int) extends Base +case class Dummy1131(x: Int) extends Base +case class Dummy1132(x: Int) extends Base +case class Dummy1133(x: Int) extends Base +case class Dummy1134(x: Int) extends Base +case class Dummy1135(x: Int) extends Base +case class Dummy1136(x: Int) extends Base +case class Dummy1137(x: Int) extends Base +case class Dummy1138(x: Int) extends Base +case class Dummy1139(x: Int) extends Base +case class Dummy1140(x: Int) extends Base +case class Dummy1141(x: Int) extends Base +case class Dummy1142(x: Int) extends Base +case class Dummy1143(x: Int) extends Base +case class Dummy1144(x: Int) extends Base +case class Dummy1145(x: Int) extends Base +case class Dummy1146(x: Int) extends Base +case class Dummy1147(x: Int) extends Base +case class Dummy1148(x: Int) extends Base +case class Dummy1149(x: Int) extends Base +case class Dummy1150(x: Int) extends Base +case class Dummy1151(x: Int) extends Base +case class Dummy1152(x: Int) extends Base +case class Dummy1153(x: Int) extends Base +case class Dummy1154(x: Int) extends Base +case class Dummy1155(x: Int) extends Base +case class Dummy1156(x: Int) extends Base +case class Dummy1157(x: Int) extends Base +case class Dummy1158(x: Int) extends Base +case class Dummy1159(x: Int) extends Base +case class Dummy1160(x: Int) extends Base +case class Dummy1161(x: Int) extends Base +case class Dummy1162(x: Int) extends Base +case class Dummy1163(x: Int) extends Base +case class Dummy1164(x: Int) extends Base +case class Dummy1165(x: Int) extends Base +case class Dummy1166(x: Int) extends Base +case class Dummy1167(x: Int) extends Base +case class Dummy1168(x: Int) extends Base +case class Dummy1169(x: Int) extends Base +case class Dummy1170(x: Int) extends Base +case class Dummy1171(x: Int) extends Base +case class Dummy1172(x: Int) extends Base +case class Dummy1173(x: Int) extends Base +case class Dummy1174(x: Int) extends Base +case class Dummy1175(x: Int) extends Base +case class Dummy1176(x: Int) extends Base +case class Dummy1177(x: Int) extends Base +case class Dummy1178(x: Int) extends Base +case class Dummy1179(x: Int) extends Base +case class Dummy1180(x: Int) extends Base +case class Dummy1181(x: Int) extends Base +case class Dummy1182(x: Int) extends Base +case class Dummy1183(x: Int) extends Base +case class Dummy1184(x: Int) extends Base +case class Dummy1185(x: Int) extends Base +case class Dummy1186(x: Int) extends Base +case class Dummy1187(x: Int) extends Base +case class Dummy1188(x: Int) extends Base +case class Dummy1189(x: Int) extends Base +case class Dummy1190(x: Int) extends Base +case class Dummy1191(x: Int) extends Base +case class Dummy1192(x: Int) extends Base +case class Dummy1193(x: Int) extends Base +case class Dummy1194(x: Int) extends Base +case class Dummy1195(x: Int) extends Base +case class Dummy1196(x: Int) extends Base +case class Dummy1197(x: Int) extends Base +case class Dummy1198(x: Int) extends Base +case class Dummy1199(x: Int) extends Base +case class Dummy1200(x: Int) extends Base +case class Dummy1201(x: Int) extends Base +case class Dummy1202(x: Int) extends Base +case class Dummy1203(x: Int) extends Base +case class Dummy1204(x: Int) extends Base +case class Dummy1205(x: Int) extends Base +case class Dummy1206(x: Int) extends Base +case class Dummy1207(x: Int) extends Base +case class Dummy1208(x: Int) extends Base +case class Dummy1209(x: Int) extends Base +case class Dummy1210(x: Int) extends Base +case class Dummy1211(x: Int) extends Base +case class Dummy1212(x: Int) extends Base +case class Dummy1213(x: Int) extends Base +case class Dummy1214(x: Int) extends Base +case class Dummy1215(x: Int) extends Base +case class Dummy1216(x: Int) extends Base +case class Dummy1217(x: Int) extends Base +case class Dummy1218(x: Int) extends Base +case class Dummy1219(x: Int) extends Base +case class Dummy1220(x: Int) extends Base +case class Dummy1221(x: Int) extends Base +case class Dummy1222(x: Int) extends Base +case class Dummy1223(x: Int) extends Base +case class Dummy1224(x: Int) extends Base +case class Dummy1225(x: Int) extends Base +case class Dummy1226(x: Int) extends Base +case class Dummy1227(x: Int) extends Base +case class Dummy1228(x: Int) extends Base +case class Dummy1229(x: Int) extends Base +case class Dummy1230(x: Int) extends Base +case class Dummy1231(x: Int) extends Base +case class Dummy1232(x: Int) extends Base +case class Dummy1233(x: Int) extends Base +case class Dummy1234(x: Int) extends Base +case class Dummy1235(x: Int) extends Base +case class Dummy1236(x: Int) extends Base +case class Dummy1237(x: Int) extends Base +case class Dummy1238(x: Int) extends Base +case class Dummy1239(x: Int) extends Base +case class Dummy1240(x: Int) extends Base +case class Dummy1241(x: Int) extends Base +case class Dummy1242(x: Int) extends Base +case class Dummy1243(x: Int) extends Base +case class Dummy1244(x: Int) extends Base +case class Dummy1245(x: Int) extends Base +case class Dummy1246(x: Int) extends Base +case class Dummy1247(x: Int) extends Base +case class Dummy1248(x: Int) extends Base +case class Dummy1249(x: Int) extends Base +case class Dummy1250(x: Int) extends Base +case class Dummy1251(x: Int) extends Base +case class Dummy1252(x: Int) extends Base +case class Dummy1253(x: Int) extends Base +case class Dummy1254(x: Int) extends Base +case class Dummy1255(x: Int) extends Base +case class Dummy1256(x: Int) extends Base +case class Dummy1257(x: Int) extends Base +case class Dummy1258(x: Int) extends Base +case class Dummy1259(x: Int) extends Base +case class Dummy1260(x: Int) extends Base +case class Dummy1261(x: Int) extends Base +case class Dummy1262(x: Int) extends Base +case class Dummy1263(x: Int) extends Base +case class Dummy1264(x: Int) extends Base +case class Dummy1265(x: Int) extends Base +case class Dummy1266(x: Int) extends Base +case class Dummy1267(x: Int) extends Base +case class Dummy1268(x: Int) extends Base +case class Dummy1269(x: Int) extends Base +case class Dummy1270(x: Int) extends Base +case class Dummy1271(x: Int) extends Base +case class Dummy1272(x: Int) extends Base +case class Dummy1273(x: Int) extends Base +case class Dummy1274(x: Int) extends Base +case class Dummy1275(x: Int) extends Base +case class Dummy1276(x: Int) extends Base +case class Dummy1277(x: Int) extends Base +case class Dummy1278(x: Int) extends Base +case class Dummy1279(x: Int) extends Base +case class Dummy1280(x: Int) extends Base +case class Dummy1281(x: Int) extends Base +case class Dummy1282(x: Int) extends Base +case class Dummy1283(x: Int) extends Base +case class Dummy1284(x: Int) extends Base +case class Dummy1285(x: Int) extends Base +case class Dummy1286(x: Int) extends Base +case class Dummy1287(x: Int) extends Base +case class Dummy1288(x: Int) extends Base +case class Dummy1289(x: Int) extends Base +case class Dummy1290(x: Int) extends Base +case class Dummy1291(x: Int) extends Base +case class Dummy1292(x: Int) extends Base +case class Dummy1293(x: Int) extends Base +case class Dummy1294(x: Int) extends Base +case class Dummy1295(x: Int) extends Base +case class Dummy1296(x: Int) extends Base +case class Dummy1297(x: Int) extends Base +case class Dummy1298(x: Int) extends Base +case class Dummy1299(x: Int) extends Base +case class Dummy1300(x: Int) extends Base +case class Dummy1301(x: Int) extends Base +case class Dummy1302(x: Int) extends Base +case class Dummy1303(x: Int) extends Base +case class Dummy1304(x: Int) extends Base +case class Dummy1305(x: Int) extends Base +case class Dummy1306(x: Int) extends Base +case class Dummy1307(x: Int) extends Base +case class Dummy1308(x: Int) extends Base +case class Dummy1309(x: Int) extends Base +case class Dummy1310(x: Int) extends Base +case class Dummy1311(x: Int) extends Base +case class Dummy1312(x: Int) extends Base +case class Dummy1313(x: Int) extends Base +case class Dummy1314(x: Int) extends Base +case class Dummy1315(x: Int) extends Base +case class Dummy1316(x: Int) extends Base +case class Dummy1317(x: Int) extends Base +case class Dummy1318(x: Int) extends Base +case class Dummy1319(x: Int) extends Base +case class Dummy1320(x: Int) extends Base +case class Dummy1321(x: Int) extends Base +case class Dummy1322(x: Int) extends Base +case class Dummy1323(x: Int) extends Base +case class Dummy1324(x: Int) extends Base +case class Dummy1325(x: Int) extends Base +case class Dummy1326(x: Int) extends Base +case class Dummy1327(x: Int) extends Base +case class Dummy1328(x: Int) extends Base +case class Dummy1329(x: Int) extends Base +case class Dummy1330(x: Int) extends Base +case class Dummy1331(x: Int) extends Base +case class Dummy1332(x: Int) extends Base +case class Dummy1333(x: Int) extends Base +case class Dummy1334(x: Int) extends Base +case class Dummy1335(x: Int) extends Base +case class Dummy1336(x: Int) extends Base +case class Dummy1337(x: Int) extends Base +case class Dummy1338(x: Int) extends Base +case class Dummy1339(x: Int) extends Base +case class Dummy1340(x: Int) extends Base +case class Dummy1341(x: Int) extends Base +case class Dummy1342(x: Int) extends Base +case class Dummy1343(x: Int) extends Base +case class Dummy1344(x: Int) extends Base +case class Dummy1345(x: Int) extends Base +case class Dummy1346(x: Int) extends Base +case class Dummy1347(x: Int) extends Base +case class Dummy1348(x: Int) extends Base +case class Dummy1349(x: Int) extends Base +case class Dummy1350(x: Int) extends Base +case class Dummy1351(x: Int) extends Base +case class Dummy1352(x: Int) extends Base +case class Dummy1353(x: Int) extends Base +case class Dummy1354(x: Int) extends Base +case class Dummy1355(x: Int) extends Base +case class Dummy1356(x: Int) extends Base +case class Dummy1357(x: Int) extends Base +case class Dummy1358(x: Int) extends Base +case class Dummy1359(x: Int) extends Base +case class Dummy1360(x: Int) extends Base +case class Dummy1361(x: Int) extends Base +case class Dummy1362(x: Int) extends Base +case class Dummy1363(x: Int) extends Base +case class Dummy1364(x: Int) extends Base +case class Dummy1365(x: Int) extends Base +case class Dummy1366(x: Int) extends Base +case class Dummy1367(x: Int) extends Base +case class Dummy1368(x: Int) extends Base +case class Dummy1369(x: Int) extends Base +case class Dummy1370(x: Int) extends Base +case class Dummy1371(x: Int) extends Base +case class Dummy1372(x: Int) extends Base +case class Dummy1373(x: Int) extends Base +case class Dummy1374(x: Int) extends Base +case class Dummy1375(x: Int) extends Base +case class Dummy1376(x: Int) extends Base +case class Dummy1377(x: Int) extends Base +case class Dummy1378(x: Int) extends Base +case class Dummy1379(x: Int) extends Base +case class Dummy1380(x: Int) extends Base +case class Dummy1381(x: Int) extends Base +case class Dummy1382(x: Int) extends Base +case class Dummy1383(x: Int) extends Base +case class Dummy1384(x: Int) extends Base +case class Dummy1385(x: Int) extends Base +case class Dummy1386(x: Int) extends Base +case class Dummy1387(x: Int) extends Base +case class Dummy1388(x: Int) extends Base +case class Dummy1389(x: Int) extends Base +case class Dummy1390(x: Int) extends Base +case class Dummy1391(x: Int) extends Base +case class Dummy1392(x: Int) extends Base +case class Dummy1393(x: Int) extends Base +case class Dummy1394(x: Int) extends Base +case class Dummy1395(x: Int) extends Base +case class Dummy1396(x: Int) extends Base +case class Dummy1397(x: Int) extends Base +case class Dummy1398(x: Int) extends Base +case class Dummy1399(x: Int) extends Base +case class Dummy1400(x: Int) extends Base +case class Dummy1401(x: Int) extends Base +case class Dummy1402(x: Int) extends Base +case class Dummy1403(x: Int) extends Base +case class Dummy1404(x: Int) extends Base +case class Dummy1405(x: Int) extends Base +case class Dummy1406(x: Int) extends Base +case class Dummy1407(x: Int) extends Base +case class Dummy1408(x: Int) extends Base +case class Dummy1409(x: Int) extends Base +case class Dummy1410(x: Int) extends Base +case class Dummy1411(x: Int) extends Base +case class Dummy1412(x: Int) extends Base +case class Dummy1413(x: Int) extends Base +case class Dummy1414(x: Int) extends Base +case class Dummy1415(x: Int) extends Base +case class Dummy1416(x: Int) extends Base +case class Dummy1417(x: Int) extends Base +case class Dummy1418(x: Int) extends Base +case class Dummy1419(x: Int) extends Base +case class Dummy1420(x: Int) extends Base +case class Dummy1421(x: Int) extends Base +case class Dummy1422(x: Int) extends Base +case class Dummy1423(x: Int) extends Base +case class Dummy1424(x: Int) extends Base +case class Dummy1425(x: Int) extends Base +case class Dummy1426(x: Int) extends Base +case class Dummy1427(x: Int) extends Base +case class Dummy1428(x: Int) extends Base +case class Dummy1429(x: Int) extends Base +case class Dummy1430(x: Int) extends Base +case class Dummy1431(x: Int) extends Base +case class Dummy1432(x: Int) extends Base +case class Dummy1433(x: Int) extends Base +case class Dummy1434(x: Int) extends Base +case class Dummy1435(x: Int) extends Base +case class Dummy1436(x: Int) extends Base +case class Dummy1437(x: Int) extends Base +case class Dummy1438(x: Int) extends Base +case class Dummy1439(x: Int) extends Base +case class Dummy1440(x: Int) extends Base +case class Dummy1441(x: Int) extends Base +case class Dummy1442(x: Int) extends Base +case class Dummy1443(x: Int) extends Base +case class Dummy1444(x: Int) extends Base +case class Dummy1445(x: Int) extends Base +case class Dummy1446(x: Int) extends Base +case class Dummy1447(x: Int) extends Base +case class Dummy1448(x: Int) extends Base +case class Dummy1449(x: Int) extends Base +case class Dummy1450(x: Int) extends Base +case class Dummy1451(x: Int) extends Base +case class Dummy1452(x: Int) extends Base +case class Dummy1453(x: Int) extends Base +case class Dummy1454(x: Int) extends Base +case class Dummy1455(x: Int) extends Base +case class Dummy1456(x: Int) extends Base +case class Dummy1457(x: Int) extends Base +case class Dummy1458(x: Int) extends Base +case class Dummy1459(x: Int) extends Base +case class Dummy1460(x: Int) extends Base +case class Dummy1461(x: Int) extends Base +case class Dummy1462(x: Int) extends Base +case class Dummy1463(x: Int) extends Base +case class Dummy1464(x: Int) extends Base +case class Dummy1465(x: Int) extends Base +case class Dummy1466(x: Int) extends Base +case class Dummy1467(x: Int) extends Base +case class Dummy1468(x: Int) extends Base +case class Dummy1469(x: Int) extends Base +case class Dummy1470(x: Int) extends Base +case class Dummy1471(x: Int) extends Base +case class Dummy1472(x: Int) extends Base +case class Dummy1473(x: Int) extends Base +case class Dummy1474(x: Int) extends Base +case class Dummy1475(x: Int) extends Base +case class Dummy1476(x: Int) extends Base +case class Dummy1477(x: Int) extends Base +case class Dummy1478(x: Int) extends Base +case class Dummy1479(x: Int) extends Base +case class Dummy1480(x: Int) extends Base +case class Dummy1481(x: Int) extends Base +case class Dummy1482(x: Int) extends Base +case class Dummy1483(x: Int) extends Base +case class Dummy1484(x: Int) extends Base +case class Dummy1485(x: Int) extends Base +case class Dummy1486(x: Int) extends Base +case class Dummy1487(x: Int) extends Base +case class Dummy1488(x: Int) extends Base +case class Dummy1489(x: Int) extends Base +case class Dummy1490(x: Int) extends Base +case class Dummy1491(x: Int) extends Base +case class Dummy1492(x: Int) extends Base +case class Dummy1493(x: Int) extends Base +case class Dummy1494(x: Int) extends Base +case class Dummy1495(x: Int) extends Base +case class Dummy1496(x: Int) extends Base +case class Dummy1497(x: Int) extends Base +case class Dummy1498(x: Int) extends Base +case class Dummy1499(x: Int) extends Base +case class Dummy1500(x: Int) extends Base +case class Dummy1501(x: Int) extends Base +case class Dummy1502(x: Int) extends Base +case class Dummy1503(x: Int) extends Base +case class Dummy1504(x: Int) extends Base +case class Dummy1505(x: Int) extends Base +case class Dummy1506(x: Int) extends Base +case class Dummy1507(x: Int) extends Base +case class Dummy1508(x: Int) extends Base +case class Dummy1509(x: Int) extends Base +case class Dummy1510(x: Int) extends Base +case class Dummy1511(x: Int) extends Base +case class Dummy1512(x: Int) extends Base +case class Dummy1513(x: Int) extends Base +case class Dummy1514(x: Int) extends Base +case class Dummy1515(x: Int) extends Base +case class Dummy1516(x: Int) extends Base +case class Dummy1517(x: Int) extends Base +case class Dummy1518(x: Int) extends Base +case class Dummy1519(x: Int) extends Base +case class Dummy1520(x: Int) extends Base +case class Dummy1521(x: Int) extends Base +case class Dummy1522(x: Int) extends Base +case class Dummy1523(x: Int) extends Base +case class Dummy1524(x: Int) extends Base +case class Dummy1525(x: Int) extends Base +case class Dummy1526(x: Int) extends Base +case class Dummy1527(x: Int) extends Base +case class Dummy1528(x: Int) extends Base +case class Dummy1529(x: Int) extends Base +case class Dummy1530(x: Int) extends Base +case class Dummy1531(x: Int) extends Base +case class Dummy1532(x: Int) extends Base +case class Dummy1533(x: Int) extends Base +case class Dummy1534(x: Int) extends Base +case class Dummy1535(x: Int) extends Base +case class Dummy1536(x: Int) extends Base +case class Dummy1537(x: Int) extends Base +case class Dummy1538(x: Int) extends Base +case class Dummy1539(x: Int) extends Base +case class Dummy1540(x: Int) extends Base +case class Dummy1541(x: Int) extends Base +case class Dummy1542(x: Int) extends Base +case class Dummy1543(x: Int) extends Base +case class Dummy1544(x: Int) extends Base +case class Dummy1545(x: Int) extends Base +case class Dummy1546(x: Int) extends Base +case class Dummy1547(x: Int) extends Base +case class Dummy1548(x: Int) extends Base +case class Dummy1549(x: Int) extends Base +case class Dummy1550(x: Int) extends Base +case class Dummy1551(x: Int) extends Base +case class Dummy1552(x: Int) extends Base +case class Dummy1553(x: Int) extends Base +case class Dummy1554(x: Int) extends Base +case class Dummy1555(x: Int) extends Base +case class Dummy1556(x: Int) extends Base +case class Dummy1557(x: Int) extends Base +case class Dummy1558(x: Int) extends Base +case class Dummy1559(x: Int) extends Base +case class Dummy1560(x: Int) extends Base +case class Dummy1561(x: Int) extends Base +case class Dummy1562(x: Int) extends Base +case class Dummy1563(x: Int) extends Base +case class Dummy1564(x: Int) extends Base +case class Dummy1565(x: Int) extends Base +case class Dummy1566(x: Int) extends Base +case class Dummy1567(x: Int) extends Base +case class Dummy1568(x: Int) extends Base +case class Dummy1569(x: Int) extends Base +case class Dummy1570(x: Int) extends Base +case class Dummy1571(x: Int) extends Base +case class Dummy1572(x: Int) extends Base +case class Dummy1573(x: Int) extends Base +case class Dummy1574(x: Int) extends Base +case class Dummy1575(x: Int) extends Base +case class Dummy1576(x: Int) extends Base +case class Dummy1577(x: Int) extends Base +case class Dummy1578(x: Int) extends Base +case class Dummy1579(x: Int) extends Base +case class Dummy1580(x: Int) extends Base +case class Dummy1581(x: Int) extends Base +case class Dummy1582(x: Int) extends Base +case class Dummy1583(x: Int) extends Base +case class Dummy1584(x: Int) extends Base +case class Dummy1585(x: Int) extends Base +case class Dummy1586(x: Int) extends Base +case class Dummy1587(x: Int) extends Base +case class Dummy1588(x: Int) extends Base +case class Dummy1589(x: Int) extends Base +case class Dummy1590(x: Int) extends Base +case class Dummy1591(x: Int) extends Base +case class Dummy1592(x: Int) extends Base +case class Dummy1593(x: Int) extends Base +case class Dummy1594(x: Int) extends Base +case class Dummy1595(x: Int) extends Base +case class Dummy1596(x: Int) extends Base +case class Dummy1597(x: Int) extends Base +case class Dummy1598(x: Int) extends Base +case class Dummy1599(x: Int) extends Base +case class Dummy1600(x: Int) extends Base +case class Dummy1601(x: Int) extends Base +case class Dummy1602(x: Int) extends Base +case class Dummy1603(x: Int) extends Base +case class Dummy1604(x: Int) extends Base +case class Dummy1605(x: Int) extends Base +case class Dummy1606(x: Int) extends Base +case class Dummy1607(x: Int) extends Base +case class Dummy1608(x: Int) extends Base +case class Dummy1609(x: Int) extends Base +case class Dummy1610(x: Int) extends Base +case class Dummy1611(x: Int) extends Base +case class Dummy1612(x: Int) extends Base +case class Dummy1613(x: Int) extends Base +case class Dummy1614(x: Int) extends Base +case class Dummy1615(x: Int) extends Base +case class Dummy1616(x: Int) extends Base +case class Dummy1617(x: Int) extends Base +case class Dummy1618(x: Int) extends Base +case class Dummy1619(x: Int) extends Base +case class Dummy1620(x: Int) extends Base +case class Dummy1621(x: Int) extends Base +case class Dummy1622(x: Int) extends Base +case class Dummy1623(x: Int) extends Base +case class Dummy1624(x: Int) extends Base +case class Dummy1625(x: Int) extends Base +case class Dummy1626(x: Int) extends Base +case class Dummy1627(x: Int) extends Base +case class Dummy1628(x: Int) extends Base +case class Dummy1629(x: Int) extends Base +case class Dummy1630(x: Int) extends Base +case class Dummy1631(x: Int) extends Base +case class Dummy1632(x: Int) extends Base +case class Dummy1633(x: Int) extends Base +case class Dummy1634(x: Int) extends Base +case class Dummy1635(x: Int) extends Base +case class Dummy1636(x: Int) extends Base +case class Dummy1637(x: Int) extends Base +case class Dummy1638(x: Int) extends Base +case class Dummy1639(x: Int) extends Base +case class Dummy1640(x: Int) extends Base +case class Dummy1641(x: Int) extends Base +case class Dummy1642(x: Int) extends Base +case class Dummy1643(x: Int) extends Base +case class Dummy1644(x: Int) extends Base +case class Dummy1645(x: Int) extends Base +case class Dummy1646(x: Int) extends Base +case class Dummy1647(x: Int) extends Base +case class Dummy1648(x: Int) extends Base +case class Dummy1649(x: Int) extends Base +case class Dummy1650(x: Int) extends Base +case class Dummy1651(x: Int) extends Base +case class Dummy1652(x: Int) extends Base +case class Dummy1653(x: Int) extends Base +case class Dummy1654(x: Int) extends Base +case class Dummy1655(x: Int) extends Base +case class Dummy1656(x: Int) extends Base +case class Dummy1657(x: Int) extends Base +case class Dummy1658(x: Int) extends Base +case class Dummy1659(x: Int) extends Base +case class Dummy1660(x: Int) extends Base +case class Dummy1661(x: Int) extends Base +case class Dummy1662(x: Int) extends Base +case class Dummy1663(x: Int) extends Base +case class Dummy1664(x: Int) extends Base +case class Dummy1665(x: Int) extends Base +case class Dummy1666(x: Int) extends Base +case class Dummy1667(x: Int) extends Base +case class Dummy1668(x: Int) extends Base +case class Dummy1669(x: Int) extends Base +case class Dummy1670(x: Int) extends Base +case class Dummy1671(x: Int) extends Base +case class Dummy1672(x: Int) extends Base +case class Dummy1673(x: Int) extends Base +case class Dummy1674(x: Int) extends Base +case class Dummy1675(x: Int) extends Base +case class Dummy1676(x: Int) extends Base +case class Dummy1677(x: Int) extends Base +case class Dummy1678(x: Int) extends Base +case class Dummy1679(x: Int) extends Base +case class Dummy1680(x: Int) extends Base +case class Dummy1681(x: Int) extends Base +case class Dummy1682(x: Int) extends Base +case class Dummy1683(x: Int) extends Base +case class Dummy1684(x: Int) extends Base +case class Dummy1685(x: Int) extends Base +case class Dummy1686(x: Int) extends Base +case class Dummy1687(x: Int) extends Base +case class Dummy1688(x: Int) extends Base +case class Dummy1689(x: Int) extends Base +case class Dummy1690(x: Int) extends Base +case class Dummy1691(x: Int) extends Base +case class Dummy1692(x: Int) extends Base +case class Dummy1693(x: Int) extends Base +case class Dummy1694(x: Int) extends Base +case class Dummy1695(x: Int) extends Base +case class Dummy1696(x: Int) extends Base +case class Dummy1697(x: Int) extends Base +case class Dummy1698(x: Int) extends Base +case class Dummy1699(x: Int) extends Base +case class Dummy1700(x: Int) extends Base +case class Dummy1701(x: Int) extends Base +case class Dummy1702(x: Int) extends Base +case class Dummy1703(x: Int) extends Base +case class Dummy1704(x: Int) extends Base +case class Dummy1705(x: Int) extends Base +case class Dummy1706(x: Int) extends Base +case class Dummy1707(x: Int) extends Base +case class Dummy1708(x: Int) extends Base +case class Dummy1709(x: Int) extends Base +case class Dummy1710(x: Int) extends Base +case class Dummy1711(x: Int) extends Base +case class Dummy1712(x: Int) extends Base +case class Dummy1713(x: Int) extends Base +case class Dummy1714(x: Int) extends Base +case class Dummy1715(x: Int) extends Base +case class Dummy1716(x: Int) extends Base +case class Dummy1717(x: Int) extends Base +case class Dummy1718(x: Int) extends Base +case class Dummy1719(x: Int) extends Base +case class Dummy1720(x: Int) extends Base +case class Dummy1721(x: Int) extends Base +case class Dummy1722(x: Int) extends Base +case class Dummy1723(x: Int) extends Base +case class Dummy1724(x: Int) extends Base +case class Dummy1725(x: Int) extends Base +case class Dummy1726(x: Int) extends Base +case class Dummy1727(x: Int) extends Base +case class Dummy1728(x: Int) extends Base +case class Dummy1729(x: Int) extends Base +case class Dummy1730(x: Int) extends Base +case class Dummy1731(x: Int) extends Base +case class Dummy1732(x: Int) extends Base +case class Dummy1733(x: Int) extends Base +case class Dummy1734(x: Int) extends Base +case class Dummy1735(x: Int) extends Base +case class Dummy1736(x: Int) extends Base +case class Dummy1737(x: Int) extends Base +case class Dummy1738(x: Int) extends Base +case class Dummy1739(x: Int) extends Base +case class Dummy1740(x: Int) extends Base +case class Dummy1741(x: Int) extends Base +case class Dummy1742(x: Int) extends Base +case class Dummy1743(x: Int) extends Base +case class Dummy1744(x: Int) extends Base +case class Dummy1745(x: Int) extends Base +case class Dummy1746(x: Int) extends Base +case class Dummy1747(x: Int) extends Base +case class Dummy1748(x: Int) extends Base +case class Dummy1749(x: Int) extends Base +case class Dummy1750(x: Int) extends Base +case class Dummy1751(x: Int) extends Base +case class Dummy1752(x: Int) extends Base +case class Dummy1753(x: Int) extends Base +case class Dummy1754(x: Int) extends Base +case class Dummy1755(x: Int) extends Base +case class Dummy1756(x: Int) extends Base +case class Dummy1757(x: Int) extends Base +case class Dummy1758(x: Int) extends Base +case class Dummy1759(x: Int) extends Base +case class Dummy1760(x: Int) extends Base +case class Dummy1761(x: Int) extends Base +case class Dummy1762(x: Int) extends Base +case class Dummy1763(x: Int) extends Base +case class Dummy1764(x: Int) extends Base +case class Dummy1765(x: Int) extends Base +case class Dummy1766(x: Int) extends Base +case class Dummy1767(x: Int) extends Base +case class Dummy1768(x: Int) extends Base +case class Dummy1769(x: Int) extends Base +case class Dummy1770(x: Int) extends Base +case class Dummy1771(x: Int) extends Base +case class Dummy1772(x: Int) extends Base +case class Dummy1773(x: Int) extends Base +case class Dummy1774(x: Int) extends Base +case class Dummy1775(x: Int) extends Base +case class Dummy1776(x: Int) extends Base +case class Dummy1777(x: Int) extends Base +case class Dummy1778(x: Int) extends Base +case class Dummy1779(x: Int) extends Base +case class Dummy1780(x: Int) extends Base +case class Dummy1781(x: Int) extends Base +case class Dummy1782(x: Int) extends Base +case class Dummy1783(x: Int) extends Base +case class Dummy1784(x: Int) extends Base +case class Dummy1785(x: Int) extends Base +case class Dummy1786(x: Int) extends Base +case class Dummy1787(x: Int) extends Base +case class Dummy1788(x: Int) extends Base +case class Dummy1789(x: Int) extends Base +case class Dummy1790(x: Int) extends Base +case class Dummy1791(x: Int) extends Base +case class Dummy1792(x: Int) extends Base +case class Dummy1793(x: Int) extends Base +case class Dummy1794(x: Int) extends Base +case class Dummy1795(x: Int) extends Base +case class Dummy1796(x: Int) extends Base +case class Dummy1797(x: Int) extends Base +case class Dummy1798(x: Int) extends Base +case class Dummy1799(x: Int) extends Base +case class Dummy1800(x: Int) extends Base +case class Dummy1801(x: Int) extends Base +case class Dummy1802(x: Int) extends Base +case class Dummy1803(x: Int) extends Base +case class Dummy1804(x: Int) extends Base +case class Dummy1805(x: Int) extends Base +case class Dummy1806(x: Int) extends Base +case class Dummy1807(x: Int) extends Base +case class Dummy1808(x: Int) extends Base +case class Dummy1809(x: Int) extends Base +case class Dummy1810(x: Int) extends Base +case class Dummy1811(x: Int) extends Base +case class Dummy1812(x: Int) extends Base +case class Dummy1813(x: Int) extends Base +case class Dummy1814(x: Int) extends Base +case class Dummy1815(x: Int) extends Base +case class Dummy1816(x: Int) extends Base +case class Dummy1817(x: Int) extends Base +case class Dummy1818(x: Int) extends Base +case class Dummy1819(x: Int) extends Base +case class Dummy1820(x: Int) extends Base +case class Dummy1821(x: Int) extends Base +case class Dummy1822(x: Int) extends Base +case class Dummy1823(x: Int) extends Base +case class Dummy1824(x: Int) extends Base +case class Dummy1825(x: Int) extends Base +case class Dummy1826(x: Int) extends Base +case class Dummy1827(x: Int) extends Base +case class Dummy1828(x: Int) extends Base +case class Dummy1829(x: Int) extends Base +case class Dummy1830(x: Int) extends Base +case class Dummy1831(x: Int) extends Base +case class Dummy1832(x: Int) extends Base +case class Dummy1833(x: Int) extends Base +case class Dummy1834(x: Int) extends Base +case class Dummy1835(x: Int) extends Base +case class Dummy1836(x: Int) extends Base +case class Dummy1837(x: Int) extends Base +case class Dummy1838(x: Int) extends Base +case class Dummy1839(x: Int) extends Base +case class Dummy1840(x: Int) extends Base +case class Dummy1841(x: Int) extends Base +case class Dummy1842(x: Int) extends Base +case class Dummy1843(x: Int) extends Base +case class Dummy1844(x: Int) extends Base +case class Dummy1845(x: Int) extends Base +case class Dummy1846(x: Int) extends Base +case class Dummy1847(x: Int) extends Base +case class Dummy1848(x: Int) extends Base +case class Dummy1849(x: Int) extends Base +case class Dummy1850(x: Int) extends Base +case class Dummy1851(x: Int) extends Base +case class Dummy1852(x: Int) extends Base +case class Dummy1853(x: Int) extends Base +case class Dummy1854(x: Int) extends Base +case class Dummy1855(x: Int) extends Base +case class Dummy1856(x: Int) extends Base +case class Dummy1857(x: Int) extends Base +case class Dummy1858(x: Int) extends Base +case class Dummy1859(x: Int) extends Base +case class Dummy1860(x: Int) extends Base +case class Dummy1861(x: Int) extends Base +case class Dummy1862(x: Int) extends Base +case class Dummy1863(x: Int) extends Base +case class Dummy1864(x: Int) extends Base +case class Dummy1865(x: Int) extends Base +case class Dummy1866(x: Int) extends Base +case class Dummy1867(x: Int) extends Base +case class Dummy1868(x: Int) extends Base +case class Dummy1869(x: Int) extends Base +case class Dummy1870(x: Int) extends Base +case class Dummy1871(x: Int) extends Base +case class Dummy1872(x: Int) extends Base +case class Dummy1873(x: Int) extends Base +case class Dummy1874(x: Int) extends Base +case class Dummy1875(x: Int) extends Base +case class Dummy1876(x: Int) extends Base +case class Dummy1877(x: Int) extends Base +case class Dummy1878(x: Int) extends Base +case class Dummy1879(x: Int) extends Base +case class Dummy1880(x: Int) extends Base +case class Dummy1881(x: Int) extends Base +case class Dummy1882(x: Int) extends Base +case class Dummy1883(x: Int) extends Base +case class Dummy1884(x: Int) extends Base +case class Dummy1885(x: Int) extends Base +case class Dummy1886(x: Int) extends Base +case class Dummy1887(x: Int) extends Base +case class Dummy1888(x: Int) extends Base +case class Dummy1889(x: Int) extends Base +case class Dummy1890(x: Int) extends Base +case class Dummy1891(x: Int) extends Base +case class Dummy1892(x: Int) extends Base +case class Dummy1893(x: Int) extends Base +case class Dummy1894(x: Int) extends Base +case class Dummy1895(x: Int) extends Base +case class Dummy1896(x: Int) extends Base +case class Dummy1897(x: Int) extends Base +case class Dummy1898(x: Int) extends Base +case class Dummy1899(x: Int) extends Base +case class Dummy1900(x: Int) extends Base +case class Dummy1901(x: Int) extends Base +case class Dummy1902(x: Int) extends Base +case class Dummy1903(x: Int) extends Base +case class Dummy1904(x: Int) extends Base +case class Dummy1905(x: Int) extends Base +case class Dummy1906(x: Int) extends Base +case class Dummy1907(x: Int) extends Base +case class Dummy1908(x: Int) extends Base +case class Dummy1909(x: Int) extends Base +case class Dummy1910(x: Int) extends Base +case class Dummy1911(x: Int) extends Base +case class Dummy1912(x: Int) extends Base +case class Dummy1913(x: Int) extends Base +case class Dummy1914(x: Int) extends Base +case class Dummy1915(x: Int) extends Base +case class Dummy1916(x: Int) extends Base +case class Dummy1917(x: Int) extends Base +case class Dummy1918(x: Int) extends Base +case class Dummy1919(x: Int) extends Base +case class Dummy1920(x: Int) extends Base +case class Dummy1921(x: Int) extends Base +case class Dummy1922(x: Int) extends Base +case class Dummy1923(x: Int) extends Base +case class Dummy1924(x: Int) extends Base +case class Dummy1925(x: Int) extends Base +case class Dummy1926(x: Int) extends Base +case class Dummy1927(x: Int) extends Base +case class Dummy1928(x: Int) extends Base +case class Dummy1929(x: Int) extends Base +case class Dummy1930(x: Int) extends Base +case class Dummy1931(x: Int) extends Base +case class Dummy1932(x: Int) extends Base +case class Dummy1933(x: Int) extends Base +case class Dummy1934(x: Int) extends Base +case class Dummy1935(x: Int) extends Base +case class Dummy1936(x: Int) extends Base +case class Dummy1937(x: Int) extends Base +case class Dummy1938(x: Int) extends Base +case class Dummy1939(x: Int) extends Base +case class Dummy1940(x: Int) extends Base +case class Dummy1941(x: Int) extends Base +case class Dummy1942(x: Int) extends Base +case class Dummy1943(x: Int) extends Base +case class Dummy1944(x: Int) extends Base +case class Dummy1945(x: Int) extends Base +case class Dummy1946(x: Int) extends Base +case class Dummy1947(x: Int) extends Base +case class Dummy1948(x: Int) extends Base +case class Dummy1949(x: Int) extends Base +case class Dummy1950(x: Int) extends Base +case class Dummy1951(x: Int) extends Base +case class Dummy1952(x: Int) extends Base +case class Dummy1953(x: Int) extends Base +case class Dummy1954(x: Int) extends Base +case class Dummy1955(x: Int) extends Base +case class Dummy1956(x: Int) extends Base +case class Dummy1957(x: Int) extends Base +case class Dummy1958(x: Int) extends Base +case class Dummy1959(x: Int) extends Base +case class Dummy1960(x: Int) extends Base +case class Dummy1961(x: Int) extends Base +case class Dummy1962(x: Int) extends Base +case class Dummy1963(x: Int) extends Base +case class Dummy1964(x: Int) extends Base +case class Dummy1965(x: Int) extends Base +case class Dummy1966(x: Int) extends Base +case class Dummy1967(x: Int) extends Base +case class Dummy1968(x: Int) extends Base +case class Dummy1969(x: Int) extends Base +case class Dummy1970(x: Int) extends Base +case class Dummy1971(x: Int) extends Base +case class Dummy1972(x: Int) extends Base +case class Dummy1973(x: Int) extends Base +case class Dummy1974(x: Int) extends Base +case class Dummy1975(x: Int) extends Base +case class Dummy1976(x: Int) extends Base +case class Dummy1977(x: Int) extends Base +case class Dummy1978(x: Int) extends Base +case class Dummy1979(x: Int) extends Base +case class Dummy1980(x: Int) extends Base +case class Dummy1981(x: Int) extends Base +case class Dummy1982(x: Int) extends Base +case class Dummy1983(x: Int) extends Base +case class Dummy1984(x: Int) extends Base +case class Dummy1985(x: Int) extends Base +case class Dummy1986(x: Int) extends Base +case class Dummy1987(x: Int) extends Base +case class Dummy1988(x: Int) extends Base +case class Dummy1989(x: Int) extends Base +case class Dummy1990(x: Int) extends Base +case class Dummy1991(x: Int) extends Base +case class Dummy1992(x: Int) extends Base +case class Dummy1993(x: Int) extends Base +case class Dummy1994(x: Int) extends Base +case class Dummy1995(x: Int) extends Base +case class Dummy1996(x: Int) extends Base +case class Dummy1997(x: Int) extends Base +case class Dummy1998(x: Int) extends Base +case class Dummy1999(x: Int) extends Base +def test(y: Base) = y match { + case Dummy0(p) => p + case Dummy1(p) => p + case Dummy2(p) => p + case Dummy3(p) => p + case Dummy4(p) => p + case Dummy5(p) => p + case Dummy6(p) => p + case Dummy7(p) => p + case Dummy8(p) => p + case Dummy9(p) => p + case Dummy10(p) => p + case Dummy11(p) => p + case Dummy12(p) => p + case Dummy13(p) => p + case Dummy14(p) => p + case Dummy15(p) => p + case Dummy16(p) => p + case Dummy17(p) => p + case Dummy18(p) => p + case Dummy19(p) => p + case Dummy20(p) => p + case Dummy21(p) => p + case Dummy22(p) => p + case Dummy23(p) => p + case Dummy24(p) => p + case Dummy25(p) => p + case Dummy26(p) => p + case Dummy27(p) => p + case Dummy28(p) => p + case Dummy29(p) => p + case Dummy30(p) => p + case Dummy31(p) => p + case Dummy32(p) => p + case Dummy33(p) => p + case Dummy34(p) => p + case Dummy35(p) => p + case Dummy36(p) => p + case Dummy37(p) => p + case Dummy38(p) => p + case Dummy39(p) => p + case Dummy40(p) => p + case Dummy41(p) => p + case Dummy42(p) => p + case Dummy43(p) => p + case Dummy44(p) => p + case Dummy45(p) => p + case Dummy46(p) => p + case Dummy47(p) => p + case Dummy48(p) => p + case Dummy49(p) => p + case Dummy50(p) => p + case Dummy51(p) => p + case Dummy52(p) => p + case Dummy53(p) => p + case Dummy54(p) => p + case Dummy55(p) => p + case Dummy56(p) => p + case Dummy57(p) => p + case Dummy58(p) => p + case Dummy59(p) => p + case Dummy60(p) => p + case Dummy61(p) => p + case Dummy62(p) => p + case Dummy63(p) => p + case Dummy64(p) => p + case Dummy65(p) => p + case Dummy66(p) => p + case Dummy67(p) => p + case Dummy68(p) => p + case Dummy69(p) => p + case Dummy70(p) => p + case Dummy71(p) => p + case Dummy72(p) => p + case Dummy73(p) => p + case Dummy74(p) => p + case Dummy75(p) => p + case Dummy76(p) => p + case Dummy77(p) => p + case Dummy78(p) => p + case Dummy79(p) => p + case Dummy80(p) => p + case Dummy81(p) => p + case Dummy82(p) => p + case Dummy83(p) => p + case Dummy84(p) => p + case Dummy85(p) => p + case Dummy86(p) => p + case Dummy87(p) => p + case Dummy88(p) => p + case Dummy89(p) => p + case Dummy90(p) => p + case Dummy91(p) => p + case Dummy92(p) => p + case Dummy93(p) => p + case Dummy94(p) => p + case Dummy95(p) => p + case Dummy96(p) => p + case Dummy97(p) => p + case Dummy98(p) => p + case Dummy99(p) => p + case Dummy100(p) => p + case Dummy101(p) => p + case Dummy102(p) => p + case Dummy103(p) => p + case Dummy104(p) => p + case Dummy105(p) => p + case Dummy106(p) => p + case Dummy107(p) => p + case Dummy108(p) => p + case Dummy109(p) => p + case Dummy110(p) => p + case Dummy111(p) => p + case Dummy112(p) => p + case Dummy113(p) => p + case Dummy114(p) => p + case Dummy115(p) => p + case Dummy116(p) => p + case Dummy117(p) => p + case Dummy118(p) => p + case Dummy119(p) => p + case Dummy120(p) => p + case Dummy121(p) => p + case Dummy122(p) => p + case Dummy123(p) => p + case Dummy124(p) => p + case Dummy125(p) => p + case Dummy126(p) => p + case Dummy127(p) => p + case Dummy128(p) => p + case Dummy129(p) => p + case Dummy130(p) => p + case Dummy131(p) => p + case Dummy132(p) => p + case Dummy133(p) => p + case Dummy134(p) => p + case Dummy135(p) => p + case Dummy136(p) => p + case Dummy137(p) => p + case Dummy138(p) => p + case Dummy139(p) => p + case Dummy140(p) => p + case Dummy141(p) => p + case Dummy142(p) => p + case Dummy143(p) => p + case Dummy144(p) => p + case Dummy145(p) => p + case Dummy146(p) => p + case Dummy147(p) => p + case Dummy148(p) => p + case Dummy149(p) => p + case Dummy150(p) => p + case Dummy151(p) => p + case Dummy152(p) => p + case Dummy153(p) => p + case Dummy154(p) => p + case Dummy155(p) => p + case Dummy156(p) => p + case Dummy157(p) => p + case Dummy158(p) => p + case Dummy159(p) => p + case Dummy160(p) => p + case Dummy161(p) => p + case Dummy162(p) => p + case Dummy163(p) => p + case Dummy164(p) => p + case Dummy165(p) => p + case Dummy166(p) => p + case Dummy167(p) => p + case Dummy168(p) => p + case Dummy169(p) => p + case Dummy170(p) => p + case Dummy171(p) => p + case Dummy172(p) => p + case Dummy173(p) => p + case Dummy174(p) => p + case Dummy175(p) => p + case Dummy176(p) => p + case Dummy177(p) => p + case Dummy178(p) => p + case Dummy179(p) => p + case Dummy180(p) => p + case Dummy181(p) => p + case Dummy182(p) => p + case Dummy183(p) => p + case Dummy184(p) => p + case Dummy185(p) => p + case Dummy186(p) => p + case Dummy187(p) => p + case Dummy188(p) => p + case Dummy189(p) => p + case Dummy190(p) => p + case Dummy191(p) => p + case Dummy192(p) => p + case Dummy193(p) => p + case Dummy194(p) => p + case Dummy195(p) => p + case Dummy196(p) => p + case Dummy197(p) => p + case Dummy198(p) => p + case Dummy199(p) => p + case Dummy200(p) => p + case Dummy201(p) => p + case Dummy202(p) => p + case Dummy203(p) => p + case Dummy204(p) => p + case Dummy205(p) => p + case Dummy206(p) => p + case Dummy207(p) => p + case Dummy208(p) => p + case Dummy209(p) => p + case Dummy210(p) => p + case Dummy211(p) => p + case Dummy212(p) => p + case Dummy213(p) => p + case Dummy214(p) => p + case Dummy215(p) => p + case Dummy216(p) => p + case Dummy217(p) => p + case Dummy218(p) => p + case Dummy219(p) => p + case Dummy220(p) => p + case Dummy221(p) => p + case Dummy222(p) => p + case Dummy223(p) => p + case Dummy224(p) => p + case Dummy225(p) => p + case Dummy226(p) => p + case Dummy227(p) => p + case Dummy228(p) => p + case Dummy229(p) => p + case Dummy230(p) => p + case Dummy231(p) => p + case Dummy232(p) => p + case Dummy233(p) => p + case Dummy234(p) => p + case Dummy235(p) => p + case Dummy236(p) => p + case Dummy237(p) => p + case Dummy238(p) => p + case Dummy239(p) => p + case Dummy240(p) => p + case Dummy241(p) => p + case Dummy242(p) => p + case Dummy243(p) => p + case Dummy244(p) => p + case Dummy245(p) => p + case Dummy246(p) => p + case Dummy247(p) => p + case Dummy248(p) => p + case Dummy249(p) => p + case Dummy250(p) => p + case Dummy251(p) => p + case Dummy252(p) => p + case Dummy253(p) => p + case Dummy254(p) => p + case Dummy255(p) => p + case Dummy256(p) => p + case Dummy257(p) => p + case Dummy258(p) => p + case Dummy259(p) => p + case Dummy260(p) => p + case Dummy261(p) => p + case Dummy262(p) => p + case Dummy263(p) => p + case Dummy264(p) => p + case Dummy265(p) => p + case Dummy266(p) => p + case Dummy267(p) => p + case Dummy268(p) => p + case Dummy269(p) => p + case Dummy270(p) => p + case Dummy271(p) => p + case Dummy272(p) => p + case Dummy273(p) => p + case Dummy274(p) => p + case Dummy275(p) => p + case Dummy276(p) => p + case Dummy277(p) => p + case Dummy278(p) => p + case Dummy279(p) => p + case Dummy280(p) => p + case Dummy281(p) => p + case Dummy282(p) => p + case Dummy283(p) => p + case Dummy284(p) => p + case Dummy285(p) => p + case Dummy286(p) => p + case Dummy287(p) => p + case Dummy288(p) => p + case Dummy289(p) => p + case Dummy290(p) => p + case Dummy291(p) => p + case Dummy292(p) => p + case Dummy293(p) => p + case Dummy294(p) => p + case Dummy295(p) => p + case Dummy296(p) => p + case Dummy297(p) => p + case Dummy298(p) => p + case Dummy299(p) => p + case Dummy300(p) => p + case Dummy301(p) => p + case Dummy302(p) => p + case Dummy303(p) => p + case Dummy304(p) => p + case Dummy305(p) => p + case Dummy306(p) => p + case Dummy307(p) => p + case Dummy308(p) => p + case Dummy309(p) => p + case Dummy310(p) => p + case Dummy311(p) => p + case Dummy312(p) => p + case Dummy313(p) => p + case Dummy314(p) => p + case Dummy315(p) => p + case Dummy316(p) => p + case Dummy317(p) => p + case Dummy318(p) => p + case Dummy319(p) => p + case Dummy320(p) => p + case Dummy321(p) => p + case Dummy322(p) => p + case Dummy323(p) => p + case Dummy324(p) => p + case Dummy325(p) => p + case Dummy326(p) => p + case Dummy327(p) => p + case Dummy328(p) => p + case Dummy329(p) => p + case Dummy330(p) => p + case Dummy331(p) => p + case Dummy332(p) => p + case Dummy333(p) => p + case Dummy334(p) => p + case Dummy335(p) => p + case Dummy336(p) => p + case Dummy337(p) => p + case Dummy338(p) => p + case Dummy339(p) => p + case Dummy340(p) => p + case Dummy341(p) => p + case Dummy342(p) => p + case Dummy343(p) => p + case Dummy344(p) => p + case Dummy345(p) => p + case Dummy346(p) => p + case Dummy347(p) => p + case Dummy348(p) => p + case Dummy349(p) => p + case Dummy350(p) => p + case Dummy351(p) => p + case Dummy352(p) => p + case Dummy353(p) => p + case Dummy354(p) => p + case Dummy355(p) => p + case Dummy356(p) => p + case Dummy357(p) => p + case Dummy358(p) => p + case Dummy359(p) => p + case Dummy360(p) => p + case Dummy361(p) => p + case Dummy362(p) => p + case Dummy363(p) => p + case Dummy364(p) => p + case Dummy365(p) => p + case Dummy366(p) => p + case Dummy367(p) => p + case Dummy368(p) => p + case Dummy369(p) => p + case Dummy370(p) => p + case Dummy371(p) => p + case Dummy372(p) => p + case Dummy373(p) => p + case Dummy374(p) => p + case Dummy375(p) => p + case Dummy376(p) => p + case Dummy377(p) => p + case Dummy378(p) => p + case Dummy379(p) => p + case Dummy380(p) => p + case Dummy381(p) => p + case Dummy382(p) => p + case Dummy383(p) => p + case Dummy384(p) => p + case Dummy385(p) => p + case Dummy386(p) => p + case Dummy387(p) => p + case Dummy388(p) => p + case Dummy389(p) => p + case Dummy390(p) => p + case Dummy391(p) => p + case Dummy392(p) => p + case Dummy393(p) => p + case Dummy394(p) => p + case Dummy395(p) => p + case Dummy396(p) => p + case Dummy397(p) => p + case Dummy398(p) => p + case Dummy399(p) => p + case Dummy400(p) => p + case Dummy401(p) => p + case Dummy402(p) => p + case Dummy403(p) => p + case Dummy404(p) => p + case Dummy405(p) => p + case Dummy406(p) => p + case Dummy407(p) => p + case Dummy408(p) => p + case Dummy409(p) => p + case Dummy410(p) => p + case Dummy411(p) => p + case Dummy412(p) => p + case Dummy413(p) => p + case Dummy414(p) => p + case Dummy415(p) => p + case Dummy416(p) => p + case Dummy417(p) => p + case Dummy418(p) => p + case Dummy419(p) => p + case Dummy420(p) => p + case Dummy421(p) => p + case Dummy422(p) => p + case Dummy423(p) => p + case Dummy424(p) => p + case Dummy425(p) => p + case Dummy426(p) => p + case Dummy427(p) => p + case Dummy428(p) => p + case Dummy429(p) => p + case Dummy430(p) => p + case Dummy431(p) => p + case Dummy432(p) => p + case Dummy433(p) => p + case Dummy434(p) => p + case Dummy435(p) => p + case Dummy436(p) => p + case Dummy437(p) => p + case Dummy438(p) => p + case Dummy439(p) => p + case Dummy440(p) => p + case Dummy441(p) => p + case Dummy442(p) => p + case Dummy443(p) => p + case Dummy444(p) => p + case Dummy445(p) => p + case Dummy446(p) => p + case Dummy447(p) => p + case Dummy448(p) => p + case Dummy449(p) => p + case Dummy450(p) => p + case Dummy451(p) => p + case Dummy452(p) => p + case Dummy453(p) => p + case Dummy454(p) => p + case Dummy455(p) => p + case Dummy456(p) => p + case Dummy457(p) => p + case Dummy458(p) => p + case Dummy459(p) => p + case Dummy460(p) => p + case Dummy461(p) => p + case Dummy462(p) => p + case Dummy463(p) => p + case Dummy464(p) => p + case Dummy465(p) => p + case Dummy466(p) => p + case Dummy467(p) => p + case Dummy468(p) => p + case Dummy469(p) => p + case Dummy470(p) => p + case Dummy471(p) => p + case Dummy472(p) => p + case Dummy473(p) => p + case Dummy474(p) => p + case Dummy475(p) => p + case Dummy476(p) => p + case Dummy477(p) => p + case Dummy478(p) => p + case Dummy479(p) => p + case Dummy480(p) => p + case Dummy481(p) => p + case Dummy482(p) => p + case Dummy483(p) => p + case Dummy484(p) => p + case Dummy485(p) => p + case Dummy486(p) => p + case Dummy487(p) => p + case Dummy488(p) => p + case Dummy489(p) => p + case Dummy490(p) => p + case Dummy491(p) => p + case Dummy492(p) => p + case Dummy493(p) => p + case Dummy494(p) => p + case Dummy495(p) => p + case Dummy496(p) => p + case Dummy497(p) => p + case Dummy498(p) => p + case Dummy499(p) => p + case Dummy500(p) => p + case Dummy501(p) => p + case Dummy502(p) => p + case Dummy503(p) => p + case Dummy504(p) => p + case Dummy505(p) => p + case Dummy506(p) => p + case Dummy507(p) => p + case Dummy508(p) => p + case Dummy509(p) => p + case Dummy510(p) => p + case Dummy511(p) => p + case Dummy512(p) => p + case Dummy513(p) => p + case Dummy514(p) => p + case Dummy515(p) => p + case Dummy516(p) => p + case Dummy517(p) => p + case Dummy518(p) => p + case Dummy519(p) => p + case Dummy520(p) => p + case Dummy521(p) => p + case Dummy522(p) => p + case Dummy523(p) => p + case Dummy524(p) => p + case Dummy525(p) => p + case Dummy526(p) => p + case Dummy527(p) => p + case Dummy528(p) => p + case Dummy529(p) => p + case Dummy530(p) => p + case Dummy531(p) => p + case Dummy532(p) => p + case Dummy533(p) => p + case Dummy534(p) => p + case Dummy535(p) => p + case Dummy536(p) => p + case Dummy537(p) => p + case Dummy538(p) => p + case Dummy539(p) => p + case Dummy540(p) => p + case Dummy541(p) => p + case Dummy542(p) => p + case Dummy543(p) => p + case Dummy544(p) => p + case Dummy545(p) => p + case Dummy546(p) => p + case Dummy547(p) => p + case Dummy548(p) => p + case Dummy549(p) => p + case Dummy550(p) => p + case Dummy551(p) => p + case Dummy552(p) => p + case Dummy553(p) => p + case Dummy554(p) => p + case Dummy555(p) => p + case Dummy556(p) => p + case Dummy557(p) => p + case Dummy558(p) => p + case Dummy559(p) => p + case Dummy560(p) => p + case Dummy561(p) => p + case Dummy562(p) => p + case Dummy563(p) => p + case Dummy564(p) => p + case Dummy565(p) => p + case Dummy566(p) => p + case Dummy567(p) => p + case Dummy568(p) => p + case Dummy569(p) => p + case Dummy570(p) => p + case Dummy571(p) => p + case Dummy572(p) => p + case Dummy573(p) => p + case Dummy574(p) => p + case Dummy575(p) => p + case Dummy576(p) => p + case Dummy577(p) => p + case Dummy578(p) => p + case Dummy579(p) => p + case Dummy580(p) => p + case Dummy581(p) => p + case Dummy582(p) => p + case Dummy583(p) => p + case Dummy584(p) => p + case Dummy585(p) => p + case Dummy586(p) => p + case Dummy587(p) => p + case Dummy588(p) => p + case Dummy589(p) => p + case Dummy590(p) => p + case Dummy591(p) => p + case Dummy592(p) => p + case Dummy593(p) => p + case Dummy594(p) => p + case Dummy595(p) => p + case Dummy596(p) => p + case Dummy597(p) => p + case Dummy598(p) => p + case Dummy599(p) => p + case Dummy600(p) => p + case Dummy601(p) => p + case Dummy602(p) => p + case Dummy603(p) => p + case Dummy604(p) => p + case Dummy605(p) => p + case Dummy606(p) => p + case Dummy607(p) => p + case Dummy608(p) => p + case Dummy609(p) => p + case Dummy610(p) => p + case Dummy611(p) => p + case Dummy612(p) => p + case Dummy613(p) => p + case Dummy614(p) => p + case Dummy615(p) => p + case Dummy616(p) => p + case Dummy617(p) => p + case Dummy618(p) => p + case Dummy619(p) => p + case Dummy620(p) => p + case Dummy621(p) => p + case Dummy622(p) => p + case Dummy623(p) => p + case Dummy624(p) => p + case Dummy625(p) => p + case Dummy626(p) => p + case Dummy627(p) => p + case Dummy628(p) => p + case Dummy629(p) => p + case Dummy630(p) => p + case Dummy631(p) => p + case Dummy632(p) => p + case Dummy633(p) => p + case Dummy634(p) => p + case Dummy635(p) => p + case Dummy636(p) => p + case Dummy637(p) => p + case Dummy638(p) => p + case Dummy639(p) => p + case Dummy640(p) => p + case Dummy641(p) => p + case Dummy642(p) => p + case Dummy643(p) => p + case Dummy644(p) => p + case Dummy645(p) => p + case Dummy646(p) => p + case Dummy647(p) => p + case Dummy648(p) => p + case Dummy649(p) => p + case Dummy650(p) => p + case Dummy651(p) => p + case Dummy652(p) => p + case Dummy653(p) => p + case Dummy654(p) => p + case Dummy655(p) => p + case Dummy656(p) => p + case Dummy657(p) => p + case Dummy658(p) => p + case Dummy659(p) => p + case Dummy660(p) => p + case Dummy661(p) => p + case Dummy662(p) => p + case Dummy663(p) => p + case Dummy664(p) => p + case Dummy665(p) => p + case Dummy666(p) => p + case Dummy667(p) => p + case Dummy668(p) => p + case Dummy669(p) => p + case Dummy670(p) => p + case Dummy671(p) => p + case Dummy672(p) => p + case Dummy673(p) => p + case Dummy674(p) => p + case Dummy675(p) => p + case Dummy676(p) => p + case Dummy677(p) => p + case Dummy678(p) => p + case Dummy679(p) => p + case Dummy680(p) => p + case Dummy681(p) => p + case Dummy682(p) => p + case Dummy683(p) => p + case Dummy684(p) => p + case Dummy685(p) => p + case Dummy686(p) => p + case Dummy687(p) => p + case Dummy688(p) => p + case Dummy689(p) => p + case Dummy690(p) => p + case Dummy691(p) => p + case Dummy692(p) => p + case Dummy693(p) => p + case Dummy694(p) => p + case Dummy695(p) => p + case Dummy696(p) => p + case Dummy697(p) => p + case Dummy698(p) => p + case Dummy699(p) => p + case Dummy700(p) => p + case Dummy701(p) => p + case Dummy702(p) => p + case Dummy703(p) => p + case Dummy704(p) => p + case Dummy705(p) => p + case Dummy706(p) => p + case Dummy707(p) => p + case Dummy708(p) => p + case Dummy709(p) => p + case Dummy710(p) => p + case Dummy711(p) => p + case Dummy712(p) => p + case Dummy713(p) => p + case Dummy714(p) => p + case Dummy715(p) => p + case Dummy716(p) => p + case Dummy717(p) => p + case Dummy718(p) => p + case Dummy719(p) => p + case Dummy720(p) => p + case Dummy721(p) => p + case Dummy722(p) => p + case Dummy723(p) => p + case Dummy724(p) => p + case Dummy725(p) => p + case Dummy726(p) => p + case Dummy727(p) => p + case Dummy728(p) => p + case Dummy729(p) => p + case Dummy730(p) => p + case Dummy731(p) => p + case Dummy732(p) => p + case Dummy733(p) => p + case Dummy734(p) => p + case Dummy735(p) => p + case Dummy736(p) => p + case Dummy737(p) => p + case Dummy738(p) => p + case Dummy739(p) => p + case Dummy740(p) => p + case Dummy741(p) => p + case Dummy742(p) => p + case Dummy743(p) => p + case Dummy744(p) => p + case Dummy745(p) => p + case Dummy746(p) => p + case Dummy747(p) => p + case Dummy748(p) => p + case Dummy749(p) => p + case Dummy750(p) => p + case Dummy751(p) => p + case Dummy752(p) => p + case Dummy753(p) => p + case Dummy754(p) => p + case Dummy755(p) => p + case Dummy756(p) => p + case Dummy757(p) => p + case Dummy758(p) => p + case Dummy759(p) => p + case Dummy760(p) => p + case Dummy761(p) => p + case Dummy762(p) => p + case Dummy763(p) => p + case Dummy764(p) => p + case Dummy765(p) => p + case Dummy766(p) => p + case Dummy767(p) => p + case Dummy768(p) => p + case Dummy769(p) => p + case Dummy770(p) => p + case Dummy771(p) => p + case Dummy772(p) => p + case Dummy773(p) => p + case Dummy774(p) => p + case Dummy775(p) => p + case Dummy776(p) => p + case Dummy777(p) => p + case Dummy778(p) => p + case Dummy779(p) => p + case Dummy780(p) => p + case Dummy781(p) => p + case Dummy782(p) => p + case Dummy783(p) => p + case Dummy784(p) => p + case Dummy785(p) => p + case Dummy786(p) => p + case Dummy787(p) => p + case Dummy788(p) => p + case Dummy789(p) => p + case Dummy790(p) => p + case Dummy791(p) => p + case Dummy792(p) => p + case Dummy793(p) => p + case Dummy794(p) => p + case Dummy795(p) => p + case Dummy796(p) => p + case Dummy797(p) => p + case Dummy798(p) => p + case Dummy799(p) => p + case Dummy800(p) => p + case Dummy801(p) => p + case Dummy802(p) => p + case Dummy803(p) => p + case Dummy804(p) => p + case Dummy805(p) => p + case Dummy806(p) => p + case Dummy807(p) => p + case Dummy808(p) => p + case Dummy809(p) => p + case Dummy810(p) => p + case Dummy811(p) => p + case Dummy812(p) => p + case Dummy813(p) => p + case Dummy814(p) => p + case Dummy815(p) => p + case Dummy816(p) => p + case Dummy817(p) => p + case Dummy818(p) => p + case Dummy819(p) => p + case Dummy820(p) => p + case Dummy821(p) => p + case Dummy822(p) => p + case Dummy823(p) => p + case Dummy824(p) => p + case Dummy825(p) => p + case Dummy826(p) => p + case Dummy827(p) => p + case Dummy828(p) => p + case Dummy829(p) => p + case Dummy830(p) => p + case Dummy831(p) => p + case Dummy832(p) => p + case Dummy833(p) => p + case Dummy834(p) => p + case Dummy835(p) => p + case Dummy836(p) => p + case Dummy837(p) => p + case Dummy838(p) => p + case Dummy839(p) => p + case Dummy840(p) => p + case Dummy841(p) => p + case Dummy842(p) => p + case Dummy843(p) => p + case Dummy844(p) => p + case Dummy845(p) => p + case Dummy846(p) => p + case Dummy847(p) => p + case Dummy848(p) => p + case Dummy849(p) => p + case Dummy850(p) => p + case Dummy851(p) => p + case Dummy852(p) => p + case Dummy853(p) => p + case Dummy854(p) => p + case Dummy855(p) => p + case Dummy856(p) => p + case Dummy857(p) => p + case Dummy858(p) => p + case Dummy859(p) => p + case Dummy860(p) => p + case Dummy861(p) => p + case Dummy862(p) => p + case Dummy863(p) => p + case Dummy864(p) => p + case Dummy865(p) => p + case Dummy866(p) => p + case Dummy867(p) => p + case Dummy868(p) => p + case Dummy869(p) => p + case Dummy870(p) => p + case Dummy871(p) => p + case Dummy872(p) => p + case Dummy873(p) => p + case Dummy874(p) => p + case Dummy875(p) => p + case Dummy876(p) => p + case Dummy877(p) => p + case Dummy878(p) => p + case Dummy879(p) => p + case Dummy880(p) => p + case Dummy881(p) => p + case Dummy882(p) => p + case Dummy883(p) => p + case Dummy884(p) => p + case Dummy885(p) => p + case Dummy886(p) => p + case Dummy887(p) => p + case Dummy888(p) => p + case Dummy889(p) => p + case Dummy890(p) => p + case Dummy891(p) => p + case Dummy892(p) => p + case Dummy893(p) => p + case Dummy894(p) => p + case Dummy895(p) => p + case Dummy896(p) => p + case Dummy897(p) => p + case Dummy898(p) => p + case Dummy899(p) => p + case Dummy900(p) => p + case Dummy901(p) => p + case Dummy902(p) => p + case Dummy903(p) => p + case Dummy904(p) => p + case Dummy905(p) => p + case Dummy906(p) => p + case Dummy907(p) => p + case Dummy908(p) => p + case Dummy909(p) => p + case Dummy910(p) => p + case Dummy911(p) => p + case Dummy912(p) => p + case Dummy913(p) => p + case Dummy914(p) => p + case Dummy915(p) => p + case Dummy916(p) => p + case Dummy917(p) => p + case Dummy918(p) => p + case Dummy919(p) => p + case Dummy920(p) => p + case Dummy921(p) => p + case Dummy922(p) => p + case Dummy923(p) => p + case Dummy924(p) => p + case Dummy925(p) => p + case Dummy926(p) => p + case Dummy927(p) => p + case Dummy928(p) => p + case Dummy929(p) => p + case Dummy930(p) => p + case Dummy931(p) => p + case Dummy932(p) => p + case Dummy933(p) => p + case Dummy934(p) => p + case Dummy935(p) => p + case Dummy936(p) => p + case Dummy937(p) => p + case Dummy938(p) => p + case Dummy939(p) => p + case Dummy940(p) => p + case Dummy941(p) => p + case Dummy942(p) => p + case Dummy943(p) => p + case Dummy944(p) => p + case Dummy945(p) => p + case Dummy946(p) => p + case Dummy947(p) => p + case Dummy948(p) => p + case Dummy949(p) => p + case Dummy950(p) => p + case Dummy951(p) => p + case Dummy952(p) => p + case Dummy953(p) => p + case Dummy954(p) => p + case Dummy955(p) => p + case Dummy956(p) => p + case Dummy957(p) => p + case Dummy958(p) => p + case Dummy959(p) => p + case Dummy960(p) => p + case Dummy961(p) => p + case Dummy962(p) => p + case Dummy963(p) => p + case Dummy964(p) => p + case Dummy965(p) => p + case Dummy966(p) => p + case Dummy967(p) => p + case Dummy968(p) => p + case Dummy969(p) => p + case Dummy970(p) => p + case Dummy971(p) => p + case Dummy972(p) => p + case Dummy973(p) => p + case Dummy974(p) => p + case Dummy975(p) => p + case Dummy976(p) => p + case Dummy977(p) => p + case Dummy978(p) => p + case Dummy979(p) => p + case Dummy980(p) => p + case Dummy981(p) => p + case Dummy982(p) => p + case Dummy983(p) => p + case Dummy984(p) => p + case Dummy985(p) => p + case Dummy986(p) => p + case Dummy987(p) => p + case Dummy988(p) => p + case Dummy989(p) => p + case Dummy990(p) => p + case Dummy991(p) => p + case Dummy992(p) => p + case Dummy993(p) => p + case Dummy994(p) => p + case Dummy995(p) => p + case Dummy996(p) => p + case Dummy997(p) => p + case Dummy998(p) => p + case Dummy999(p) => p + case Dummy1000(p) => p + case Dummy1001(p) => p + case Dummy1002(p) => p + case Dummy1003(p) => p + case Dummy1004(p) => p + case Dummy1005(p) => p + case Dummy1006(p) => p + case Dummy1007(p) => p + case Dummy1008(p) => p + case Dummy1009(p) => p + case Dummy1010(p) => p + case Dummy1011(p) => p + case Dummy1012(p) => p + case Dummy1013(p) => p + case Dummy1014(p) => p + case Dummy1015(p) => p + case Dummy1016(p) => p + case Dummy1017(p) => p + case Dummy1018(p) => p + case Dummy1019(p) => p + case Dummy1020(p) => p + case Dummy1021(p) => p + case Dummy1022(p) => p + case Dummy1023(p) => p + case Dummy1024(p) => p + case Dummy1025(p) => p + case Dummy1026(p) => p + case Dummy1027(p) => p + case Dummy1028(p) => p + case Dummy1029(p) => p + case Dummy1030(p) => p + case Dummy1031(p) => p + case Dummy1032(p) => p + case Dummy1033(p) => p + case Dummy1034(p) => p + case Dummy1035(p) => p + case Dummy1036(p) => p + case Dummy1037(p) => p + case Dummy1038(p) => p + case Dummy1039(p) => p + case Dummy1040(p) => p + case Dummy1041(p) => p + case Dummy1042(p) => p + case Dummy1043(p) => p + case Dummy1044(p) => p + case Dummy1045(p) => p + case Dummy1046(p) => p + case Dummy1047(p) => p + case Dummy1048(p) => p + case Dummy1049(p) => p + case Dummy1050(p) => p + case Dummy1051(p) => p + case Dummy1052(p) => p + case Dummy1053(p) => p + case Dummy1054(p) => p + case Dummy1055(p) => p + case Dummy1056(p) => p + case Dummy1057(p) => p + case Dummy1058(p) => p + case Dummy1059(p) => p + case Dummy1060(p) => p + case Dummy1061(p) => p + case Dummy1062(p) => p + case Dummy1063(p) => p + case Dummy1064(p) => p + case Dummy1065(p) => p + case Dummy1066(p) => p + case Dummy1067(p) => p + case Dummy1068(p) => p + case Dummy1069(p) => p + case Dummy1070(p) => p + case Dummy1071(p) => p + case Dummy1072(p) => p + case Dummy1073(p) => p + case Dummy1074(p) => p + case Dummy1075(p) => p + case Dummy1076(p) => p + case Dummy1077(p) => p + case Dummy1078(p) => p + case Dummy1079(p) => p + case Dummy1080(p) => p + case Dummy1081(p) => p + case Dummy1082(p) => p + case Dummy1083(p) => p + case Dummy1084(p) => p + case Dummy1085(p) => p + case Dummy1086(p) => p + case Dummy1087(p) => p + case Dummy1088(p) => p + case Dummy1089(p) => p + case Dummy1090(p) => p + case Dummy1091(p) => p + case Dummy1092(p) => p + case Dummy1093(p) => p + case Dummy1094(p) => p + case Dummy1095(p) => p + case Dummy1096(p) => p + case Dummy1097(p) => p + case Dummy1098(p) => p + case Dummy1099(p) => p + case Dummy1100(p) => p + case Dummy1101(p) => p + case Dummy1102(p) => p + case Dummy1103(p) => p + case Dummy1104(p) => p + case Dummy1105(p) => p + case Dummy1106(p) => p + case Dummy1107(p) => p + case Dummy1108(p) => p + case Dummy1109(p) => p + case Dummy1110(p) => p + case Dummy1111(p) => p + case Dummy1112(p) => p + case Dummy1113(p) => p + case Dummy1114(p) => p + case Dummy1115(p) => p + case Dummy1116(p) => p + case Dummy1117(p) => p + case Dummy1118(p) => p + case Dummy1119(p) => p + case Dummy1120(p) => p + case Dummy1121(p) => p + case Dummy1122(p) => p + case Dummy1123(p) => p + case Dummy1124(p) => p + case Dummy1125(p) => p + case Dummy1126(p) => p + case Dummy1127(p) => p + case Dummy1128(p) => p + case Dummy1129(p) => p + case Dummy1130(p) => p + case Dummy1131(p) => p + case Dummy1132(p) => p + case Dummy1133(p) => p + case Dummy1134(p) => p + case Dummy1135(p) => p + case Dummy1136(p) => p + case Dummy1137(p) => p + case Dummy1138(p) => p + case Dummy1139(p) => p + case Dummy1140(p) => p + case Dummy1141(p) => p + case Dummy1142(p) => p + case Dummy1143(p) => p + case Dummy1144(p) => p + case Dummy1145(p) => p + case Dummy1146(p) => p + case Dummy1147(p) => p + case Dummy1148(p) => p + case Dummy1149(p) => p + case Dummy1150(p) => p + case Dummy1151(p) => p + case Dummy1152(p) => p + case Dummy1153(p) => p + case Dummy1154(p) => p + case Dummy1155(p) => p + case Dummy1156(p) => p + case Dummy1157(p) => p + case Dummy1158(p) => p + case Dummy1159(p) => p + case Dummy1160(p) => p + case Dummy1161(p) => p + case Dummy1162(p) => p + case Dummy1163(p) => p + case Dummy1164(p) => p + case Dummy1165(p) => p + case Dummy1166(p) => p + case Dummy1167(p) => p + case Dummy1168(p) => p + case Dummy1169(p) => p + case Dummy1170(p) => p + case Dummy1171(p) => p + case Dummy1172(p) => p + case Dummy1173(p) => p + case Dummy1174(p) => p + case Dummy1175(p) => p + case Dummy1176(p) => p + case Dummy1177(p) => p + case Dummy1178(p) => p + case Dummy1179(p) => p + case Dummy1180(p) => p + case Dummy1181(p) => p + case Dummy1182(p) => p + case Dummy1183(p) => p + case Dummy1184(p) => p + case Dummy1185(p) => p + case Dummy1186(p) => p + case Dummy1187(p) => p + case Dummy1188(p) => p + case Dummy1189(p) => p + case Dummy1190(p) => p + case Dummy1191(p) => p + case Dummy1192(p) => p + case Dummy1193(p) => p + case Dummy1194(p) => p + case Dummy1195(p) => p + case Dummy1196(p) => p + case Dummy1197(p) => p + case Dummy1198(p) => p + case Dummy1199(p) => p + case Dummy1200(p) => p + case Dummy1201(p) => p + case Dummy1202(p) => p + case Dummy1203(p) => p + case Dummy1204(p) => p + case Dummy1205(p) => p + case Dummy1206(p) => p + case Dummy1207(p) => p + case Dummy1208(p) => p + case Dummy1209(p) => p + case Dummy1210(p) => p + case Dummy1211(p) => p + case Dummy1212(p) => p + case Dummy1213(p) => p + case Dummy1214(p) => p + case Dummy1215(p) => p + case Dummy1216(p) => p + case Dummy1217(p) => p + case Dummy1218(p) => p + case Dummy1219(p) => p + case Dummy1220(p) => p + case Dummy1221(p) => p + case Dummy1222(p) => p + case Dummy1223(p) => p + case Dummy1224(p) => p + case Dummy1225(p) => p + case Dummy1226(p) => p + case Dummy1227(p) => p + case Dummy1228(p) => p + case Dummy1229(p) => p + case Dummy1230(p) => p + case Dummy1231(p) => p + case Dummy1232(p) => p + case Dummy1233(p) => p + case Dummy1234(p) => p + case Dummy1235(p) => p + case Dummy1236(p) => p + case Dummy1237(p) => p + case Dummy1238(p) => p + case Dummy1239(p) => p + case Dummy1240(p) => p + case Dummy1241(p) => p + case Dummy1242(p) => p + case Dummy1243(p) => p + case Dummy1244(p) => p + case Dummy1245(p) => p + case Dummy1246(p) => p + case Dummy1247(p) => p + case Dummy1248(p) => p + case Dummy1249(p) => p + case Dummy1250(p) => p + case Dummy1251(p) => p + case Dummy1252(p) => p + case Dummy1253(p) => p + case Dummy1254(p) => p + case Dummy1255(p) => p + case Dummy1256(p) => p + case Dummy1257(p) => p + case Dummy1258(p) => p + case Dummy1259(p) => p + case Dummy1260(p) => p + case Dummy1261(p) => p + case Dummy1262(p) => p + case Dummy1263(p) => p + case Dummy1264(p) => p + case Dummy1265(p) => p + case Dummy1266(p) => p + case Dummy1267(p) => p + case Dummy1268(p) => p + case Dummy1269(p) => p + case Dummy1270(p) => p + case Dummy1271(p) => p + case Dummy1272(p) => p + case Dummy1273(p) => p + case Dummy1274(p) => p + case Dummy1275(p) => p + case Dummy1276(p) => p + case Dummy1277(p) => p + case Dummy1278(p) => p + case Dummy1279(p) => p + case Dummy1280(p) => p + case Dummy1281(p) => p + case Dummy1282(p) => p + case Dummy1283(p) => p + case Dummy1284(p) => p + case Dummy1285(p) => p + case Dummy1286(p) => p + case Dummy1287(p) => p + case Dummy1288(p) => p + case Dummy1289(p) => p + case Dummy1290(p) => p + case Dummy1291(p) => p + case Dummy1292(p) => p + case Dummy1293(p) => p + case Dummy1294(p) => p + case Dummy1295(p) => p + case Dummy1296(p) => p + case Dummy1297(p) => p + case Dummy1298(p) => p + case Dummy1299(p) => p + case Dummy1300(p) => p + case Dummy1301(p) => p + case Dummy1302(p) => p + case Dummy1303(p) => p + case Dummy1304(p) => p + case Dummy1305(p) => p + case Dummy1306(p) => p + case Dummy1307(p) => p + case Dummy1308(p) => p + case Dummy1309(p) => p + case Dummy1310(p) => p + case Dummy1311(p) => p + case Dummy1312(p) => p + case Dummy1313(p) => p + case Dummy1314(p) => p + case Dummy1315(p) => p + case Dummy1316(p) => p + case Dummy1317(p) => p + case Dummy1318(p) => p + case Dummy1319(p) => p + case Dummy1320(p) => p + case Dummy1321(p) => p + case Dummy1322(p) => p + case Dummy1323(p) => p + case Dummy1324(p) => p + case Dummy1325(p) => p + case Dummy1326(p) => p + case Dummy1327(p) => p + case Dummy1328(p) => p + case Dummy1329(p) => p + case Dummy1330(p) => p + case Dummy1331(p) => p + case Dummy1332(p) => p + case Dummy1333(p) => p + case Dummy1334(p) => p + case Dummy1335(p) => p + case Dummy1336(p) => p + case Dummy1337(p) => p + case Dummy1338(p) => p + case Dummy1339(p) => p + case Dummy1340(p) => p + case Dummy1341(p) => p + case Dummy1342(p) => p + case Dummy1343(p) => p + case Dummy1344(p) => p + case Dummy1345(p) => p + case Dummy1346(p) => p + case Dummy1347(p) => p + case Dummy1348(p) => p + case Dummy1349(p) => p + case Dummy1350(p) => p + case Dummy1351(p) => p + case Dummy1352(p) => p + case Dummy1353(p) => p + case Dummy1354(p) => p + case Dummy1355(p) => p + case Dummy1356(p) => p + case Dummy1357(p) => p + case Dummy1358(p) => p + case Dummy1359(p) => p + case Dummy1360(p) => p + case Dummy1361(p) => p + case Dummy1362(p) => p + case Dummy1363(p) => p + case Dummy1364(p) => p + case Dummy1365(p) => p + case Dummy1366(p) => p + case Dummy1367(p) => p + case Dummy1368(p) => p + case Dummy1369(p) => p + case Dummy1370(p) => p + case Dummy1371(p) => p + case Dummy1372(p) => p + case Dummy1373(p) => p + case Dummy1374(p) => p + case Dummy1375(p) => p + case Dummy1376(p) => p + case Dummy1377(p) => p + case Dummy1378(p) => p + case Dummy1379(p) => p + case Dummy1380(p) => p + case Dummy1381(p) => p + case Dummy1382(p) => p + case Dummy1383(p) => p + case Dummy1384(p) => p + case Dummy1385(p) => p + case Dummy1386(p) => p + case Dummy1387(p) => p + case Dummy1388(p) => p + case Dummy1389(p) => p + case Dummy1390(p) => p + case Dummy1391(p) => p + case Dummy1392(p) => p + case Dummy1393(p) => p + case Dummy1394(p) => p + case Dummy1395(p) => p + case Dummy1396(p) => p + case Dummy1397(p) => p + case Dummy1398(p) => p + case Dummy1399(p) => p + case Dummy1400(p) => p + case Dummy1401(p) => p + case Dummy1402(p) => p + case Dummy1403(p) => p + case Dummy1404(p) => p + case Dummy1405(p) => p + case Dummy1406(p) => p + case Dummy1407(p) => p + case Dummy1408(p) => p + case Dummy1409(p) => p + case Dummy1410(p) => p + case Dummy1411(p) => p + case Dummy1412(p) => p + case Dummy1413(p) => p + case Dummy1414(p) => p + case Dummy1415(p) => p + case Dummy1416(p) => p + case Dummy1417(p) => p + case Dummy1418(p) => p + case Dummy1419(p) => p + case Dummy1420(p) => p + case Dummy1421(p) => p + case Dummy1422(p) => p + case Dummy1423(p) => p + case Dummy1424(p) => p + case Dummy1425(p) => p + case Dummy1426(p) => p + case Dummy1427(p) => p + case Dummy1428(p) => p + case Dummy1429(p) => p + case Dummy1430(p) => p + case Dummy1431(p) => p + case Dummy1432(p) => p + case Dummy1433(p) => p + case Dummy1434(p) => p + case Dummy1435(p) => p + case Dummy1436(p) => p + case Dummy1437(p) => p + case Dummy1438(p) => p + case Dummy1439(p) => p + case Dummy1440(p) => p + case Dummy1441(p) => p + case Dummy1442(p) => p + case Dummy1443(p) => p + case Dummy1444(p) => p + case Dummy1445(p) => p + case Dummy1446(p) => p + case Dummy1447(p) => p + case Dummy1448(p) => p + case Dummy1449(p) => p + case Dummy1450(p) => p + case Dummy1451(p) => p + case Dummy1452(p) => p + case Dummy1453(p) => p + case Dummy1454(p) => p + case Dummy1455(p) => p + case Dummy1456(p) => p + case Dummy1457(p) => p + case Dummy1458(p) => p + case Dummy1459(p) => p + case Dummy1460(p) => p + case Dummy1461(p) => p + case Dummy1462(p) => p + case Dummy1463(p) => p + case Dummy1464(p) => p + case Dummy1465(p) => p + case Dummy1466(p) => p + case Dummy1467(p) => p + case Dummy1468(p) => p + case Dummy1469(p) => p + case Dummy1470(p) => p + case Dummy1471(p) => p + case Dummy1472(p) => p + case Dummy1473(p) => p + case Dummy1474(p) => p + case Dummy1475(p) => p + case Dummy1476(p) => p + case Dummy1477(p) => p + case Dummy1478(p) => p + case Dummy1479(p) => p + case Dummy1480(p) => p + case Dummy1481(p) => p + case Dummy1482(p) => p + case Dummy1483(p) => p + case Dummy1484(p) => p + case Dummy1485(p) => p + case Dummy1486(p) => p + case Dummy1487(p) => p + case Dummy1488(p) => p + case Dummy1489(p) => p + case Dummy1490(p) => p + case Dummy1491(p) => p + case Dummy1492(p) => p + case Dummy1493(p) => p + case Dummy1494(p) => p + case Dummy1495(p) => p + case Dummy1496(p) => p + case Dummy1497(p) => p + case Dummy1498(p) => p + case Dummy1499(p) => p + case Dummy1500(p) => p + case Dummy1501(p) => p + case Dummy1502(p) => p + case Dummy1503(p) => p + case Dummy1504(p) => p + case Dummy1505(p) => p + case Dummy1506(p) => p + case Dummy1507(p) => p + case Dummy1508(p) => p + case Dummy1509(p) => p + case Dummy1510(p) => p + case Dummy1511(p) => p + case Dummy1512(p) => p + case Dummy1513(p) => p + case Dummy1514(p) => p + case Dummy1515(p) => p + case Dummy1516(p) => p + case Dummy1517(p) => p + case Dummy1518(p) => p + case Dummy1519(p) => p + case Dummy1520(p) => p + case Dummy1521(p) => p + case Dummy1522(p) => p + case Dummy1523(p) => p + case Dummy1524(p) => p + case Dummy1525(p) => p + case Dummy1526(p) => p + case Dummy1527(p) => p + case Dummy1528(p) => p + case Dummy1529(p) => p + case Dummy1530(p) => p + case Dummy1531(p) => p + case Dummy1532(p) => p + case Dummy1533(p) => p + case Dummy1534(p) => p + case Dummy1535(p) => p + case Dummy1536(p) => p + case Dummy1537(p) => p + case Dummy1538(p) => p + case Dummy1539(p) => p + case Dummy1540(p) => p + case Dummy1541(p) => p + case Dummy1542(p) => p + case Dummy1543(p) => p + case Dummy1544(p) => p + case Dummy1545(p) => p + case Dummy1546(p) => p + case Dummy1547(p) => p + case Dummy1548(p) => p + case Dummy1549(p) => p + case Dummy1550(p) => p + case Dummy1551(p) => p + case Dummy1552(p) => p + case Dummy1553(p) => p + case Dummy1554(p) => p + case Dummy1555(p) => p + case Dummy1556(p) => p + case Dummy1557(p) => p + case Dummy1558(p) => p + case Dummy1559(p) => p + case Dummy1560(p) => p + case Dummy1561(p) => p + case Dummy1562(p) => p + case Dummy1563(p) => p + case Dummy1564(p) => p + case Dummy1565(p) => p + case Dummy1566(p) => p + case Dummy1567(p) => p + case Dummy1568(p) => p + case Dummy1569(p) => p + case Dummy1570(p) => p + case Dummy1571(p) => p + case Dummy1572(p) => p + case Dummy1573(p) => p + case Dummy1574(p) => p + case Dummy1575(p) => p + case Dummy1576(p) => p + case Dummy1577(p) => p + case Dummy1578(p) => p + case Dummy1579(p) => p + case Dummy1580(p) => p + case Dummy1581(p) => p + case Dummy1582(p) => p + case Dummy1583(p) => p + case Dummy1584(p) => p + case Dummy1585(p) => p + case Dummy1586(p) => p + case Dummy1587(p) => p + case Dummy1588(p) => p + case Dummy1589(p) => p + case Dummy1590(p) => p + case Dummy1591(p) => p + case Dummy1592(p) => p + case Dummy1593(p) => p + case Dummy1594(p) => p + case Dummy1595(p) => p + case Dummy1596(p) => p + case Dummy1597(p) => p + case Dummy1598(p) => p + case Dummy1599(p) => p + case Dummy1600(p) => p + case Dummy1601(p) => p + case Dummy1602(p) => p + case Dummy1603(p) => p + case Dummy1604(p) => p + case Dummy1605(p) => p + case Dummy1606(p) => p + case Dummy1607(p) => p + case Dummy1608(p) => p + case Dummy1609(p) => p + case Dummy1610(p) => p + case Dummy1611(p) => p + case Dummy1612(p) => p + case Dummy1613(p) => p + case Dummy1614(p) => p + case Dummy1615(p) => p + case Dummy1616(p) => p + case Dummy1617(p) => p + case Dummy1618(p) => p + case Dummy1619(p) => p + case Dummy1620(p) => p + case Dummy1621(p) => p + case Dummy1622(p) => p + case Dummy1623(p) => p + case Dummy1624(p) => p + case Dummy1625(p) => p + case Dummy1626(p) => p + case Dummy1627(p) => p + case Dummy1628(p) => p + case Dummy1629(p) => p + case Dummy1630(p) => p + case Dummy1631(p) => p + case Dummy1632(p) => p + case Dummy1633(p) => p + case Dummy1634(p) => p + case Dummy1635(p) => p + case Dummy1636(p) => p + case Dummy1637(p) => p + case Dummy1638(p) => p + case Dummy1639(p) => p + case Dummy1640(p) => p + case Dummy1641(p) => p + case Dummy1642(p) => p + case Dummy1643(p) => p + case Dummy1644(p) => p + case Dummy1645(p) => p + case Dummy1646(p) => p + case Dummy1647(p) => p + case Dummy1648(p) => p + case Dummy1649(p) => p + case Dummy1650(p) => p + case Dummy1651(p) => p + case Dummy1652(p) => p + case Dummy1653(p) => p + case Dummy1654(p) => p + case Dummy1655(p) => p + case Dummy1656(p) => p + case Dummy1657(p) => p + case Dummy1658(p) => p + case Dummy1659(p) => p + case Dummy1660(p) => p + case Dummy1661(p) => p + case Dummy1662(p) => p + case Dummy1663(p) => p + case Dummy1664(p) => p + case Dummy1665(p) => p + case Dummy1666(p) => p + case Dummy1667(p) => p + case Dummy1668(p) => p + case Dummy1669(p) => p + case Dummy1670(p) => p + case Dummy1671(p) => p + case Dummy1672(p) => p + case Dummy1673(p) => p + case Dummy1674(p) => p + case Dummy1675(p) => p + case Dummy1676(p) => p + case Dummy1677(p) => p + case Dummy1678(p) => p + case Dummy1679(p) => p + case Dummy1680(p) => p + case Dummy1681(p) => p + case Dummy1682(p) => p + case Dummy1683(p) => p + case Dummy1684(p) => p + case Dummy1685(p) => p + case Dummy1686(p) => p + case Dummy1687(p) => p + case Dummy1688(p) => p + case Dummy1689(p) => p + case Dummy1690(p) => p + case Dummy1691(p) => p + case Dummy1692(p) => p + case Dummy1693(p) => p + case Dummy1694(p) => p + case Dummy1695(p) => p + case Dummy1696(p) => p + case Dummy1697(p) => p + case Dummy1698(p) => p + case Dummy1699(p) => p + case Dummy1700(p) => p + case Dummy1701(p) => p + case Dummy1702(p) => p + case Dummy1703(p) => p + case Dummy1704(p) => p + case Dummy1705(p) => p + case Dummy1706(p) => p + case Dummy1707(p) => p + case Dummy1708(p) => p + case Dummy1709(p) => p + case Dummy1710(p) => p + case Dummy1711(p) => p + case Dummy1712(p) => p + case Dummy1713(p) => p + case Dummy1714(p) => p + case Dummy1715(p) => p + case Dummy1716(p) => p + case Dummy1717(p) => p + case Dummy1718(p) => p + case Dummy1719(p) => p + case Dummy1720(p) => p + case Dummy1721(p) => p + case Dummy1722(p) => p + case Dummy1723(p) => p + case Dummy1724(p) => p + case Dummy1725(p) => p + case Dummy1726(p) => p + case Dummy1727(p) => p + case Dummy1728(p) => p + case Dummy1729(p) => p + case Dummy1730(p) => p + case Dummy1731(p) => p + case Dummy1732(p) => p + case Dummy1733(p) => p + case Dummy1734(p) => p + case Dummy1735(p) => p + case Dummy1736(p) => p + case Dummy1737(p) => p + case Dummy1738(p) => p + case Dummy1739(p) => p + case Dummy1740(p) => p + case Dummy1741(p) => p + case Dummy1742(p) => p + case Dummy1743(p) => p + case Dummy1744(p) => p + case Dummy1745(p) => p + case Dummy1746(p) => p + case Dummy1747(p) => p + case Dummy1748(p) => p + case Dummy1749(p) => p + case Dummy1750(p) => p + case Dummy1751(p) => p + case Dummy1752(p) => p + case Dummy1753(p) => p + case Dummy1754(p) => p + case Dummy1755(p) => p + case Dummy1756(p) => p + case Dummy1757(p) => p + case Dummy1758(p) => p + case Dummy1759(p) => p + case Dummy1760(p) => p + case Dummy1761(p) => p + case Dummy1762(p) => p + case Dummy1763(p) => p + case Dummy1764(p) => p + case Dummy1765(p) => p + case Dummy1766(p) => p + case Dummy1767(p) => p + case Dummy1768(p) => p + case Dummy1769(p) => p + case Dummy1770(p) => p + case Dummy1771(p) => p + case Dummy1772(p) => p + case Dummy1773(p) => p + case Dummy1774(p) => p + case Dummy1775(p) => p + case Dummy1776(p) => p + case Dummy1777(p) => p + case Dummy1778(p) => p + case Dummy1779(p) => p + case Dummy1780(p) => p + case Dummy1781(p) => p + case Dummy1782(p) => p + case Dummy1783(p) => p + case Dummy1784(p) => p + case Dummy1785(p) => p + case Dummy1786(p) => p + case Dummy1787(p) => p + case Dummy1788(p) => p + case Dummy1789(p) => p + case Dummy1790(p) => p + case Dummy1791(p) => p + case Dummy1792(p) => p + case Dummy1793(p) => p + case Dummy1794(p) => p + case Dummy1795(p) => p + case Dummy1796(p) => p + case Dummy1797(p) => p + case Dummy1798(p) => p + case Dummy1799(p) => p + case Dummy1800(p) => p + case Dummy1801(p) => p + case Dummy1802(p) => p + case Dummy1803(p) => p + case Dummy1804(p) => p + case Dummy1805(p) => p + case Dummy1806(p) => p + case Dummy1807(p) => p + case Dummy1808(p) => p + case Dummy1809(p) => p + case Dummy1810(p) => p + case Dummy1811(p) => p + case Dummy1812(p) => p + case Dummy1813(p) => p + case Dummy1814(p) => p + case Dummy1815(p) => p + case Dummy1816(p) => p + case Dummy1817(p) => p + case Dummy1818(p) => p + case Dummy1819(p) => p + case Dummy1820(p) => p + case Dummy1821(p) => p + case Dummy1822(p) => p + case Dummy1823(p) => p + case Dummy1824(p) => p + case Dummy1825(p) => p + case Dummy1826(p) => p + case Dummy1827(p) => p + case Dummy1828(p) => p + case Dummy1829(p) => p + case Dummy1830(p) => p + case Dummy1831(p) => p + case Dummy1832(p) => p + case Dummy1833(p) => p + case Dummy1834(p) => p + case Dummy1835(p) => p + case Dummy1836(p) => p + case Dummy1837(p) => p + case Dummy1838(p) => p + case Dummy1839(p) => p + case Dummy1840(p) => p + case Dummy1841(p) => p + case Dummy1842(p) => p + case Dummy1843(p) => p + case Dummy1844(p) => p + case Dummy1845(p) => p + case Dummy1846(p) => p + case Dummy1847(p) => p + case Dummy1848(p) => p + case Dummy1849(p) => p + case Dummy1850(p) => p + case Dummy1851(p) => p + case Dummy1852(p) => p + case Dummy1853(p) => p + case Dummy1854(p) => p + case Dummy1855(p) => p + case Dummy1856(p) => p + case Dummy1857(p) => p + case Dummy1858(p) => p + case Dummy1859(p) => p + case Dummy1860(p) => p + case Dummy1861(p) => p + case Dummy1862(p) => p + case Dummy1863(p) => p + case Dummy1864(p) => p + case Dummy1865(p) => p + case Dummy1866(p) => p + case Dummy1867(p) => p + case Dummy1868(p) => p + case Dummy1869(p) => p + case Dummy1870(p) => p + case Dummy1871(p) => p + case Dummy1872(p) => p + case Dummy1873(p) => p + case Dummy1874(p) => p + case Dummy1875(p) => p + case Dummy1876(p) => p + case Dummy1877(p) => p + case Dummy1878(p) => p + case Dummy1879(p) => p + case Dummy1880(p) => p + case Dummy1881(p) => p + case Dummy1882(p) => p + case Dummy1883(p) => p + case Dummy1884(p) => p + case Dummy1885(p) => p + case Dummy1886(p) => p + case Dummy1887(p) => p + case Dummy1888(p) => p + case Dummy1889(p) => p + case Dummy1890(p) => p + case Dummy1891(p) => p + case Dummy1892(p) => p + case Dummy1893(p) => p + case Dummy1894(p) => p + case Dummy1895(p) => p + case Dummy1896(p) => p + case Dummy1897(p) => p + case Dummy1898(p) => p + case Dummy1899(p) => p + case Dummy1900(p) => p + case Dummy1901(p) => p + case Dummy1902(p) => p + case Dummy1903(p) => p + case Dummy1904(p) => p + case Dummy1905(p) => p + case Dummy1906(p) => p + case Dummy1907(p) => p + case Dummy1908(p) => p + case Dummy1909(p) => p + case Dummy1910(p) => p + case Dummy1911(p) => p + case Dummy1912(p) => p + case Dummy1913(p) => p + case Dummy1914(p) => p + case Dummy1915(p) => p + case Dummy1916(p) => p + case Dummy1917(p) => p + case Dummy1918(p) => p + case Dummy1919(p) => p + case Dummy1920(p) => p + case Dummy1921(p) => p + case Dummy1922(p) => p + case Dummy1923(p) => p + case Dummy1924(p) => p + case Dummy1925(p) => p + case Dummy1926(p) => p + case Dummy1927(p) => p + case Dummy1928(p) => p + case Dummy1929(p) => p + case Dummy1930(p) => p + case Dummy1931(p) => p + case Dummy1932(p) => p + case Dummy1933(p) => p + case Dummy1934(p) => p + case Dummy1935(p) => p + case Dummy1936(p) => p + case Dummy1937(p) => p + case Dummy1938(p) => p + case Dummy1939(p) => p + case Dummy1940(p) => p + case Dummy1941(p) => p + case Dummy1942(p) => p + case Dummy1943(p) => p + case Dummy1944(p) => p + case Dummy1945(p) => p + case Dummy1946(p) => p + case Dummy1947(p) => p + case Dummy1948(p) => p + case Dummy1949(p) => p + case Dummy1950(p) => p + case Dummy1951(p) => p + case Dummy1952(p) => p + case Dummy1953(p) => p + case Dummy1954(p) => p + case Dummy1955(p) => p + case Dummy1956(p) => p + case Dummy1957(p) => p + case Dummy1958(p) => p + case Dummy1959(p) => p + case Dummy1960(p) => p + case Dummy1961(p) => p + case Dummy1962(p) => p + case Dummy1963(p) => p + case Dummy1964(p) => p + case Dummy1965(p) => p + case Dummy1966(p) => p + case Dummy1967(p) => p + case Dummy1968(p) => p + case Dummy1969(p) => p + case Dummy1970(p) => p + case Dummy1971(p) => p + case Dummy1972(p) => p + case Dummy1973(p) => p + case Dummy1974(p) => p + case Dummy1975(p) => p + case Dummy1976(p) => p + case Dummy1977(p) => p + case Dummy1978(p) => p + case Dummy1979(p) => p + case Dummy1980(p) => p + case Dummy1981(p) => p + case Dummy1982(p) => p + case Dummy1983(p) => p + case Dummy1984(p) => p + case Dummy1985(p) => p + case Dummy1986(p) => p + case Dummy1987(p) => p + case Dummy1988(p) => p + case Dummy1989(p) => p + case Dummy1990(p) => p + case Dummy1991(p) => p + case Dummy1992(p) => p + case Dummy1993(p) => p + case Dummy1994(p) => p + case Dummy1995(p) => p + case Dummy1996(p) => p + case Dummy1997(p) => p + case Dummy1998(p) => p + case Dummy1999(p) => p +} +} diff --git a/test/files/run/t6987.check b/test/disabled/run/t6987.check index 86fc96c679..86fc96c679 100644 --- a/test/files/run/t6987.check +++ b/test/disabled/run/t6987.check diff --git a/test/files/run/t6987.scala b/test/disabled/run/t6987.scala index 37e91d61ae..37e91d61ae 100644 --- a/test/files/run/t6987.scala +++ b/test/disabled/run/t6987.scala diff --git a/test/files/disabled/run/t4602.scala b/test/files/disabled/run/t4602.scala new file mode 100644 index 0000000000..73ba231ccf --- /dev/null +++ b/test/files/disabled/run/t4602.scala @@ -0,0 +1,57 @@ +import java.io.{File, FileOutputStream, BufferedOutputStream, FileWriter, ByteArrayOutputStream, PrintStream} +import tools.nsc.{CompileClient, CompileServer} +import java.util.concurrent.{CountDownLatch, TimeUnit} + +object Test extends App { + val startupLatch = new CountDownLatch(1) + // we have to explicitly launch our server because when the client launches a server it uses + // the "scala" shell command meaning whatever version of scala (and whatever version of libraries) + // happens to be in the path gets used + val t = new Thread(new Runnable { + def run() = { + CompileServer.execute(() => startupLatch.countDown(), Array[String]()) + } + }) + t setDaemon true + t.start() + if (!startupLatch.await(2, TimeUnit.MINUTES)) + sys error "Timeout waiting for server to start" + + val baos = new ByteArrayOutputStream() + val ps = new PrintStream(baos) + + val outdir = scala.reflect.io.Directory(sys.props("partest.output")) + + val dirNameAndPath = (1 to 2).toList map {number => + val name = s"Hello${number}" + val dir = outdir / number.toString + (dir, name, dir / s"${name}.scala") + } + + dirNameAndPath foreach {case (dir, name, path) => + dir.createDirectory() + val file = path.jfile + val out = new FileWriter(file) + try + out.write(s"object ${name}\n") + finally + out.close + } + + val success = (scala.Console withOut ps) { + dirNameAndPath foreach {case (path, name, _) => + CompileClient.process(Array("-verbose", "-current-dir", path.toString, s"${name}.scala")) + } + + CompileClient.process(Array("-shutdown")) + } + + // now make sure we got success and the correct normalized paths + val msg = baos.toString() + + assert(success, s"got a failure. Full results were: \n${msg}") + dirNameAndPath foreach {case (_, _, path) => + val expected = s"Input files after normalizing paths: ${path}" + assert(msg contains expected, s"could not find '${expected}' in output. Full results were: \n${msg}") + } +} diff --git a/test/files/jvm/bytecode-test-example.check b/test/files/jvm/bytecode-test-example.check new file mode 100644 index 0000000000..0cfbf08886 --- /dev/null +++ b/test/files/jvm/bytecode-test-example.check @@ -0,0 +1 @@ +2 diff --git a/test/files/jvm/bytecode-test-example/Foo_1.scala b/test/files/jvm/bytecode-test-example/Foo_1.scala new file mode 100644 index 0000000000..4f679d156f --- /dev/null +++ b/test/files/jvm/bytecode-test-example/Foo_1.scala @@ -0,0 +1,9 @@ +class Foo_1 { + def foo(x: AnyRef): Int = { + val bool = x == null + if (x != null) + 1 + else + 0 + } +} diff --git a/test/files/jvm/bytecode-test-example/Test.scala b/test/files/jvm/bytecode-test-example/Test.scala new file mode 100644 index 0000000000..d668059cb7 --- /dev/null +++ b/test/files/jvm/bytecode-test-example/Test.scala @@ -0,0 +1,32 @@ +import scala.tools.partest.BytecodeTest + +import scala.tools.nsc.util.JavaClassPath +import java.io.InputStream +import scala.tools.asm +import asm.ClassReader +import asm.tree.{ClassNode, InsnList} +import scala.collection.JavaConverters._ + +object Test extends BytecodeTest { + def show: Unit = { + val classNode = loadClassNode("Foo_1") + val methodNode = getMethod(classNode, "foo") + println(countNullChecks(methodNode.instructions)) + } + + def countNullChecks(insnList: InsnList): Int = { + /** Is given instruction a null check? + * NOTE + * This will detect direct null compparsion as in + * if (x == null) ... + * and not indirect as in + * val foo = null + * if (x == foo) ... + */ + def isNullCheck(node: asm.tree.AbstractInsnNode): Boolean = { + val opcode = node.getOpcode + (opcode == asm.Opcodes.IFNULL) || (opcode == asm.Opcodes.IFNONNULL) + } + insnList.iterator.asScala.count(isNullCheck) + } +} diff --git a/test/files/jvm/throws-annot-from-java.check b/test/files/jvm/throws-annot-from-java.check new file mode 100644 index 0000000000..be3ba412f8 --- /dev/null +++ b/test/files/jvm/throws-annot-from-java.check @@ -0,0 +1,47 @@ +Type in expressions to have them evaluated. +Type :help for more information. + +scala> :power +** Power User mode enabled - BEEP WHIR GYVE ** +** :phase has been set to 'typer'. ** +** scala.tools.nsc._ has been imported ** +** global._, definitions._ also imported ** +** Try :help, :vals, power.<tab> ** + +scala> :paste +// Entering paste mode (ctrl-D to finish) + +{ + val clazz = rootMirror.getClassByName(newTermName("test.ThrowsDeclaration_2")); + { + val method = clazz.info.member(newTermName("foo")) + val throwsAnn = method.annotations.head + val atp = throwsAnn.atp + println("foo") + println("atp.typeParams.isEmpty: " + atp.typeParams.isEmpty) + println(throwsAnn) + } + println + + { + val method = clazz.info.member(newTermName("bar")) + val throwsAnn = method.annotations.head + val Literal(const) = throwsAnn.args.head + val tp = const.typeValue + println("bar") + println("tp.typeParams.isEmpty: " + tp.typeParams.isEmpty) + println(throwsAnn) + } +} + +// Exiting paste mode, now interpreting. + +foo +atp.typeParams.isEmpty: true +throws[IllegalStateException](classOf[java.lang.IllegalStateException]) + +bar +tp.typeParams.isEmpty: true +throws[test.PolymorphicException[_]](classOf[test.PolymorphicException]) + +scala> diff --git a/test/files/jvm/throws-annot-from-java/PolymorphicException_1.scala b/test/files/jvm/throws-annot-from-java/PolymorphicException_1.scala new file mode 100644 index 0000000000..58fa536f0b --- /dev/null +++ b/test/files/jvm/throws-annot-from-java/PolymorphicException_1.scala @@ -0,0 +1,3 @@ +package test + +class PolymorphicException[T] extends Exception diff --git a/test/files/jvm/throws-annot-from-java/Test_3.scala b/test/files/jvm/throws-annot-from-java/Test_3.scala new file mode 100644 index 0000000000..de1d984573 --- /dev/null +++ b/test/files/jvm/throws-annot-from-java/Test_3.scala @@ -0,0 +1,29 @@ +import scala.tools.partest.ReplTest + +object Test extends ReplTest { + def code = """:power +:paste +{ + val clazz = rootMirror.getClassByName(newTermName("test.ThrowsDeclaration_2")); + { + val method = clazz.info.member(newTermName("foo")) + val throwsAnn = method.annotations.head + val atp = throwsAnn.atp + println("foo") + println("atp.typeParams.isEmpty: " + atp.typeParams.isEmpty) + println(throwsAnn) + } + println + + { + val method = clazz.info.member(newTermName("bar")) + val throwsAnn = method.annotations.head + val Literal(const) = throwsAnn.args.head + val tp = const.typeValue + println("bar") + println("tp.typeParams.isEmpty: " + tp.typeParams.isEmpty) + println(throwsAnn) + } +} +""" +} diff --git a/test/files/jvm/throws-annot-from-java/ThrowsDeclaration_2.java b/test/files/jvm/throws-annot-from-java/ThrowsDeclaration_2.java new file mode 100644 index 0000000000..3708fe626b --- /dev/null +++ b/test/files/jvm/throws-annot-from-java/ThrowsDeclaration_2.java @@ -0,0 +1,6 @@ +package test; + +public class ThrowsDeclaration_2 { + public void foo() throws IllegalStateException {}; + public void bar() throws PolymorphicException {}; +} diff --git a/test/files/neg/macro-false-deprecation-warning.check b/test/files/neg/macro-false-deprecation-warning.check new file mode 100644 index 0000000000..7d56505ec4 --- /dev/null +++ b/test/files/neg/macro-false-deprecation-warning.check @@ -0,0 +1,4 @@ +Impls_Macros_1.scala:5: error: illegal start of simple expression +} +^ +one error found diff --git a/test/files/neg/macro-false-deprecation-warning.flags b/test/files/neg/macro-false-deprecation-warning.flags new file mode 100644 index 0000000000..59af162db6 --- /dev/null +++ b/test/files/neg/macro-false-deprecation-warning.flags @@ -0,0 +1 @@ +-language:experimental.macros -deprecation
\ No newline at end of file diff --git a/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala b/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala new file mode 100644 index 0000000000..6dc2ea114b --- /dev/null +++ b/test/files/neg/macro-false-deprecation-warning/Impls_Macros_1.scala @@ -0,0 +1,15 @@ +import scala.reflect.macros.Context + +object Helper { + def unapplySeq[T](x: List[T]): Option[Seq[T]] = +} + +object Macros { + def impl[T: c.WeakTypeTag](c: Context)(x: c.Expr[List[T]]) = { + c.universe.reify(Helper.unapplySeq(x.splice)) + } + + object UnapplyMacro { + def unapplySeq[T](x: List[T]): Option[Seq[T]] = macro impl[T] + } +} diff --git a/test/files/neg/t5353.check b/test/files/neg/t5353.check new file mode 100644 index 0000000000..75e2435600 --- /dev/null +++ b/test/files/neg/t5353.check @@ -0,0 +1,4 @@ +t5353.scala:2: error: this type parameter must be specified + def f(x: Boolean) = if (x) Array("abc") else Array() + ^ +one error found diff --git a/test/files/neg/t5353.scala b/test/files/neg/t5353.scala new file mode 100644 index 0000000000..1ee869aac1 --- /dev/null +++ b/test/files/neg/t5353.scala @@ -0,0 +1,3 @@ +class A { + def f(x: Boolean) = if (x) Array("abc") else Array() +} diff --git a/test/files/neg/t5378.check b/test/files/neg/t5378.check new file mode 100644 index 0000000000..c1460083f6 --- /dev/null +++ b/test/files/neg/t5378.check @@ -0,0 +1,31 @@ +t5378.scala:7: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + def contains = new { def apply[T1 <: T](value: T1) = ??? } + ^ +t5378.scala:8: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + def contains1 = new { def apply[T1 <: A1](value: T1) = ??? } + ^ +t5378.scala:9: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + def contains2 = new { def apply[T1 <: A2](value: T1) = ??? } + ^ +t5378.scala:15: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + new Bippy { def apply[T1 <: T](value: T1) = ??? } + ^ +t5378.scala:16: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + new Bippy { def apply[T1 <: B1](value: T1) = ??? } + ^ +t5378.scala:17: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + new Bippy { def apply[T1 <: B2](value: T1) = ??? } + ^ +t5378.scala:21: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + def apply1[T1 <: B3](value: T1) = ??? + ^ +t5378.scala:23: error: Parameter type in structural refinement may not refer to an abstract type defined outside that refinement + def apply3(value: B3) = ??? + ^ +t5378.scala:28: error: Parameter type in structural refinement may not refer to an abstract type defined outside that refinement + def apply1(s: String)(x: Int)(value: T) = ??? + ^ +t5378.scala:29: error: Type bound in structural refinement may not refer to an abstract type defined outside that refinement + def apply2[T1 <: T](s: String)(x: Int)(value: T1) = ??? + ^ +10 errors found diff --git a/test/files/neg/t5378.scala b/test/files/neg/t5378.scala new file mode 100644 index 0000000000..fa6afa02be --- /dev/null +++ b/test/files/neg/t5378.scala @@ -0,0 +1,54 @@ +import scala.language.reflectiveCalls + +class Coll[+T] { + type A1 <: T + type A2 <: A1 + + def contains = new { def apply[T1 <: T](value: T1) = ??? } + def contains1 = new { def apply[T1 <: A1](value: T1) = ??? } + def contains2 = new { def apply[T1 <: A2](value: T1) = ??? } + def contains3 = { + trait Bippy { + type B1 <: T + type B2 <: B1 + } + new Bippy { def apply[T1 <: T](value: T1) = ??? } + new Bippy { def apply[T1 <: B1](value: T1) = ??? } + new Bippy { def apply[T1 <: B2](value: T1) = ??? } + new Bippy { + type B3 = B2 + type B4 = List[B2] + def apply1[T1 <: B3](value: T1) = ??? + def apply2[T1 <: B4](value: T1) = ??? + def apply3(value: B3) = ??? + def apply4(value: B4) = value.head + } + } + def contains4 = new { + def apply1(s: String)(x: Int)(value: T) = ??? + def apply2[T1 <: T](s: String)(x: Int)(value: T1) = ??? + } + def containsOk = { + trait Bippy { + type B1 <: AnyRef + type B2 <: B1 + } + new Bippy { def apply[T1 <: AnyRef](value: T1) = ??? } + new Bippy { type B1 = String ; def apply[T1 <: B1](value: T1) = ??? } + new Bippy { type B2 = String ; def apply[T1 <: B2](value: T1) = ??? } + } +} + +object Test { + def main(args: Array[String]): Unit = { + val xs = new Coll[List[String]] + val ys: Coll[Traversable[String]] = xs + + println(ys contains Nil) + // java.lang.NoSuchMethodException: Coll$$anon$1.apply(scala.collection.Traversable) + // at java.lang.Class.getMethod(Class.java:1605) + // at Test$.reflMethod$Method1(a.scala:14) + // at Test$.main(a.scala:14) + // at Test.main(a.scala) + } +} diff --git a/test/files/neg/t5692a.check b/test/files/neg/t5692a.check index ded95a8820..7fbfb5dba7 100644 --- a/test/files/neg/t5692a.check +++ b/test/files/neg/t5692a.check @@ -1,4 +1,4 @@ -Test_2.scala:2: error: type parameter not specified +Test_2.scala:2: error: this type parameter must be specified def x = Macros.foo ^ one error found diff --git a/test/files/neg/t5692b.check b/test/files/neg/t5692b.check index e453870ec8..16796826b4 100644 --- a/test/files/neg/t5692b.check +++ b/test/files/neg/t5692b.check @@ -1,4 +1,4 @@ -Test_2.scala:2: error: type parameters not specified +Test_2.scala:2: error: these type parameters must be specified def x = Macros.foo ^ one error found diff --git a/test/files/neg/t6426.check b/test/files/neg/t6426.check new file mode 100644 index 0000000000..149f74c4de --- /dev/null +++ b/test/files/neg/t6426.check @@ -0,0 +1,7 @@ +t6426.scala:4: error: wildcard invalid as backquoted identifier + println(`_`.Buffer(0)) + ^ +t6426.scala:5: error: ')' expected but '}' found. +} +^ +two errors found diff --git a/test/files/neg/t6426.scala b/test/files/neg/t6426.scala new file mode 100644 index 0000000000..a27d18eb58 --- /dev/null +++ b/test/files/neg/t6426.scala @@ -0,0 +1,5 @@ +class A { + import collection.{mutable => _, _} + + println(`_`.Buffer(0)) +} diff --git a/test/files/neg/t6728.check b/test/files/neg/t6728.check new file mode 100644 index 0000000000..d853d6f724 --- /dev/null +++ b/test/files/neg/t6728.check @@ -0,0 +1,4 @@ +t6728.scala:4: error: '(' expected but '}' found. + } + ^ +one error found diff --git a/test/files/neg/t6728.scala b/test/files/neg/t6728.scala new file mode 100644 index 0000000000..ba0b1a0fdf --- /dev/null +++ b/test/files/neg/t6728.scala @@ -0,0 +1,5 @@ +object X { + while(true) { + for + } +} diff --git a/test/files/pos/t3577.scala b/test/files/pos/t3577.scala new file mode 100644 index 0000000000..80a280f67a --- /dev/null +++ b/test/files/pos/t3577.scala @@ -0,0 +1,29 @@ +case class Check[A](val value: A) + +case class C2(checks: Check[_]*); + +object C { + def m(x : C2): Any = (null: Any) match { + case C2(_, rest @ _*) => { + rest.map(_.value) + } + } +} + +/////////////////// + +object Container { + trait Exp[+T] + abstract class FuncExp[-S, +T] + + sealed abstract class FoundNode[T, Repr] { + def optimize[TupleT, U, That](parentNode: FlatMap[T, Repr, U, That]): Any + def optimize2[TupleT, U, That](parentNode: Any): Any + } + + class FlatMap[T, Repr, U, That] + + val Seq(fn: FoundNode[t, repr]) = Seq[FoundNode[_, _]]() + fn.optimize(null) // was: scala.MatchError: ? (of class BoundedWildcardType) @ Variances#varianceInType + fn.optimize2(null) // was: fatal error: bad type: ?(class scala.reflect.internal.Types$BoundedWildcardType) @ Pickle.putType +} diff --git a/test/files/pos/t5130.scala b/test/files/pos/t5130.scala new file mode 100644 index 0000000000..676d3c7050 --- /dev/null +++ b/test/files/pos/t5130.scala @@ -0,0 +1,46 @@ +import scala.language.reflectiveCalls + +class A { + this_a => + + def b = new B + class B { def a: this_a.type = this_a } +} +trait A2 { def c = () } + +object Test { + val v1 = new A { def c = () } + val v2 = new A with A2 { } + val v3: A { def c: Unit } = null + def d1 = new A { def c = () } + def d2 = new A with A2 { } + def d3: A { def c: Unit } = null + var x1 = new A { def c = () } + var x2 = new A with A2 { } + var x3: A { def c: Unit } = null + + def main(args: Array[String]): Unit = { + val mv1 = new A { def c = () } + val mv2 = new A with A2 { } + val mv3: A { def c: Unit } = null + def md1 = new A { def c = () } + def md2 = new A with A2 { } + def md3: A { def c: Unit } = null + + v1.b.a.c + v2.b.a.c + v3.b.a.c + d1.b.a.c + d2.b.a.c + d3.b.a.c + x1.b.a.c + x2.b.a.c + x3.b.a.c + mv1.b.a.c + mv2.b.a.c + mv3.b.a.c + md1.b.a.c + md2.b.a.c + md3.b.a.c + } +} diff --git a/test/files/pos/t5604b/T_1.scala b/test/files/pos/t5604b/T_1.scala new file mode 100644 index 0000000000..179dcb10c6 --- /dev/null +++ b/test/files/pos/t5604b/T_1.scala @@ -0,0 +1,6 @@ +// sandbox/t5604/T.scala +package t6504 + +trait T { + def foo: Boolean = false +} diff --git a/test/files/pos/t5604b/T_2.scala b/test/files/pos/t5604b/T_2.scala new file mode 100644 index 0000000000..179dcb10c6 --- /dev/null +++ b/test/files/pos/t5604b/T_2.scala @@ -0,0 +1,6 @@ +// sandbox/t5604/T.scala +package t6504 + +trait T { + def foo: Boolean = false +} diff --git a/test/files/pos/t5604b/Test_1.scala b/test/files/pos/t5604b/Test_1.scala new file mode 100644 index 0000000000..f7c58ebe83 --- /dev/null +++ b/test/files/pos/t5604b/Test_1.scala @@ -0,0 +1,7 @@ +// sandbox/t5604/Test.scala +package t6504 + +object Test { + def blerg1(a: Any): Any = if (foo) blerg1(0) + def blerg2(a: Any): Any = if (t6504.foo) blerg2(0) +} diff --git a/test/files/pos/t5604b/Test_2.scala b/test/files/pos/t5604b/Test_2.scala new file mode 100644 index 0000000000..f7c58ebe83 --- /dev/null +++ b/test/files/pos/t5604b/Test_2.scala @@ -0,0 +1,7 @@ +// sandbox/t5604/Test.scala +package t6504 + +object Test { + def blerg1(a: Any): Any = if (foo) blerg1(0) + def blerg2(a: Any): Any = if (t6504.foo) blerg2(0) +} diff --git a/test/files/pos/t5604b/pack_1.scala b/test/files/pos/t5604b/pack_1.scala new file mode 100644 index 0000000000..f50d568bfa --- /dev/null +++ b/test/files/pos/t5604b/pack_1.scala @@ -0,0 +1,5 @@ +// sandbox/t5604/pack.scala +package t6504 + +object `package` extends T { +} diff --git a/test/files/pos/t5859.scala b/test/files/pos/t5859.scala new file mode 100644 index 0000000000..2a31e68ee5 --- /dev/null +++ b/test/files/pos/t5859.scala @@ -0,0 +1,15 @@ + +class A { + def f(xs: List[Int], ys: AnyRef*) = () + def f(xs: AnyRef*) = () + + f() + f(List[AnyRef](): _*) + f(List(): _*) + f(Nil: _*) + f(Array(): _*) + f(Array[AnyRef](): _*) + f(List(1)) + f(List(1), Nil: _*) + f(List(1), Array(): _*) +} diff --git a/test/files/pos/t6072.scala b/test/files/pos/t6072.scala new file mode 100644 index 0000000000..e25ebbffc5 --- /dev/null +++ b/test/files/pos/t6072.scala @@ -0,0 +1,3 @@ +class A { + object B { def eq(lvl: Int) = ??? } +} diff --git a/test/files/pos/t6516.scala b/test/files/pos/t6516.scala new file mode 100644 index 0000000000..c004055de2 --- /dev/null +++ b/test/files/pos/t6516.scala @@ -0,0 +1,19 @@ +import scala.language.experimental.macros +import scala.reflect.macros.Context +import scala.collection.TraversableLike + +// This one compiles +object Test { + type Alias[T, CC[_]] = Context { type PrefixType = TraversableLike[T, CC[T]] } + def f() = macro f_impl + def f_impl(c: Alias[Int, List])() = ??? +} + +// This one doesn't +object Test2 { + type Ctx = scala.reflect.macros.Context + type Alias[T, CC[_]] = Ctx { type PrefixType = TraversableLike[T, CC[T]] } + + def f() = macro f_impl + def f_impl(c: Alias[Int, List])() = ??? +} diff --git a/test/files/pos/t6595.flags b/test/files/pos/t6595.flags new file mode 100644 index 0000000000..85d8eb2ba2 --- /dev/null +++ b/test/files/pos/t6595.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t6595.scala b/test/files/pos/t6595.scala new file mode 100644 index 0000000000..437c0bcf05 --- /dev/null +++ b/test/files/pos/t6595.scala @@ -0,0 +1,18 @@ +import scala.annotation.switch + +class Foo extends { + final val b0 = 5 +} with AnyRef { + final val b1 = 10 + + // Using the @switch annotation as a means of testing that the + // type inferred for b0 is Int(5) and not Int. Only in the former + // case can a switch be generated. + def f(p: Int) = (p: @switch) match { + case `b0` => 1 + case `b1` => 2 + case 15 => 3 + case 20 => 4 + case _ => 5 + } +} diff --git a/test/files/pos/t6651.scala b/test/files/pos/t6651.scala new file mode 100644 index 0000000000..55a3b74e4c --- /dev/null +++ b/test/files/pos/t6651.scala @@ -0,0 +1,33 @@ +class YouAreYourself[A <: AnyRef](val you: A) extends AnyVal { + def yourself: you.type = you +} + +object Test { + val s = "" + val s1: s.type = new YouAreYourself[s.type](s).yourself +} + +trait Path { + type Dep <: AnyRef +} + +final class ValueClass[P <: Path](val path: P) extends AnyVal { + import path.Dep + + def apply(dep: Dep)(d2: dep.type, foo: Int): (Dep, d2.type) = (d2, d2) + + // This generates dodgy code; note `ValueClass.this`: + // + // final def bounds$extension[D >: Nothing <: ValueClass.this.path.Dep, + // P >: Nothing <: Path] + // ($this: ValueClass[P]) + // (dep: D) + // (d2: dep.type, foo: Int): (D, d2.type) = scala.Tuple2.apply[D, d2.type](d2, d2); + // + // Nothing crashes down the line, but it certainly doesn't conform to best-practices. + // + // An better alternative would be to add a type parameter for the (singleton) type of + // the wrapped value. + def bounds[D <: Dep](dep: D)(d2: dep.type, foo: Int): (D, d2.type) = (d2, d2) +} + diff --git a/test/files/pos/t6891.flags b/test/files/pos/t6891.flags new file mode 100644 index 0000000000..fe048006aa --- /dev/null +++ b/test/files/pos/t6891.flags @@ -0,0 +1 @@ +-Ycheck:extmethods -Xfatal-warnings
\ No newline at end of file diff --git a/test/files/pos/t6891.scala b/test/files/pos/t6891.scala new file mode 100644 index 0000000000..bed2d0d777 --- /dev/null +++ b/test/files/pos/t6891.scala @@ -0,0 +1,26 @@ +object O { + implicit class Foo[A](val value: String) extends AnyVal { + def bippy() = { + @annotation.tailrec def loop(x: A): Unit = loop(x) + () + } + + def boppy() = { + @annotation.tailrec def loop(x: value.type): Unit = loop(x) + () + } + + def beppy[C](c: => C) = { + () => c + @annotation.tailrec def loop(x: value.type): Unit = loop(x) + () => c + () + } + } + // uncaught exception during compilation: Types$TypeError("type mismatch; + // found : A(in method bippy$extension) + // required: A(in class Foo)") @ scala.tools.nsc.typechecker.Contexts$Context.issueCommon(Contexts.scala:396) + // error: scala.reflect.internal.Types$TypeError: type mismatch; + // found : A(in method bippy$extension) + // required: A(in class Foo) +} diff --git a/test/files/pos/t7035.scala b/test/files/pos/t7035.scala new file mode 100644 index 0000000000..f45bd0a878 --- /dev/null +++ b/test/files/pos/t7035.scala @@ -0,0 +1,15 @@ +case class Y(final var x: Int, final private var y: String, final val z1: Boolean, final private val z2: Any) { + + import Test.{y => someY} + List(someY.x: Int, someY.y: String, someY.z1: Boolean, someY.z2: Any) + someY.y = "" +} + +object Test { + val y = Y(0, "", true, new {}) + val unapp: Option[(Int, String, Boolean, Any)] = // was (Int, Boolean, String, Any) !! + Y.unapply(y) + + val Y(a, b, c, d) = y + List(a: Int, b: String, c: Boolean, d: Any) +} diff --git a/test/files/run/reify-staticXXX.scala b/test/files/run/reify-staticXXX.scala index dc861f843e..e80157dd8f 100644 --- a/test/files/run/reify-staticXXX.scala +++ b/test/files/run/reify-staticXXX.scala @@ -4,12 +4,12 @@ import scala.tools.reflect.Eval object B { override def toString = "object" } class C { override def toString = "class" } -package foo { +package foo1 { object B { override def toString = "package > object" } class C { override def toString = "package > class" } } -object foo { +object Foo2 { object B { override def toString = "object > object" } class C { override def toString = "object > class" } } @@ -20,14 +20,14 @@ object packageless { println(reify(B).eval) println(new C) println(reify(new C).eval) - println(foo.B) - println(reify(foo.B).eval) - println(new foo.C) - println(reify(new foo.C).eval) - println(_root_.foo.B) - println(reify(_root_.foo.B).eval) - println(new _root_.foo.C) - println(reify(new _root_.foo.C).eval) + println(Foo2.B) + println(reify(Foo2.B).eval) + println(new Foo2.C) + println(reify(new Foo2.C).eval) + println(_root_.foo1.B) + println(reify(_root_.foo1.B).eval) + println(new _root_.foo1.C) + println(reify(new _root_.foo1.C).eval) } } @@ -38,14 +38,14 @@ package packageful { println(reify(B).eval) println(new C) println(reify(new C).eval) - println(foo.B) - println(reify(foo.B).eval) - println(new foo.C) - println(reify(new foo.C).eval) - println(_root_.foo.B) - println(reify(_root_.foo.B).eval) - println(new _root_.foo.C) - println(reify(new _root_.foo.C).eval) + println(Foo2.B) + println(reify(Foo2.B).eval) + println(new Foo2.C) + println(reify(new Foo2.C).eval) + println(_root_.foo1.B) + println(reify(_root_.foo1.B).eval) + println(new _root_.foo1.C) + println(reify(new _root_.foo1.C).eval) } } } diff --git a/test/files/run/t2418.check b/test/files/run/t2418.check new file mode 100644 index 0000000000..f599e28b8a --- /dev/null +++ b/test/files/run/t2418.check @@ -0,0 +1 @@ +10 diff --git a/test/files/run/t2418.scala b/test/files/run/t2418.scala new file mode 100644 index 0000000000..f330bef60a --- /dev/null +++ b/test/files/run/t2418.scala @@ -0,0 +1,10 @@ +class Foo { + @volatile final var x=10 + override def toString = "" + x +} + +object Test { + def main(args: Array[String]): Unit = { + println((new Foo)) + } +} diff --git a/test/files/run/t3353.check b/test/files/run/t3353.check new file mode 100644 index 0000000000..8b4ae1fe69 --- /dev/null +++ b/test/files/run/t3353.check @@ -0,0 +1 @@ +Got: foo and None diff --git a/test/files/run/t3353.scala b/test/files/run/t3353.scala new file mode 100644 index 0000000000..eeb63c1b05 --- /dev/null +++ b/test/files/run/t3353.scala @@ -0,0 +1,10 @@ +object Test extends App { + + "foo" match { + case Matcher(result) => println(result) + } + + object Matcher{ + def unapply(s: String)(implicit secondParam: Option[String] = None) = Some("Got: " + s + " and " + secondParam) + } +} diff --git a/test/files/run/t4729.check b/test/files/run/t4729.check new file mode 100644 index 0000000000..9a2aa56d99 --- /dev/null +++ b/test/files/run/t4729.check @@ -0,0 +1,4 @@ +WrappedArray(1, 2) +WrappedArray(1, 2) +WrappedArray(1, 2) +WrappedArray(1, 2) diff --git a/test/files/run/t4729/J_1.java b/test/files/run/t4729/J_1.java new file mode 100644 index 0000000000..2ffb5a88d1 --- /dev/null +++ b/test/files/run/t4729/J_1.java @@ -0,0 +1,4 @@ +// Java Interface: +public interface J_1 { + public void method(String... s); +} diff --git a/test/files/run/t4729/S_2.scala b/test/files/run/t4729/S_2.scala new file mode 100644 index 0000000000..e34e3d34d4 --- /dev/null +++ b/test/files/run/t4729/S_2.scala @@ -0,0 +1,29 @@ + // Scala class: +class ScalaVarArgs extends J_1 { + // -- no problem on overriding it using ordinary class + def method(s: String*) { println(s) } +} + +object Test { + def main(args: Array[String]) { + //[1] Ok - no problem using inferred type + val varArgs = new J_1 { + def method(s: String*) { println(s) } + } + varArgs.method("1", "2") + + //[2] Ok -- no problem when explicit set its type after construction + val b: J_1 = varArgs + b.method("1", "2") + + //[3] Ok -- no problem on calling its method + (new ScalaVarArgs).method("1", "2") + (new ScalaVarArgs: J_1).method("1", "2") + + //[4] Not Ok -- error when assigning anonymous class to a explictly typed val + // Compiler error: object creation impossible, since method method in trait VarArgs of type (s: <repeated...>[java.lang.String])Unit is not defined + val tagged: J_1 = new J_1 { + def method(s: String*) { println(s) } + } + } +} diff --git a/test/files/run/t5604.check b/test/files/run/t5604.check new file mode 100644 index 0000000000..53a2fc8894 --- /dev/null +++ b/test/files/run/t5604.check @@ -0,0 +1,8 @@ +long +double +long +double +long +double +long +double diff --git a/test/files/run/t5604.scala b/test/files/run/t5604.scala new file mode 100644 index 0000000000..a06c8aab3e --- /dev/null +++ b/test/files/run/t5604.scala @@ -0,0 +1,50 @@ +// a.scala +// Fri Jan 13 11:31:47 PST 2012 + +package foo { + object regular extends Duh { + def buh(n: Long) = println("long") + def buh(n: Double) = println("double") + } + class regular { + import regular._ + + duh(33L) + duh(3.0d) + foo.regular.duh(33L) + foo.regular.duh(3.0d) + buh(66L) + buh(6.0d) + foo.regular.buh(66L) + foo.regular.buh(6.0d) + } + + trait Duh { + def duh(n: Long) = println("long") + def duh(n: Double) = println("double") + } + package object bar extends Duh { + def buh(n: Long) = println("long") + def buh(n: Double) = println("double") + } + package bar { + object Main { + def main(args:Array[String]) { + duh(33L) + duh(3.0d) + foo.bar.duh(33L) + foo.bar.duh(3.0d) + buh(66L) + buh(6.0d) + foo.bar.buh(66L) + foo.bar.buh(6.0d) + } + } + } +} + +object Test { + def main(args: Array[String]): Unit = { + foo.bar.Main.main(null) + } +} diff --git a/test/files/run/t6154.check b/test/files/run/t6154.check new file mode 100644 index 0000000000..9766475a41 --- /dev/null +++ b/test/files/run/t6154.check @@ -0,0 +1 @@ +ok diff --git a/test/files/run/t6154.scala b/test/files/run/t6154.scala new file mode 100644 index 0000000000..02ef62905f --- /dev/null +++ b/test/files/run/t6154.scala @@ -0,0 +1,10 @@ +object Test { + def foo(a: Int) { + var bar: Int = 0 + bar = try { 0 } catch { case ex: Throwable => 0 } + new { foo(bar) } + } + + def main(args: Array[String]): Unit = + try foo(0) catch { case _: java.lang.StackOverflowError => println("ok") } +} diff --git a/test/files/run/t6572/bar_1.scala b/test/files/run/t6572/bar_1.scala new file mode 100644 index 0000000000..5518ced7af --- /dev/null +++ b/test/files/run/t6572/bar_1.scala @@ -0,0 +1,19 @@ +package bar + +abstract class IntBase[V] extends Base[Int, V] + +class DefaultIntBase[V <: IntProvider] extends IntBase[V] { + override protected def hashCode(key: Int) = key +} + +trait IntProvider { + def int: Int +} + +abstract class Base[@specialized K, V] { + + protected def hashCode(key: K) = key.hashCode + + def get(key: K): V = throw new RuntimeException + +}
\ No newline at end of file diff --git a/test/files/run/t6572/foo_2.scala b/test/files/run/t6572/foo_2.scala new file mode 100644 index 0000000000..465f0b7c3c --- /dev/null +++ b/test/files/run/t6572/foo_2.scala @@ -0,0 +1,17 @@ +//package foo + +import bar._ + +class FooProvider extends IntProvider { + def int = 3 +} + +class Wrapper(users: DefaultIntBase[FooProvider]) { + final def user(userId: Int) = users.get(userId) +} + +object Test { + def main(args: Array[String]) { + new Wrapper(new DefaultIntBase) + } +}
\ No newline at end of file diff --git a/test/files/run/t6584.check b/test/files/run/t6584.check new file mode 100644 index 0000000000..35c8688751 --- /dev/null +++ b/test/files/run/t6584.check @@ -0,0 +1,8 @@ +Array: 102400 +Vector: 102400 +List: 102400 +Stream: 102400 +Array: 102400 +Vector: 102400 +List: 102400 +Stream: 102400 diff --git a/test/files/run/t6584.scala b/test/files/run/t6584.scala new file mode 100644 index 0000000000..24c236ef35 --- /dev/null +++ b/test/files/run/t6584.scala @@ -0,0 +1,16 @@ +object Test { + def main(args: Array[String]): Unit = { + val size = 100 * 1024 + val doubled = (1 to size) ++ (1 to size) + + println("Array: " + Array.tabulate(size)(x => x).distinct.size) + println("Vector: " + Vector.tabulate(size)(x => x).distinct.size) + println("List: " + List.tabulate(size)(x => x).distinct.size) + println("Stream: " + Stream.tabulate(size)(x => x).distinct.size) + + println("Array: " + doubled.toArray.distinct.size) + println("Vector: " + doubled.toVector.distinct.size) + println("List: " + doubled.toList.distinct.size) + println("Stream: " + doubled.toStream.distinct.size) + } +} diff --git a/test/files/run/t6669.scala b/test/files/run/t6669.scala new file mode 100644 index 0000000000..b55718b12b --- /dev/null +++ b/test/files/run/t6669.scala @@ -0,0 +1,26 @@ +import java.io.{ByteArrayOutputStream, PrintStream} + +object Test extends App { + val baos = new ByteArrayOutputStream() + val ps = new PrintStream(baos) + + // first test with the default classpath + (scala.Console withOut ps) { + scala.tools.scalap.Main.main(Array("-verbose", "java.lang.Object")) + } + + // now make sure we saw the '.' in the classpath + val msg1 = baos.toString() + assert(msg1 contains "directory classpath: .", s"Did not see '.' in the default class path. Full results were:\n$msg1") + + // then test again with a user specified classpath + baos.reset + + (scala.Console withOut ps) { + scala.tools.scalap.Main.main(Array("-verbose", "-cp", "whatever", "java.lang.Object")) + } + + // now make sure we did not see the '.' in the classpath + val msg2 = baos.toString() + assert(!(msg2 contains "directory classpath: ."), s"Did saw '.' in the user specified class path. Full results were:\n$msg2") +} diff --git a/test/files/run/t6853.scala b/test/files/run/t6853.scala new file mode 100644 index 0000000000..352375c99c --- /dev/null +++ b/test/files/run/t6853.scala @@ -0,0 +1,18 @@ +// Test cases: the only place we can cut and paste without crying +// ourself to sleep. +object Test { + + def main(args: Array[String]): Unit = { + // First testing the basic operations + val m = collection.mutable.ListMap[String, Int]() + var i = 0 + while(i < 2) { m += ("foo" + i) -> i; i = i+1} + assert(m == Map("foo1"->1,"foo0"->0)) + m-= "foo0" + assert(m == Map("foo1"->1)) + // Now checking if it scales as described in SI-6853 + i = 0 + while(i < 80000) { m += ("foo" + i) -> i; i = i+1} + assert(m.size == 80000) + } +} diff --git a/test/files/run/t6968.check b/test/files/run/t6968.check new file mode 100644 index 0000000000..7a18941537 --- /dev/null +++ b/test/files/run/t6968.check @@ -0,0 +1 @@ +1, 3, 5 diff --git a/test/files/run/t6968.scala b/test/files/run/t6968.scala new file mode 100644 index 0000000000..b5cadfd9e1 --- /dev/null +++ b/test/files/run/t6968.scala @@ -0,0 +1,7 @@ +object Test { + def main(args: Array[String]) { + val mixedList = List(1,(1,2),4,(3,1),(5,4),6) + val as = for((a,b) <- mixedList) yield a + println(as.mkString(", ")) + } +} diff --git a/test/files/scalacheck/parallel-collections/ParallelMapCheck1.scala b/test/files/scalacheck/parallel-collections/ParallelMapCheck1.scala index 05237bace8..b6af8f41bd 100644 --- a/test/files/scalacheck/parallel-collections/ParallelMapCheck1.scala +++ b/test/files/scalacheck/parallel-collections/ParallelMapCheck1.scala @@ -20,7 +20,7 @@ abstract class ParallelMapCheck[K, V](collname: String) extends ParallelIterable property("gets iterated keys") = forAll(collectionPairs) { case (t, coll) => val containsT = for ((k, v) <- t) yield (coll.get(k) == Some(v)) - val containsSelf = for ((k, v) <- coll) yield (coll.get(k) == Some(v)) + val containsSelf = coll.map { case (k, v) => coll.get(k) == Some(v) } ("Par contains elements of seq map" |: containsT.forall(_ == true)) && ("Par contains elements of itself" |: containsSelf.forall(_ == true)) } diff --git a/test/pending/neg/t5378.scala b/test/pending/neg/t5378.scala deleted file mode 100644 index cada29b0a0..0000000000 --- a/test/pending/neg/t5378.scala +++ /dev/null @@ -1,19 +0,0 @@ -import language.reflectiveCalls - -class Coll[+T] { - def contains = new { def apply[T1 <: T](value: T1) = ??? } -} - -object Test { - def main(args: Array[String]): Unit = { - val xs = new Coll[List[String]] - val ys: Coll[Traversable[String]] = xs - - println(ys contains Nil) - // java.lang.NoSuchMethodException: Coll$$anon$1.apply(scala.collection.Traversable) - // at java.lang.Class.getMethod(Class.java:1605) - // at Test$.reflMethod$Method1(a.scala:14) - // at Test$.main(a.scala:14) - // at Test.main(a.scala) - } -} diff --git a/test/files/neg/t5589neg.check b/test/pending/neg/t5589neg.check index f1dad94df3..f1dad94df3 100644 --- a/test/files/neg/t5589neg.check +++ b/test/pending/neg/t5589neg.check diff --git a/test/files/neg/t5589neg.scala b/test/pending/neg/t5589neg.scala index 31ff2c3693..31ff2c3693 100644 --- a/test/files/neg/t5589neg.scala +++ b/test/pending/neg/t5589neg.scala diff --git a/test/files/neg/t5589neg2.scala b/test/pending/neg/t5589neg2.scala index b7c7ab7218..b7c7ab7218 100644 --- a/test/files/neg/t5589neg2.scala +++ b/test/pending/neg/t5589neg2.scala diff --git a/test/files/pos/t1336.scala b/test/pending/pos/t1336.scala index 63967985c7..63967985c7 100644 --- a/test/files/pos/t1336.scala +++ b/test/pending/pos/t1336.scala diff --git a/test/files/pos/t5589.scala b/test/pending/pos/t5589.scala index 69cbb20391..69cbb20391 100644 --- a/test/files/pos/t5589.scala +++ b/test/pending/pos/t5589.scala diff --git a/test/files/run/t4574.scala b/test/pending/run/t4574.scala index 1dde496aca..1dde496aca 100644 --- a/test/files/run/t4574.scala +++ b/test/pending/run/t4574.scala diff --git a/test/scaladoc/run/SI-6017.check b/test/scaladoc/run/SI-6017.check new file mode 100644 index 0000000000..619c56180b --- /dev/null +++ b/test/scaladoc/run/SI-6017.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/SI-6017.scala b/test/scaladoc/run/SI-6017.scala new file mode 100644 index 0000000000..a4950e48d8 --- /dev/null +++ b/test/scaladoc/run/SI-6017.scala @@ -0,0 +1,23 @@ +import scala.tools.nsc.doc +import scala.tools.nsc.doc.model._ +import scala.tools.nsc.doc.html.page.{Index, ReferenceIndex} +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def scaladocSettings = "" + override def code = """ + class STAR + class Star + """ + + def testModel(rootPackage: Package) { + model match { + case Some(universe) => { + val index = IndexModelFactory.makeIndex(universe) + // Because "STAR" and "Star" are different + assert(index.firstLetterIndex('s').keys.toSeq.length == 2) + } + case _ => assert(false) + } + } +} |