diff --git a/compiler/src-non-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src-non-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala deleted file mode 100644 index 265a27dc6711..000000000000 --- a/compiler/src-non-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala +++ /dev/null @@ -1,2882 +0,0 @@ -package scala.quoted -package runtime.impl - -import dotty.tools.dotc -import dotty.tools.dotc.ast.tpd -import dotty.tools.dotc.ast.untpd -import dotty.tools.dotc.core.Annotations -import dotty.tools.dotc.core.Contexts._ -import dotty.tools.dotc.core.Types -import dotty.tools.dotc.core.Flags._ -import dotty.tools.dotc.core.NameKinds -import dotty.tools.dotc.core.StdNames._ -import dotty.tools.dotc.quoted.reflect._ -import dotty.tools.dotc.quoted.QuoteUtils._ -import dotty.tools.dotc.core.Decorators._ - -import dotty.tools.dotc.quoted.{MacroExpansion, PickledQuotes, QuoteUtils} - -import scala.quoted.runtime.{QuoteUnpickler, QuoteMatching} -import scala.quoted.runtime.impl.printers._ - -import scala.reflect.TypeTest - -object QuotesImpl { - - type ScopeId = Int - - def apply()(using Context): Quotes = - new QuotesImpl - - def showDecompiledTree(tree: tpd.Tree)(using Context): String = - import qctx.reflect.Printer.{TreeCode, TreeAnsiCode} - val qctx: QuotesImpl = new QuotesImpl(using MacroExpansion.context(tree)) - if ctx.settings.color.value == "always" then TreeAnsiCode.show(tree) - else TreeCode.show(tree) - - def scopeId(using Context): ScopeId = - ctx.outersIterator.toList.last.hashCode() - -} - -class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler, QuoteMatching: - - private val yCheck: Boolean = - ctx.settings.Ycheck.value(using ctx).exists(x => x == "all" || x == "macros") - - extension [T](self: scala.quoted.Expr[T]) - def show: String = - reflect.Printer.TreeCode.show(reflect.asTerm(self)) - - def matches(that: scala.quoted.Expr[Any]): Boolean = - treeMatch(reflect.asTerm(self), reflect.asTerm(that)).nonEmpty - - end extension - - extension [X](self: scala.quoted.Expr[Any]) - /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */ - def isExprOf(using scala.quoted.Type[X]): Boolean = - reflect.TypeReprMethods.<:<(reflect.asTerm(self).tpe)(reflect.TypeRepr.of[X]) - - /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */ - def asExprOf(using scala.quoted.Type[X]): scala.quoted.Expr[X] = { - if self.isExprOf[X] then - self.asInstanceOf[scala.quoted.Expr[X]] - else - throw Exception( - s"""Expr cast exception: ${self.show} - |of type: ${reflect.Printer.TypeReprCode.show(reflect.asTerm(self).tpe)} - |did not conform to type: ${reflect.Printer.TypeReprCode.show(reflect.TypeRepr.of[X])} - |""".stripMargin - ) - } - end extension - - object reflect extends reflectModule: - - extension (expr: Expr[Any]) - def asTerm: Term = - val exprImpl = expr.asInstanceOf[ExprImpl] - exprImpl.checkScopeId(QuotesImpl.this.hashCode) - exprImpl.tree - end extension - - type Tree = tpd.Tree - - object Tree extends TreeModule - - given TreeMethods: TreeMethods with - extension (self: Tree) - def pos: Position = self.sourcePos - def symbol: Symbol = self.symbol - def show(using printer: Printer[Tree]): String = printer.show(self) - def isExpr: Boolean = - self match - case TermTypeTest(self) => - self.tpe.widen match - case _: MethodType | _: PolyType => false - case _ => true - case _ => false - def asExpr: scala.quoted.Expr[Any] = - if self.isExpr then - new ExprImpl(self, QuotesImpl.this.hashCode) - else self match - case TermTypeTest(self) => throw new Exception("Expected an expression. This is a partially applied Term. Try eta-expanding the term first.") - case _ => throw new Exception("Expected a Term but was: " + self) - end extension - - extension [T](self: Tree) - def asExprOf(using tp: scala.quoted.Type[T]): scala.quoted.Expr[T] = - QuotesImpl.this.asExprOf[T](self.asExpr)(using tp) - end extension - - extension [ThisTree <: Tree](self: ThisTree) - def changeOwner(newOwner: Symbol): ThisTree = - tpd.TreeOps(self).changeNonLocalOwners(newOwner).asInstanceOf[ThisTree] - end extension - - end TreeMethods - - type PackageClause = tpd.PackageDef - - object PackageClauseTypeTest extends TypeTest[Tree, PackageClause]: - def unapply(x: Tree): Option[PackageClause & x.type] = x match - case x: (tpd.PackageDef & x.type) => Some(x) - case _ => None - end PackageClauseTypeTest - - object PackageClause extends PackageClauseModule: - def apply(pid: Ref, stats: List[Tree]): PackageClause = - withDefaultPos(tpd.PackageDef(pid.asInstanceOf[tpd.RefTree], stats)) - def copy(original: Tree)(pid: Ref, stats: List[Tree]): PackageClause = - tpd.cpy.PackageDef(original)(pid, stats) - def unapply(tree: PackageClause): (Ref, List[Tree]) = - (tree.pid, tree.stats) - end PackageClause - - given PackageClauseMethods: PackageClauseMethods with - extension (self: PackageClause) - def pid: Ref = self.pid - def stats: List[Tree] = self.stats - end extension - end PackageClauseMethods - - type Import = tpd.Import - - object ImportTypeTest extends TypeTest[Tree, Import]: - def unapply(x: Tree): Option[Import & x.type] = x match - case tree: (tpd.Import & x.type) => Some(tree) - case _ => None - end ImportTypeTest - - object Import extends ImportModule: - def apply(expr: Term, selectors: List[Selector]): Import = - withDefaultPos(tpd.Import(expr, selectors)) - def copy(original: Tree)(expr: Term, selectors: List[Selector]): Import = - tpd.cpy.Import(original)(expr, selectors) - def unapply(tree: Import): (Term, List[Selector]) = - (tree.expr, tree.selectors) - end Import - - given ImportMethods: ImportMethods with - extension (self: Import) - def expr: Term = self.expr - def selectors: List[Selector] = self.selectors - end extension - end ImportMethods - - type Export = tpd.Export - - object ExportTypeTest extends TypeTest[Tree, Export]: - def unapply(x: Tree): Option[Export & x.type] = x match - case tree: (tpd.Export & x.type) => Some(tree) - case _ => None - end ExportTypeTest - - object Export extends ExportModule: - def unapply(tree: Export): (Term, List[Selector]) = - (tree.expr, tree.selectors) - end Export - - given ExportMethods: ExportMethods with - extension (self: Export) - def expr: Term = self.expr - def selectors: List[Selector] = self.selectors - end extension - end ExportMethods - - type Statement = tpd.Tree - - object StatementTypeTest extends TypeTest[Tree, Statement]: - def unapply(x: Tree): Option[Statement & x.type] = x match - case _: tpd.PatternTree => None - case _ => - if x.isTerm then TermTypeTest.unapply(x) - else DefinitionTypeTest.unapply(x) - end StatementTypeTest - - type Definition = tpd.MemberDef - - object DefinitionTypeTest extends TypeTest[Tree, Definition]: - def unapply(x: Tree): Option[Definition & x.type] = x match - case x: (tpd.MemberDef & x.type) => Some(x) - case _ => None - end DefinitionTypeTest - - object Definition extends DefinitionModule - - given DefinitionMethods: DefinitionMethods with - extension (self: Definition) - def name: String = self match - case self: tpd.MemberDef => self.name.toString - end extension - end DefinitionMethods - - type ClassDef = tpd.TypeDef - - object ClassDefTypeTest extends TypeTest[Tree, ClassDef]: - def unapply(x: Tree): Option[ClassDef & x.type] = x match - case x: (tpd.TypeDef & x.type) if x.isClassDef => Some(x) - case _ => None - end ClassDefTypeTest - - object ClassDef extends ClassDefModule: - def copy(original: Tree)(name: String, constr: DefDef, parents: List[Tree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement]): ClassDef = { - val dotc.ast.Trees.TypeDef(_, originalImpl: tpd.Template) = original - tpd.cpy.TypeDef(original)(name.toTypeName, tpd.cpy.Template(originalImpl)(constr, parents, derived, selfOpt.getOrElse(tpd.EmptyValDef), body)) - } - def unapply(cdef: ClassDef): (String, DefDef, List[Tree /* Term | TypeTree */], List[TypeTree], Option[ValDef], List[Statement]) = - val rhs = cdef.rhs.asInstanceOf[tpd.Template] - (cdef.name.toString, cdef.constructor, cdef.parents, rhs.derived.asInstanceOf[List[TypeTree]], cdef.self, rhs.body) - end ClassDef - - given ClassDefMethods: ClassDefMethods with - extension (self: ClassDef) - def constructor: DefDef = - self.rhs.asInstanceOf[tpd.Template].constr - def parents: List[Tree] = - self.rhs.asInstanceOf[tpd.Template].parents - def derived: List[TypeTree] = - self.rhs.asInstanceOf[tpd.Template].derived.asInstanceOf[List[TypeTree]] - def self: Option[ValDef] = - optional(self.rhs.asInstanceOf[tpd.Template].self) - def body: List[Statement] = - self.rhs.asInstanceOf[tpd.Template].body - end extension - end ClassDefMethods - - type DefDef = tpd.DefDef - - object DefDefTypeTest extends TypeTest[Tree, DefDef]: - def unapply(x: Tree): Option[DefDef & x.type] = x match - case x: (tpd.DefDef & x.type) => Some(x) - case _ => None - end DefDefTypeTest - - object DefDef extends DefDefModule: - def apply(symbol: Symbol, rhsFn: List[TypeRepr] => List[List[Term]] => Option[Term]): DefDef = - withDefaultPos(tpd.DefDef(symbol.asTerm, prefss => { - val (tparams, vparamss) = tpd.splitArgs(prefss) - yCheckedOwners(rhsFn(tparams.map(_.tpe))(vparamss), symbol).getOrElse(tpd.EmptyTree) - })) - def copy(original: Tree)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term]): DefDef = - tpd.cpy.DefDef(original)(name.toTermName, tpd.joinParams(typeParams, paramss), tpt, yCheckedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree)) - // def unapply(ddef: DefDef): (String, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term]) = - // (ddef.name.toString, ddef.typeParams, ddef.termParamss, ddef.tpt, optional(ddef.rhs)) - end DefDef - - given DefDefMethods: DefDefMethods with - extension (self: DefDef) - def typeParams: List[TypeDef] = self.leadingTypeParams // TODO: adapt to multiple type parameter clauses - // def paramss: List[List[ValDef]] = self.termParamss - def returnTpt: TypeTree = self.tpt - def rhs: Option[Term] = optional(self.rhs) - end extension - end DefDefMethods - - type ValDef = tpd.ValDef - - object ValDefTypeTest extends TypeTest[Tree, ValDef]: - def unapply(x: Tree): Option[ValDef & x.type] = x match - case x: (tpd.ValDef & x.type) => Some(x) - case _ => None - end ValDefTypeTest - - object ValDef extends ValDefModule: - def apply(symbol: Symbol, rhs: Option[Term]): ValDef = - tpd.ValDef(symbol.asTerm, yCheckedOwners(rhs, symbol).getOrElse(tpd.EmptyTree)) - def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef = - tpd.cpy.ValDef(original)(name.toTermName, tpt, yCheckedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree)) - def unapply(vdef: ValDef): (String, TypeTree, Option[Term]) = - (vdef.name.toString, vdef.tpt, optional(vdef.rhs)) - - def let(owner: Symbol, name: String, rhs: Term)(body: Ident => Term): Term = - val vdef = tpd.SyntheticValDef(name.toTermName, rhs)(using ctx.withOwner(owner)) - val ref = tpd.ref(vdef.symbol).asInstanceOf[Ident] - Block(List(vdef), body(ref)) - - def let(owner: Symbol, terms: List[Term])(body: List[Ident] => Term): Term = - val ctx1 = ctx.withOwner(owner) - val vdefs = terms.map(term => tpd.SyntheticValDef("x".toTermName, term)(using ctx1)) - val refs = vdefs.map(vdef => tpd.ref(vdef.symbol).asInstanceOf[Ident]) - Block(vdefs, body(refs)) - end ValDef - - given ValDefMethods: ValDefMethods with - extension (self: ValDef) - def tpt: TypeTree = self.tpt - def rhs: Option[Term] = optional(self.rhs) - end extension - end ValDefMethods - - type TypeDef = tpd.TypeDef - - object TypeDefTypeTest extends TypeTest[Tree, TypeDef]: - def unapply(x: Tree): Option[TypeDef & x.type] = x match - case x: (tpd.TypeDef & x.type) if !x.isClassDef => Some(x) - case _ => None - end TypeDefTypeTest - - object TypeDef extends TypeDefModule: - def apply(symbol: Symbol): TypeDef = - withDefaultPos(tpd.TypeDef(symbol.asType)) - def copy(original: Tree)(name: String, rhs: Tree): TypeDef = - tpd.cpy.TypeDef(original)(name.toTypeName, rhs) - def unapply(tdef: TypeDef): (String, Tree /*TypeTree | TypeBoundsTree*/ /* TypeTree | TypeBoundsTree */) = - (tdef.name.toString, tdef.rhs) - end TypeDef - - given TypeDefMethods: TypeDefMethods with - extension (self: TypeDef) - def rhs: Tree = self.rhs - end extension - end TypeDefMethods - - type Term = tpd.Tree - - object TermTypeTest extends TypeTest[Tree, Term]: - def unapply(x: Tree): Option[Term & x.type] = x match - case _ if UnapplyTypeTest.unapply(x).isDefined => None - case _: tpd.PatternTree => None - case x: (tpd.Tree & x.type) if x.isTerm => Some(x) - case x: (tpd.SeqLiteral & x.type) => Some(x) - case x: (tpd.Inlined & x.type) => Some(x) - case x: (tpd.NamedArg & x.type) => Some(x) - case _ => None - end TermTypeTest - - object Term extends TermModule: - def betaReduce(tree: Term): Option[Term] = - tree match - case app @ tpd.Apply(tpd.Select(fn, nme.apply), args) if dotc.core.Symbols.defn.isFunctionType(fn.tpe) => - val app1 = dotc.transform.BetaReduce(app, fn, args) - if app1 eq app then None - else Some(app1.withSpan(tree.span)) - case tpd.Block(Nil, expr) => - for e <- betaReduce(expr) yield tpd.cpy.Block(tree)(Nil, e) - case tpd.Inlined(_, Nil, expr) => - betaReduce(expr) - case _ => - None - end Term - - given TermMethods: TermMethods with - extension (self: Term) - def seal: scala.quoted.Expr[Any] = - if self.isExpr then new ExprImpl(self, QuotesImpl.this.hashCode) - else throw new Exception("Cannot seal a partially applied Term. Try eta-expanding the term first.") - - def sealOpt: Option[scala.quoted.Expr[Any]] = - if self.isExpr then Some(new ExprImpl(self, QuotesImpl.this.hashCode)) - else None - - def tpe: TypeRepr = self.tpe - def underlyingArgument: Term = new tpd.TreeOps(self).underlyingArgument - def underlying: Term = new tpd.TreeOps(self).underlying - def etaExpand(owner: Symbol): Term = self.tpe.widen match { - case mtpe: Types.MethodType if !mtpe.isParamDependent => - val closureResType = mtpe.resType match { - case t: Types.MethodType => t.toFunctionType() - case t => t - } - val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType) - val closureMethod = dotc.core.Symbols.newSymbol(owner, nme.ANON_FUN, Synthetic | Method, closureTpe) - tpd.Closure(closureMethod, tss => new tpd.TreeOps(self).appliedToTermArgs(tss.head).etaExpand(closureMethod)) - case _ => self - } - - def appliedTo(arg: Term): Term = - self.appliedToArgs(arg :: Nil) - def appliedTo(arg: Term, args: Term*): Term = - self.appliedToArgs(arg :: args.toList) - def appliedToArgs(args: List[Term]): Apply = - Apply(self, args) - def appliedToArgss(argss: List[List[Term]]): Term = - argss.foldLeft(self: Term)(Apply(_, _)) - def appliedToNone: Apply = - self.appliedToArgs(Nil) - def appliedToType(targ: TypeRepr): Term = - self.appliedToTypes(targ :: Nil) - def appliedToTypes(targs: List[TypeRepr]): Term = - self.appliedToTypeTrees(targs map (Inferred(_))) - def appliedToTypeTrees(targs: List[TypeTree]): Term = - if (targs.isEmpty) self else TypeApply(self, targs) - def select(sym: Symbol): Select = Select(self, sym) - - end extension - end TermMethods - - type Ref = tpd.RefTree - - object RefTypeTest extends TypeTest[Tree, Ref]: - def unapply(x: Tree): Option[Ref & x.type] = x match - case x: (tpd.RefTree & x.type) if x.isTerm => Some(x) - case _ => None - end RefTypeTest - - object Ref extends RefModule: - def term(tp: TermRef): Ref = - withDefaultPos(tpd.ref(tp).asInstanceOf[tpd.RefTree]) - def apply(sym: Symbol): Ref = - assert(sym.isTerm) - withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.RefTree]) - end Ref - - type Ident = tpd.Ident - - object IdentTypeTest extends TypeTest[Tree, Ident]: - def unapply(x: Tree): Option[Ident & x.type] = x match - case x: (tpd.Ident & x.type) if x.isTerm => Some(x) - case _ => None - end IdentTypeTest - - object Ident extends IdentModule: - def apply(tmref: TermRef): Term = - withDefaultPos(tpd.ref(tmref).asInstanceOf[Term]) - def copy(original: Tree)(name: String): Ident = - tpd.cpy.Ident(original)(name.toTermName) - def unapply(tree: Ident): Some[String] = - Some(tree.name.toString) - end Ident - - given IdentMethods: IdentMethods with - extension (self: Ident) - def name: String = self.name.toString - end extension - end IdentMethods - - type Select = tpd.Select - - object SelectTypeTest extends TypeTest[Tree, Select]: - def unapply(x: Tree): Option[Select & x.type] = x match - case x: (tpd.Select & x.type) if x.isTerm => Some(x) - case _ => None - end SelectTypeTest - - object Select extends SelectModule: - def apply(qualifier: Term, symbol: Symbol): Select = - withDefaultPos(tpd.Select(qualifier, Types.TermRef(qualifier.tpe, symbol))) - def unique(qualifier: Term, name: String): Select = - val denot = qualifier.tpe.member(name.toTermName) - assert(!denot.isOverloaded, s"The symbol `$name` is overloaded. The method Select.unique can only be used for non-overloaded symbols.") - withDefaultPos(tpd.Select(qualifier, name.toTermName)) - def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term]): Apply = - withDefaultPos(tpd.applyOverloaded(qualifier, name.toTermName, args, targs, Types.WildcardType).asInstanceOf[Apply]) - - def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term], returnType: TypeRepr): Apply = - withDefaultPos(tpd.applyOverloaded(qualifier, name.toTermName, args, targs, returnType).asInstanceOf[Apply]) - def copy(original: Tree)(qualifier: Term, name: String): Select = - tpd.cpy.Select(original)(qualifier, name.toTermName) - def unapply(x: Select): (Term, String) = - (x.qualifier, x.name.toString) - end Select - - given SelectMethods: SelectMethods with - extension (self: Select) - def qualifier: Term = self.qualifier - def name: String = self.name.toString - def signature: Option[Signature] = - if self.symbol.signature == dotc.core.Signature.NotAMethod then None - else Some(self.symbol.signature) - end extension - end SelectMethods - - type Literal = tpd.Literal - - object LiteralTypeTest extends TypeTest[Tree, Literal]: - def unapply(x: Tree): Option[Literal & x.type] = x match - case x: (tpd.Literal & x.type) => Some(x) - case _ => None - end LiteralTypeTest - - object Literal extends LiteralModule: - def apply(constant: Constant): Literal = - withDefaultPos(tpd.Literal(constant)) - def copy(original: Tree)(constant: Constant): Literal = - tpd.cpy.Literal(original)(constant) - def unapply(x: Literal): Some[Constant] = - Some(x.constant) - end Literal - - given LiteralMethods: LiteralMethods with - extension (self: Literal) - def constant: Constant = self.const - end extension - end LiteralMethods - - type This = tpd.This - - object ThisTypeTest extends TypeTest[Tree, This]: - def unapply(x: Tree): Option[This & x.type] = x match - case x: (tpd.This & x.type) => Some(x) - case _ => None - end ThisTypeTest - - object This extends ThisModule: - def apply(cls: Symbol): This = - withDefaultPos(tpd.This(cls.asClass)) - def copy(original: Tree)(qual: Option[String]): This = - tpd.cpy.This(original)(qual.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent)) - def unapply(x: This): Some[Option[String]] = - Some(optional(x.qual).map(_.name.toString)) - end This - - given ThisMethods: ThisMethods with - extension (self: This) - def id: Option[String] = optional(self.qual).map(_.name.toString) - end extension - end ThisMethods - - type New = tpd.New - - object NewTypeTest extends TypeTest[Tree, New]: - def unapply(x: Tree): Option[New & x.type] = x match - case x: (tpd.New & x.type) => Some(x) - case _ => None - end NewTypeTest - - object New extends NewModule: - def apply(tpt: TypeTree): New = - withDefaultPos(tpd.New(tpt)) - def copy(original: Tree)(tpt: TypeTree): New = - tpd.cpy.New(original)(tpt) - def unapply(x: New): Some[TypeTree] = Some(x.tpt) - end New - - given NewMethods: NewMethods with - extension (self: New) - def tpt: TypeTree = self.tpt - end extension - end NewMethods - - type NamedArg = tpd.NamedArg - - object NamedArgTypeTest extends TypeTest[Tree, NamedArg]: - def unapply(x: Tree): Option[NamedArg & x.type] = x match - case x: (tpd.NamedArg & x.type) if x.name.isInstanceOf[dotc.core.Names.TermName] => Some(x) // TODO: Now, the name should alwas be a term name - case _ => None - end NamedArgTypeTest - - object NamedArg extends NamedArgModule: - def apply(name: String, arg: Term): NamedArg = - withDefaultPos(tpd.NamedArg(name.toTermName, arg)) - def copy(original: Tree)(name: String, arg: Term): NamedArg = - tpd.cpy.NamedArg(original)(name.toTermName, arg) - def unapply(x: NamedArg): (String, Term) = - (x.name.toString, x.value) - end NamedArg - - given NamedArgMethods: NamedArgMethods with - extension (self: NamedArg) - def name: String = self.name.toString - def value: Term = self.arg - end extension - end NamedArgMethods - - type Apply = tpd.Apply - - object ApplyTypeTest extends TypeTest[Tree, Apply]: - def unapply(x: Tree): Option[Apply & x.type] = x match - case x: (tpd.Apply & x.type) => Some(x) - case _ => None - end ApplyTypeTest - - object Apply extends ApplyModule: - def apply(fun: Term, args: List[Term]): Apply = - withDefaultPos(tpd.Apply(fun, args)) - def copy(original: Tree)(fun: Term, args: List[Term]): Apply = - tpd.cpy.Apply(original)(fun, args) - def unapply(x: Apply): (Term, List[Term]) = - (x.fun, x.args) - end Apply - - given ApplyMethods: ApplyMethods with - extension (self: Apply) - def fun: Term = self.fun - def args: List[Term] = self.args - end extension - end ApplyMethods - - type TypeApply = tpd.TypeApply - - object TypeApplyTypeTest extends TypeTest[Tree, TypeApply]: - def unapply(x: Tree): Option[TypeApply & x.type] = x match - case x: (tpd.TypeApply & x.type) => Some(x) - case _ => None - end TypeApplyTypeTest - - object TypeApply extends TypeApplyModule: - def apply(fun: Term, args: List[TypeTree]): TypeApply = - withDefaultPos(tpd.TypeApply(fun, args)) - def copy(original: Tree)(fun: Term, args: List[TypeTree]): TypeApply = - tpd.cpy.TypeApply(original)(fun, args) - def unapply(x: TypeApply): (Term, List[TypeTree]) = - (x.fun, x.args) - end TypeApply - - given TypeApplyMethods: TypeApplyMethods with - extension (self: TypeApply) - def fun: Term = self.fun - def args: List[TypeTree] = self.args - end extension - end TypeApplyMethods - - type Super = tpd.Super - - object SuperTypeTest extends TypeTest[Tree, Super]: - def unapply(x: Tree): Option[Super & x.type] = x match - case x: (tpd.Super & x.type) => Some(x) - case _ => None - end SuperTypeTest - - object Super extends SuperModule: - def apply(qual: Term, mix: Option[String]): Super = - withDefaultPos(tpd.Super(qual, mix.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent), dotc.core.Symbols.NoSymbol)) - def copy(original: Tree)(qual: Term, mix: Option[String]): Super = - tpd.cpy.Super(original)(qual, mix.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent)) - def unapply(x: Super): (Term, Option[String]) = - (x.qualifier, x.id) - end Super - - given SuperMethods: SuperMethods with - extension (self: Super) - def qualifier: Term = self.qual - def id: Option[String] = optional(self.mix).map(_.name.toString) - def idPos: Position = self.mix.sourcePos - end extension - end SuperMethods - - type Typed = tpd.Typed - - object TypedTypeTest extends TypeTest[Tree, Typed]: - def unapply(x: Tree): Option[Typed & x.type] = x match - case x: (tpd.Typed & x.type) => Some(x) - case _ => None - end TypedTypeTest - - object Typed extends TypedModule: - def apply(expr: Term, tpt: TypeTree): Typed = - withDefaultPos(tpd.Typed(expr, tpt)) - def copy(original: Tree)(expr: Term, tpt: TypeTree): Typed = - tpd.cpy.Typed(original)(expr, tpt) - def unapply(x: Typed): (Term, TypeTree) = - (x.expr, x.tpt) - end Typed - - given TypedMethods: TypedMethods with - extension (self: Typed) - def expr: Term = self.expr - def tpt: TypeTree = self.tpt - end extension - end TypedMethods - - type Assign = tpd.Assign - - object AssignTypeTest extends TypeTest[Tree, Assign]: - def unapply(x: Tree): Option[Assign & x.type] = x match - case x: (tpd.Assign & x.type) => Some(x) - case _ => None - end AssignTypeTest - - object Assign extends AssignModule: - def apply(lhs: Term, rhs: Term): Assign = - withDefaultPos(tpd.Assign(lhs, rhs)) - def copy(original: Tree)(lhs: Term, rhs: Term): Assign = - tpd.cpy.Assign(original)(lhs, rhs) - def unapply(x: Assign): (Term, Term) = - (x.lhs, x.rhs) - end Assign - - given AssignMethods: AssignMethods with - extension (self: Assign) - def lhs: Term = self.lhs - def rhs: Term = self.rhs - end extension - end AssignMethods - - type Block = tpd.Block - - object BlockTypeTest extends TypeTest[Tree, Block]: - def unapply(x: Tree): Option[Block & x.type] = x match - case x: (tpd.Block & x.type) => Some(x) - case _ => None - end BlockTypeTest - - object Block extends BlockModule: - def apply(stats: List[Statement], expr: Term): Block = - withDefaultPos(tpd.Block(stats, expr)) - def copy(original: Tree)(stats: List[Statement], expr: Term): Block = - tpd.cpy.Block(original)(stats, expr) - def unapply(x: Block): (List[Statement], Term) = - (x.statements, x.expr) - end Block - - given BlockMethods: BlockMethods with - extension (self: Block) - def statements: List[Statement] = self.stats - def expr: Term = self.expr - end extension - end BlockMethods - - type Closure = tpd.Closure - - object ClosureTypeTest extends TypeTest[Tree, Closure]: - def unapply(x: Tree): Option[Closure & x.type] = x match - case x: (tpd.Closure & x.type) => Some(x) - case _ => None - end ClosureTypeTest - - object Closure extends ClosureModule: - def apply(meth: Term, tpe: Option[TypeRepr]): Closure = - withDefaultPos(tpd.Closure(Nil, meth, tpe.map(tpd.TypeTree(_)).getOrElse(tpd.EmptyTree))) - def copy(original: Tree)(meth: Tree, tpe: Option[TypeRepr]): Closure = - tpd.cpy.Closure(original)(Nil, meth, tpe.map(tpd.TypeTree(_)).getOrElse(tpd.EmptyTree)) - def unapply(x: Closure): (Term, Option[TypeRepr]) = - (x.meth, x.tpeOpt) - end Closure - - given ClosureMethods: ClosureMethods with - extension (self: Closure) - def meth: Term = self.meth - def tpeOpt: Option[TypeRepr] = optional(self.tpt).map(_.tpe) - end extension - end ClosureMethods - - object Lambda extends LambdaModule: - def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block = - val meth = dotc.core.Symbols.newSymbol(owner, nme.ANON_FUN, Synthetic | Method, tpe) - tpd.Closure(meth, tss => yCheckedOwners(rhsFn(meth, tss.head), meth)) - - def unapply(tree: Block): Option[(List[ValDef], Term)] = ??? - end Lambda - - type If = tpd.If - - object IfTypeTest extends TypeTest[Tree, If]: - def unapply(x: Tree): Option[If & x.type] = x match - case x: (tpd.If & x.type) => Some(x) - case _ => None - end IfTypeTest - - object If extends IfModule: - def apply(cond: Term, thenp: Term, elsep: Term): If = - withDefaultPos(tpd.If(cond, thenp, elsep)) - def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term): If = - tpd.cpy.If(original)(cond, thenp, elsep) - def unapply(tree: If): (Term, Term, Term) = - (tree.cond, tree.thenp, tree.elsep) - end If - - given IfMethods: IfMethods with - extension (self: If) - def cond: Term = self.cond - def thenp: Term = self.thenp - def elsep: Term = self.elsep - def isInline: Boolean = self.isInline - end extension - end IfMethods - - type Match = tpd.Match - - object MatchTypeTest extends TypeTest[Tree, Match]: - def unapply(x: Tree): Option[Match & x.type] = x match - case x: (tpd.Match & x.type) if !x.selector.isEmpty => Some(x) - case _ => None - end MatchTypeTest - - object Match extends MatchModule: - def apply(selector: Term, cases: List[CaseDef]): Match = - withDefaultPos(tpd.Match(selector, cases)) - - def copy(original: Tree)(selector: Term, cases: List[CaseDef]): Match = - tpd.cpy.Match(original)(selector, cases) - - def unapply(x: Match): (Term, List[CaseDef]) = - (x.scrutinee, x.cases) - end Match - - given MatchMethods: MatchMethods with - extension (self: Match) - def scrutinee: Term = self.selector - def cases: List[CaseDef] = self.cases - def isInline: Boolean = self.isInline - end extension - end MatchMethods - - type SummonFrom = tpd.Match - - object SummonFromTypeTest extends TypeTest[Tree, SummonFrom]: - def unapply(x: Tree): Option[SummonFrom & x.type] = x match - case x: (tpd.Match & x.type) if x.selector.isEmpty => Some(x) - case _ => None - end SummonFromTypeTest - - object SummonFrom extends SummonFromModule: - def apply(cases: List[CaseDef]): SummonFrom = - withDefaultPos(tpd.Match(tpd.EmptyTree, cases)) - def copy(original: Tree)(cases: List[CaseDef]): SummonFrom = - tpd.cpy.Match(original)(tpd.EmptyTree, cases) - def unapply(x: SummonFrom): Some[List[CaseDef]] = - Some(x.cases) - end SummonFrom - - given SummonFromMethods: SummonFromMethods with - extension (self: SummonFrom) - def cases: List[CaseDef] = self.cases - end extension - end SummonFromMethods - - type Try = tpd.Try - - object TryTypeTest extends TypeTest[Tree, Try]: - def unapply(x: Tree): Option[Try & x.type] = x match - case x: (tpd.Try & x.type) => Some(x) - case _ => None - end TryTypeTest - - object Try extends TryModule: - def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try = - withDefaultPos(tpd.Try(expr, cases, finalizer.getOrElse(tpd.EmptyTree))) - def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try = - tpd.cpy.Try(original)(expr, cases, finalizer.getOrElse(tpd.EmptyTree)) - def unapply(x: Try): (Term, List[CaseDef], Option[Term]) = - (x.body, x.cases, optional(x.finalizer)) - end Try - - given TryMethods: TryMethods with - extension (self: Try) - def body: Term = self.expr - def cases: List[CaseDef] = self.cases - def finalizer: Option[Term] = optional(self.finalizer) - end extension - end TryMethods - - type Return = tpd.Return - - object ReturnTypeTest extends TypeTest[Tree, Return]: - def unapply(x: Tree): Option[Return & x.type] = x match - case x: (tpd.Return & x.type) => Some(x) - case _ => None - end ReturnTypeTest - - object Return extends ReturnModule: - def apply(expr: Term, from: Symbol): Return = - withDefaultPos(tpd.Return(expr, from)) - def copy(original: Tree)(expr: Term, from: Symbol): Return = - tpd.cpy.Return(original)(expr, tpd.ref(from)) - def unapply(x: Return): (Term, Symbol) = - (x.expr, x.from.symbol) - end Return - - given ReturnMethods: ReturnMethods with - extension (self: Return) - def expr: Term = self.expr - def from: Symbol = self.from.symbol - end extension - end ReturnMethods - - type Repeated = tpd.SeqLiteral - - object RepeatedTypeTest extends TypeTest[Tree, Repeated]: - def unapply(x: Tree): Option[Repeated & x.type] = x match - case x: (tpd.SeqLiteral & x.type) => Some(x) - case _ => None - end RepeatedTypeTest - - object Repeated extends RepeatedModule: - def apply(elems: List[Term], elemtpt: TypeTree): Repeated = - withDefaultPos(tpd.SeqLiteral(elems, elemtpt)) - def copy(original: Tree)(elems: List[Term], elemtpt: TypeTree): Repeated = - tpd.cpy.SeqLiteral(original)(elems, elemtpt) - def unapply(x: Repeated): (List[Term], TypeTree) = - (x.elems, x.elemtpt) - end Repeated - - given RepeatedMethods: RepeatedMethods with - extension (self: Repeated) - def elems: List[Term] = self.elems - def elemtpt: TypeTree = self.elemtpt - end extension - end RepeatedMethods - - type Inlined = tpd.Inlined - - object InlinedTypeTest extends TypeTest[Tree, Inlined]: - def unapply(x: Tree): Option[Inlined & x.type] = x match - case x: (tpd.Inlined & x.type) => Some(x) - case _ => None - end InlinedTypeTest - - object Inlined extends InlinedModule: - def apply(call: Option[Tree], bindings: List[Definition], expansion: Term): Inlined = - withDefaultPos(tpd.Inlined(call.getOrElse(tpd.EmptyTree), bindings.map { case b: tpd.MemberDef => b }, expansion)) - def copy(original: Tree)(call: Option[Tree], bindings: List[Definition], expansion: Term): Inlined = - tpd.cpy.Inlined(original)(call.getOrElse(tpd.EmptyTree), bindings.asInstanceOf[List[tpd.MemberDef]], expansion) - def unapply(x: Inlined): (Option[Tree /* Term | TypeTree */], List[Definition], Term) = - (optional(x.call), x.bindings, x.body) - end Inlined - - given InlinedMethods: InlinedMethods with - extension (self: Inlined) - def call: Option[Tree] = optional(self.call) - def bindings: List[Definition] = self.bindings - def body: Term = self.expansion - end extension - end InlinedMethods - - type SelectOuter = tpd.Select - - object SelectOuterTypeTest extends TypeTest[Tree, SelectOuter]: - def unapply(x: Tree): Option[SelectOuter & x.type] = x match - case x: (tpd.Select & x.type) => - x.name match - case NameKinds.OuterSelectName(_, _) => Some(x) - case _ => None - case _ => None - end SelectOuterTypeTest - - object SelectOuter extends SelectOuterModule: - def apply(qualifier: Term, name: String, levels: Int): SelectOuter = - withDefaultPos(tpd.Select(qualifier, NameKinds.OuterSelectName(name.toTermName, levels))) - def copy(original: Tree)(qualifier: Term, name: String, levels: Int): SelectOuter = - tpd.cpy.Select(original)(qualifier, NameKinds.OuterSelectName(name.toTermName, levels)) - def unapply(x: SelectOuter): (Term, String, Int) = - (x.qualifier, x.name.toString, x.level) - end SelectOuter - - given SelectOuterMethods: SelectOuterMethods with - extension (self: SelectOuter) - def qualifier: Term = self.qualifier - def name: String = self.name.toString - def level: Int = - val NameKinds.OuterSelectName(_, levels) = self.name - levels - end extension - end SelectOuterMethods - - type While = tpd.WhileDo - - object WhileTypeTest extends TypeTest[Tree, While]: - def unapply(x: Tree): Option[While & x.type] = x match - case x: (tpd.WhileDo & x.type) => Some(x) - case _ => None - end WhileTypeTest - - object While extends WhileModule: - def apply(cond: Term, body: Term): While = - withDefaultPos(tpd.WhileDo(cond, body)) - def copy(original: Tree)(cond: Term, body: Term): While = - tpd.cpy.WhileDo(original)(cond, body) - def unapply(x: While): (Term, Term) = - (x.cond, x.body) - end While - - given WhileMethods: WhileMethods with - extension (self: While) - def cond: Term = self.cond - def body: Term = self.body - end extension - end WhileMethods - - type TypeTree = tpd.Tree - - object TypeTreeTypeTest extends TypeTest[Tree, TypeTree]: - def unapply(x: Tree): Option[TypeTree & x.type] = x match - case x: (tpd.TypeBoundsTree & x.type) => None - case x: (tpd.Tree & x.type) if x.isType => Some(x) - case _ => None - end TypeTreeTypeTest - - object TypeTree extends TypeTreeModule: - def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree = - tp.asInstanceOf[TypeImpl].typeTree - end TypeTree - - given TypeTreeMethods: TypeTreeMethods with - extension (self: TypeTree) - def tpe: TypeRepr = self.tpe.stripTypeVar - end extension - end TypeTreeMethods - - type Inferred = tpd.TypeTree - - object InferredTypeTest extends TypeTest[Tree, Inferred]: - def unapply(x: Tree): Option[Inferred & x.type] = x match - case tpt: (tpd.TypeTree & x.type) if !tpt.tpe.isInstanceOf[Types.TypeBounds] => Some(tpt) - case _ => None - end InferredTypeTest - - object Inferred extends InferredModule: - def apply(tpe: TypeRepr): Inferred = - withDefaultPos(tpd.TypeTree(tpe)) - def unapply(x: Inferred): true = true - end Inferred - - type TypeIdent = tpd.Ident - - object TypeIdentTypeTest extends TypeTest[Tree, TypeIdent]: - def unapply(x: Tree): Option[TypeIdent & x.type] = x match - case tpt: (tpd.Ident & x.type) if tpt.isType => Some(tpt) - case _ => None - end TypeIdentTypeTest - - object TypeIdent extends TypeIdentModule: - def apply(sym: Symbol): TypeTree = - assert(sym.isType) - withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.TypeTree]) - def copy(original: Tree)(name: String): TypeIdent = - tpd.cpy.Ident(original)(name.toTypeName) - def unapply(x: TypeIdent): Some[String] = - Some(x.name.toString) - end TypeIdent - - given TypeIdentMethods: TypeIdentMethods with - extension (self: TypeIdent) - def name: String = self.name.toString - end extension - end TypeIdentMethods - - type TypeSelect = tpd.Select - - object TypeSelectTypeTest extends TypeTest[Tree, TypeSelect]: - def unapply(x: Tree): Option[TypeSelect & x.type] = x match - case tpt: (tpd.Select & x.type) if tpt.isType && tpt.qualifier.isTerm => Some(tpt) - case _ => None - end TypeSelectTypeTest - - object TypeSelect extends TypeSelectModule: - def apply(qualifier: Term, name: String): TypeSelect = - withDefaultPos(tpd.Select(qualifier, name.toTypeName)) - def copy(original: Tree)(qualifier: Term, name: String): TypeSelect = - tpd.cpy.Select(original)(qualifier, name.toTypeName) - def unapply(x: TypeSelect): (Term, String) = - (x.qualifier, x.name.toString) - end TypeSelect - - given TypeSelectMethods: TypeSelectMethods with - extension (self: TypeSelect) - def qualifier: Term = self.qualifier - def name: String = self.name.toString - end extension - end TypeSelectMethods - - type TypeProjection = tpd.Select - - object TypeProjectionTypeTest extends TypeTest[Tree, TypeProjection]: - def unapply(x: Tree): Option[TypeProjection & x.type] = x match - case tpt: (tpd.Select & x.type) if tpt.isType && tpt.qualifier.isType => Some(tpt) - case _ => None - end TypeProjectionTypeTest - - object TypeProjection extends TypeProjectionModule: - def copy(original: Tree)(qualifier: TypeTree, name: String): TypeProjection = - tpd.cpy.Select(original)(qualifier, name.toTypeName) - def unapply(x: TypeProjection): (TypeTree, String) = - (x.qualifier, x.name.toString) - end TypeProjection - - given TypeProjectionMethods: TypeProjectionMethods with - extension (self: TypeProjection) - def qualifier: TypeTree = self.qualifier - def name: String = self.name.toString - end extension - end TypeProjectionMethods - - type Singleton = tpd.SingletonTypeTree - - object SingletonTypeTest extends TypeTest[Tree, Singleton]: - def unapply(x: Tree): Option[Singleton & x.type] = x match - case tpt: (tpd.SingletonTypeTree & x.type) => Some(tpt) - case _ => None - end SingletonTypeTest - - object Singleton extends SingletonModule: - def apply(ref: Term): Singleton = - withDefaultPos(tpd.SingletonTypeTree(ref)) - def copy(original: Tree)(ref: Term): Singleton = - tpd.cpy.SingletonTypeTree(original)(ref) - def unapply(x: Singleton): Some[Term] = - Some(x.ref) - end Singleton - - given SingletonMethods: SingletonMethods with - extension (self: Singleton) - def ref: Term = self.ref - end extension - end SingletonMethods - - type Refined = tpd.RefinedTypeTree - - object RefinedTypeTest extends TypeTest[Tree, Refined]: - def unapply(x: Tree): Option[Refined & x.type] = x match - case tpt: (tpd.RefinedTypeTree & x.type) => Some(tpt) - case _ => None - end RefinedTypeTest - - object Refined extends RefinedModule: - def copy(original: Tree)(tpt: TypeTree, refinements: List[Definition]): Refined = - tpd.cpy.RefinedTypeTree(original)(tpt, refinements) - def unapply(x: Refined): (TypeTree, List[Definition]) = - (x.tpt, x.refinements.asInstanceOf[List[Definition]]) - end Refined - - given RefinedMethods: RefinedMethods with - extension (self: Refined) - def tpt: TypeTree = self.tpt - def refinements: List[Definition] = self.refinements.asInstanceOf[List[Definition]] - end extension - end RefinedMethods - - type Applied = tpd.AppliedTypeTree - - object AppliedTypeTest extends TypeTest[Tree, Applied]: - def unapply(x: Tree): Option[Applied & x.type] = x match - case tpt: (tpd.AppliedTypeTree & x.type) => Some(tpt) - case _ => None - end AppliedTypeTest - - object Applied extends AppliedModule: - def apply(tpt: TypeTree, args: List[Tree]): Applied = - withDefaultPos(tpd.AppliedTypeTree(tpt, args)) - def copy(original: Tree)(tpt: TypeTree, args: List[Tree]): Applied = - tpd.cpy.AppliedTypeTree(original)(tpt, args) - def unapply(x: Applied): (TypeTree, List[Tree /*TypeTree | TypeBoundsTree*/]) = - (x.tpt, x.args) - end Applied - - given AppliedMethods: AppliedMethods with - extension (self: Applied) - def tpt: TypeTree = self.tpt - def args: List[Tree] = self.args - end extension - end AppliedMethods - - type Annotated = tpd.Annotated - - object AnnotatedTypeTest extends TypeTest[Tree, Annotated]: - def unapply(x: Tree): Option[Annotated & x.type] = x match - case tpt: (tpd.Annotated & x.type) => Some(tpt) - case _ => None - end AnnotatedTypeTest - - object Annotated extends AnnotatedModule: - def apply(arg: TypeTree, annotation: Term): Annotated = - withDefaultPos(tpd.Annotated(arg, annotation)) - def copy(original: Tree)(arg: TypeTree, annotation: Term): Annotated = - tpd.cpy.Annotated(original)(arg, annotation) - def unapply(x: Annotated): (TypeTree, Term) = - (x.arg, x.annotation) - end Annotated - - given AnnotatedMethods: AnnotatedMethods with - extension (self: Annotated) - def arg: TypeTree = self.arg - def annotation: Term = self.annot - end extension - end AnnotatedMethods - - type MatchTypeTree = tpd.MatchTypeTree - - object MatchTypeTreeTypeTest extends TypeTest[Tree, MatchTypeTree]: - def unapply(x: Tree): Option[MatchTypeTree & x.type] = x match - case tpt: (tpd.MatchTypeTree & x.type) => Some(tpt) - case _ => None - end MatchTypeTreeTypeTest - - object MatchTypeTree extends MatchTypeTreeModule: - def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef]): MatchTypeTree = - withDefaultPos(tpd.MatchTypeTree(bound.getOrElse(tpd.EmptyTree), selector, cases)) - def copy(original: Tree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef]): MatchTypeTree = - tpd.cpy.MatchTypeTree(original)(bound.getOrElse(tpd.EmptyTree), selector, cases) - def unapply(x: MatchTypeTree): (Option[TypeTree], TypeTree, List[TypeCaseDef]) = - (optional(x.bound), x.selector, x.cases) - end MatchTypeTree - - given MatchTypeTreeMethods: MatchTypeTreeMethods with - extension (self: MatchTypeTree) - def bound: Option[TypeTree] = optional(self.bound) - def selector: TypeTree = self.selector - def cases: List[TypeCaseDef] = self.cases - end extension - end MatchTypeTreeMethods - - type ByName = tpd.ByNameTypeTree - - object ByNameTypeTest extends TypeTest[Tree, ByName]: - def unapply(x: Tree): Option[ByName & x.type] = x match - case tpt: (tpd.ByNameTypeTree & x.type) => Some(tpt) - case _ => None - end ByNameTypeTest - - object ByName extends ByNameModule: - def apply(result: TypeTree): ByName = - withDefaultPos(tpd.ByNameTypeTree(result)) - def copy(original: Tree)(result: TypeTree): ByName = - tpd.cpy.ByNameTypeTree(original)(result) - def unapply(x: ByName): Some[TypeTree] = - Some(x.result) - end ByName - - given ByNameMethods: ByNameMethods with - extension (self: ByName) - def result: TypeTree = self.result - end extension - end ByNameMethods - - type LambdaTypeTree = tpd.LambdaTypeTree - - object LambdaTypeTreeTypeTest extends TypeTest[Tree, LambdaTypeTree]: - def unapply(x: Tree): Option[LambdaTypeTree & x.type] = x match - case tpt: (tpd.LambdaTypeTree & x.type) => Some(tpt) - case _ => None - end LambdaTypeTreeTypeTest - - object LambdaTypeTree extends LambdaTypeTreeModule: - def apply(tparams: List[TypeDef], body: Tree): LambdaTypeTree = - withDefaultPos(tpd.LambdaTypeTree(tparams, body)) - def copy(original: Tree)(tparams: List[TypeDef], body: Tree): LambdaTypeTree = - tpd.cpy.LambdaTypeTree(original)(tparams, body) - def unapply(tree: LambdaTypeTree): (List[TypeDef], Tree /*TypeTree | TypeBoundsTree*/) = - (tree.tparams, tree.body) - end LambdaTypeTree - - given LambdaTypeTreeMethods: LambdaTypeTreeMethods with - extension (self: LambdaTypeTree) - def tparams: List[TypeDef] = self.tparams - def body: Tree = self.body - end extension - end LambdaTypeTreeMethods - - type TypeBind = tpd.Bind - - object TypeBindTypeTest extends TypeTest[Tree, TypeBind]: - def unapply(x: Tree): Option[TypeBind & x.type] = x match - case tpt: (tpd.Bind & x.type) if tpt.name.isTypeName => Some(tpt) - case _ => None - end TypeBindTypeTest - - object TypeBind extends TypeBindModule: - def copy(original: Tree)(name: String, tpt: Tree): TypeBind = - tpd.cpy.Bind(original)(name.toTypeName, tpt) - def unapply(x: TypeBind): (String, Tree /*TypeTree | TypeBoundsTree*/) = - (x.name.toString, x.body) - end TypeBind - - given TypeBindMethods: TypeBindMethods with - extension (self: TypeBind) - def name: String = self.name.toString - def body: Tree = self.body - end extension - end TypeBindMethods - - type TypeBlock = tpd.Block - - object TypeBlockTypeTest extends TypeTest[Tree, TypeBlock]: - def unapply(x: Tree): Option[TypeBlock & x.type] = x match - case tpt: (tpd.Block & x.type) => Some(tpt) - case _ => None - end TypeBlockTypeTest - - object TypeBlock extends TypeBlockModule: - def apply(aliases: List[TypeDef], tpt: TypeTree): TypeBlock = - withDefaultPos(tpd.Block(aliases, tpt)) - def copy(original: Tree)(aliases: List[TypeDef], tpt: TypeTree): TypeBlock = - tpd.cpy.Block(original)(aliases, tpt) - def unapply(x: TypeBlock): (List[TypeDef], TypeTree) = - (x.aliases, x.tpt) - end TypeBlock - - given TypeBlockMethods: TypeBlockMethods with - extension (self: TypeBlock) - def aliases: List[TypeDef] = self.stats.map { case alias: TypeDef => alias } - def tpt: TypeTree = self.expr - end extension - end TypeBlockMethods - - type TypeBoundsTree = tpd.TypeBoundsTree | tpd.TypeTree - - object TypeBoundsTreeTypeTest extends TypeTest[Tree, TypeBoundsTree]: - def unapply(x: Tree): Option[TypeBoundsTree & x.type] = x match - case x: (tpd.TypeBoundsTree & x.type) => Some(x) - case x: (tpd.TypeTree & x.type) => - x.tpe match - case tpe: Types.TypeBounds => Some(x) - case _ => None - case _ => None - end TypeBoundsTreeTypeTest - - object TypeBoundsTree extends TypeBoundsTreeModule: - def apply(low: TypeTree, hi: TypeTree): TypeBoundsTree = - withDefaultPos(tpd.TypeBoundsTree(low, hi)) - def copy(original: Tree)(low: TypeTree, hi: TypeTree): TypeBoundsTree = - tpd.cpy.TypeBoundsTree(original)(low, hi, tpd.EmptyTree) - def unapply(x: TypeBoundsTree): (TypeTree, TypeTree) = - (x.low, x.hi) - end TypeBoundsTree - - given TypeBoundsTreeMethods: TypeBoundsTreeMethods with - extension (self: TypeBoundsTree) - def tpe: TypeBounds = self.tpe.asInstanceOf[Types.TypeBounds] - def low: TypeTree = self match - case self: tpd.TypeBoundsTree => self.lo - case self: tpd.TypeTree => tpd.TypeTree(self.tpe.asInstanceOf[Types.TypeBounds].lo).withSpan(self.span) - def hi: TypeTree = self match - case self: tpd.TypeBoundsTree => self.hi - case self: tpd.TypeTree => tpd.TypeTree(self.tpe.asInstanceOf[Types.TypeBounds].hi).withSpan(self.span) - end extension - end TypeBoundsTreeMethods - - type WildcardTypeTree = tpd.Ident - - object WildcardTypeTreeTypeTest extends TypeTest[Tree, WildcardTypeTree]: - def unapply(x: Tree): Option[WildcardTypeTree & x.type] = x match - case x: (tpd.Ident & x.type) if x.name == nme.WILDCARD => Some(x) - case _ => None - end WildcardTypeTreeTypeTest - - object WildcardTypeTree extends WildcardTypeTreeModule: - def apply(tpe: TypeRepr): WildcardTypeTree = withDefaultPos(tpd.Underscore(tpe)) - def unapply(x: WildcardTypeTree): true = true - end WildcardTypeTree - - given WildcardTypeTreeMethods: WildcardTypeTreeMethods with - extension (self: WildcardTypeTree) - def tpe: TypeRepr = self.tpe.stripTypeVar - end extension - end WildcardTypeTreeMethods - - type CaseDef = tpd.CaseDef - - object CaseDefTypeTest extends TypeTest[Tree, CaseDef]: - def unapply(x: Tree): Option[CaseDef & x.type] = x match - case tree: (tpd.CaseDef & x.type) if tree.body.isTerm => Some(tree) - case _ => None - end CaseDefTypeTest - - object CaseDef extends CaseDefModule: - def apply(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef = - tpd.CaseDef(pattern, guard.getOrElse(tpd.EmptyTree), rhs) - def copy(original: Tree)(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef = - tpd.cpy.CaseDef(original)(pattern, guard.getOrElse(tpd.EmptyTree), rhs) - def unapply(x: CaseDef): (Tree, Option[Term], Term) = - (x.pat, optional(x.guard), x.body) - end CaseDef - - given CaseDefMethods: CaseDefMethods with - extension (self: CaseDef) - def pattern: Tree = self.pat - def guard: Option[Term] = optional(self.guard) - def rhs: Term = self.body - end extension - end CaseDefMethods - - type TypeCaseDef = tpd.CaseDef - - object TypeCaseDefTypeTest extends TypeTest[Tree, TypeCaseDef]: - def unapply(x: Tree): Option[TypeCaseDef & x.type] = x match - case tree: (tpd.CaseDef & x.type) if tree.body.isType => Some(tree) - case _ => None - end TypeCaseDefTypeTest - - object TypeCaseDef extends TypeCaseDefModule: - def apply(pattern: TypeTree, rhs: TypeTree): TypeCaseDef = - tpd.CaseDef(pattern, tpd.EmptyTree, rhs) - def copy(original: Tree)(pattern: TypeTree, rhs: TypeTree): TypeCaseDef = - tpd.cpy.CaseDef(original)(pattern, tpd.EmptyTree, rhs) - def unapply(tree: TypeCaseDef): (TypeTree, TypeTree) = - (tree.pat, tree.body) - end TypeCaseDef - - given TypeCaseDefMethods: TypeCaseDefMethods with - extension (self: TypeCaseDef) - def pattern: TypeTree = self.pat - def rhs: TypeTree = self.body - end extension - end TypeCaseDefMethods - - type Bind = tpd.Bind - - object BindTypeTest extends TypeTest[Tree, Bind]: - def unapply(x: Tree): Option[Bind & x.type] = x match - case x: (tpd.Bind & x.type) if x.name.isTermName => Some(x) - case _ => None - end BindTypeTest - - object Bind extends BindModule: - def apply(sym: Symbol, pattern: Tree): Bind = - tpd.Bind(sym, pattern) - def copy(original: Tree)(name: String, pattern: Tree): Bind = - withDefaultPos(tpd.cpy.Bind(original)(name.toTermName, pattern)) - def unapply(pattern: Bind): (String, Tree) = - (pattern.name.toString, pattern.pattern) - end Bind - - given BindMethods: BindMethods with - extension (self: Bind) - def name: String = self.name.toString - def pattern: Tree = self.body - end extension - end BindMethods - - type Unapply = tpd.UnApply | tpd.Typed // tpd.Typed containing a tpd.UnApply as expression - - object UnapplyTypeTest extends TypeTest[Tree, Unapply]: - def unapply(x: Tree): Option[Unapply & x.type] = - x match // keep in sync with UnapplyMethodsImpl.selfUnApply - case x: (tpd.UnApply & x.type) => Some(x) - case x: (tpd.Typed & x.type) if x.expr.isInstanceOf[tpd.UnApply] => Some(x) - case _ => None - end UnapplyTypeTest - - object Unapply extends UnapplyModule: - def copy(original: Tree)(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply = - withDefaultPos(tpd.cpy.UnApply(original)(fun, implicits, patterns)) - def unapply(x: Unapply): (Term, List[Term], List[Tree]) = - (x.fun, x.implicits, x.patterns) - end Unapply - - given UnapplyMethods: UnapplyMethods with - extension (self: Unapply) - def fun: Term = selfUnApply(self).fun - def implicits: List[Term] = selfUnApply(self).implicits - def patterns: List[Tree] = effectivePatterns(selfUnApply(self).patterns) - end extension - private def selfUnApply(self: Unapply): tpd.UnApply = - self match // keep in sync with UnapplyTypeTest - case self: tpd.UnApply => self - case self: tpd.Typed => self.expr.asInstanceOf[tpd.UnApply] - private def effectivePatterns(patterns: List[Tree]): List[Tree] = - patterns match - case patterns0 :+ dotc.ast.Trees.SeqLiteral(elems, _) => patterns0 ::: elems - case _ => patterns - end UnapplyMethods - - type Alternatives = tpd.Alternative - - object AlternativesTypeTest extends TypeTest[Tree, Alternatives]: - def unapply(x: Tree): Option[Alternatives & x.type] = x match - case x: (tpd.Alternative & x.type) => Some(x) - case _ => None - end AlternativesTypeTest - - object Alternatives extends AlternativesModule: - def apply(patterns: List[Tree]): Alternatives = - withDefaultPos(tpd.Alternative(patterns)) - def copy(original: Tree)(patterns: List[Tree]): Alternatives = - tpd.cpy.Alternative(original)(patterns) - def unapply(x: Alternatives): Some[List[Tree]] = - Some(x.patterns) - end Alternatives - - given AlternativesMethods: AlternativesMethods with - extension (self: Alternatives) - def patterns: List[Tree] = self.trees - end extension - end AlternativesMethods - - type Selector = untpd.ImportSelector - - object Selector extends SelectorModule - - type SimpleSelector = untpd.ImportSelector - - object SimpleSelectorTypeTest extends TypeTest[Selector, SimpleSelector]: - def unapply(x: Selector): Option[SimpleSelector & x.type] = x match - case x: (untpd.ImportSelector & x.type) if x.renamed.isEmpty && !x.isGiven => Some(x) - case _ => None // TODO: handle import bounds - end SimpleSelectorTypeTest - - object SimpleSelector extends SimpleSelectorModule: - def unapply(x: SimpleSelector): Some[String] = Some(x.name.toString) - end SimpleSelector - - given SimpleSelectorMethods: SimpleSelectorMethods with - extension (self: SimpleSelector) - def name: String = self.imported.name.toString - def namePos: Position = self.imported.sourcePos - end extension - end SimpleSelectorMethods - - type RenameSelector = untpd.ImportSelector - - object RenameSelectorTypeTest extends TypeTest[Selector, RenameSelector]: - def unapply(x: Selector): Option[RenameSelector & x.type] = x match - case x: (untpd.ImportSelector & x.type) if !x.renamed.isEmpty => Some(x) - case _ => None - end RenameSelectorTypeTest - - object RenameSelector extends RenameSelectorModule: - def unapply(x: RenameSelector): (String, String) = (x.fromName, x.toName) - end RenameSelector - - given RenameSelectorMethods: RenameSelectorMethods with - extension (self: RenameSelector) - def fromName: String = self.imported.name.toString - def fromPos: Position = self.imported.sourcePos - def toName: String = self.renamed.asInstanceOf[untpd.Ident].name.toString - def toPos: Position = self.renamed.asInstanceOf[untpd.Ident].sourcePos - end extension - end RenameSelectorMethods - - type OmitSelector = untpd.ImportSelector - - object OmitSelectorTypeTest extends TypeTest[Selector, OmitSelector]: - def unapply(x: Selector): Option[OmitSelector & x.type] = x match { - case self: (untpd.ImportSelector & x.type) => - self.renamed match - case dotc.ast.Trees.Ident(nme.WILDCARD) => Some(self) - case _ => None - case _ => None - } - end OmitSelectorTypeTest - - object OmitSelector extends OmitSelectorModule: - def unapply(x: OmitSelector): Some[String] = Some(x.imported.name.toString) - end OmitSelector - - given OmitSelectorMethods: OmitSelectorMethods with - extension (self: OmitSelector) - def name: String = self.imported.toString - def namePos: Position = self.imported.sourcePos - end extension - end OmitSelectorMethods - - type GivenSelector = untpd.ImportSelector - - object GivenSelectorTypeTest extends TypeTest[Selector, GivenSelector]: - def unapply(x: Selector): Option[GivenSelector & x.type] = x match { - case self: (untpd.ImportSelector & x.type) if x.isGiven => Some(self) - case _ => None - } - end GivenSelectorTypeTest - - object GivenSelector extends GivenSelectorModule: - def unapply(x: GivenSelector): Some[Option[TypeTree]] = - Some(GivenSelectorMethods.bound(x)) - end GivenSelector - - given GivenSelectorMethods: GivenSelectorMethods with - extension (self: GivenSelector) - def bound: Option[TypeTree] = - self.bound match - case untpd.TypedSplice(tpt) => Some(tpt) - case _ => None - end extension - end GivenSelectorMethods - - type TypeRepr = dotc.core.Types.Type - - object TypeRepr extends TypeReprModule: - def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeRepr = - tp.asInstanceOf[TypeImpl].typeTree.tpe - def typeConstructorOf(clazz: Class[?]): TypeRepr = - if (clazz.isPrimitive) - if (clazz == classOf[Boolean]) dotc.core.Symbols.defn.BooleanType - else if (clazz == classOf[Byte]) dotc.core.Symbols.defn.ByteType - else if (clazz == classOf[Char]) dotc.core.Symbols.defn.CharType - else if (clazz == classOf[Short]) dotc.core.Symbols.defn.ShortType - else if (clazz == classOf[Int]) dotc.core.Symbols.defn.IntType - else if (clazz == classOf[Long]) dotc.core.Symbols.defn.LongType - else if (clazz == classOf[Float]) dotc.core.Symbols.defn.FloatType - else if (clazz == classOf[Double]) dotc.core.Symbols.defn.DoubleType - else dotc.core.Symbols.defn.UnitType - else if (clazz.isArray) - dotc.core.Symbols.defn.ArrayType.appliedTo(typeConstructorOf(clazz.getComponentType)) - else if clazz.isMemberClass then - val name = clazz.getSimpleName.toTypeName - val enclosing = typeConstructorOf(clazz.getEnclosingClass) - if (enclosing.member(name).exists) enclosing.select(name) - else enclosing.classSymbol.companionModule.termRef.select(name) - else - dotc.core.Symbols.getClassIfDefined(clazz.getCanonicalName).typeRef - end TypeRepr - - given TypeReprMethods: TypeReprMethods with - extension (self: TypeRepr) - - def show(using printer: Printer[TypeRepr]): String = printer.show(self) - - def seal: scala.quoted.Type[_] = self.asType - - def asType: scala.quoted.Type[?] = - new TypeImpl(Inferred(self), QuotesImpl.this.hashCode) - - def =:=(that: TypeRepr): Boolean = self =:= that - def <:<(that: TypeRepr): Boolean = self <:< that - def widen: TypeRepr = self.widen - def widenTermRefExpr: TypeRepr = self.widenTermRefExpr - def dealias: TypeRepr = self.dealias - def simplified: TypeRepr = self.simplified - def classSymbol: Option[Symbol] = - if self.classSymbol.exists then Some(self.classSymbol.asClass) - else None - def typeSymbol: Symbol = self.typeSymbol - def termSymbol: Symbol = self.termSymbol - def isSingleton: Boolean = self.isSingleton - def memberType(member: Symbol): TypeRepr = - member.info.asSeenFrom(self, member.owner) - def baseClasses: List[Symbol] = self.baseClasses - def baseType(cls: Symbol): TypeRepr = self.baseType(cls) - def derivesFrom(cls: Symbol): Boolean = self.derivesFrom(cls) - def isFunctionType: Boolean = - dotc.core.Symbols.defn.isFunctionType(self) - def isContextFunctionType: Boolean = - dotc.core.Symbols.defn.isContextFunctionType(self) - def isErasedFunctionType: Boolean = - dotc.core.Symbols.defn.isErasedFunctionType(self) - def isDependentFunctionType: Boolean = - val tpNoRefinement = self.dropDependentRefinement - tpNoRefinement != self - && dotc.core.Symbols.defn.isNonRefinedFunction(tpNoRefinement) - def select(sym: Symbol): TypeRepr = self.select(sym) - def appliedTo(targ: TypeRepr): TypeRepr = - dotc.core.Types.decorateTypeApplications(self).appliedTo(targ) - def appliedTo(targs: List[TypeRepr]): TypeRepr = - dotc.core.Types.decorateTypeApplications(self).appliedTo(targs) - end extension - end TypeReprMethods - - type ConstantType = dotc.core.Types.ConstantType - - object ConstantTypeTypeTest extends TypeTest[TypeRepr, ConstantType]: - def unapply(x: TypeRepr): Option[ConstantType & x.type] = x match - case tpe: (Types.ConstantType & x.type) => Some(tpe) - case _ => None - end ConstantTypeTypeTest - - object ConstantType extends ConstantTypeModule: - def apply(const: Constant): ConstantType = Types.ConstantType(const) - def unapply(x: ConstantType): Some[Constant] = Some(x.constant) - end ConstantType - - given ConstantTypeMethods: ConstantTypeMethods with - extension (self: ConstantType) def constant: Constant = self.value - end ConstantTypeMethods - - type NamedType = dotc.core.Types.NamedType - - object NamedTypeTypeTest extends TypeTest[TypeRepr, NamedType]: - def unapply(x: TypeRepr): Option[NamedType & x.type] = x match - case tpe: (Types.NamedType & x.type) => Some(tpe) - case _ => None - end NamedTypeTypeTest - - given NamedTypeMethods: NamedTypeMethods with - extension (self: NamedType) - def qualifier: TypeRepr = self.prefix - def name: String = self.name.toString - end extension - end NamedTypeMethods - - type TermRef = dotc.core.Types.NamedType - - object TermRefTypeTest extends TypeTest[TypeRepr, TermRef]: - def unapply(x: TypeRepr): Option[TermRef & x.type] = x match - case tpe: (Types.TermRef & x.type) => Some(tpe) - case _ => None - end TermRefTypeTest - - object TermRef extends TermRefModule: - def apply(qual: TypeRepr, name: String): TermRef = - Types.TermRef(qual, name.toTermName) - def unapply(x: TermRef): (TypeRepr, String) = - (x.prefix, x.name.toString) - end TermRef - - type TypeRef = dotc.core.Types.NamedType - - object TypeRefTypeTest extends TypeTest[TypeRepr, TypeRef]: - def unapply(x: TypeRepr): Option[TypeRef & x.type] = x match - case tpe: (Types.TypeRef & x.type) => Some(tpe) - case _ => None - end TypeRefTypeTest - - object TypeRef extends TypeRefModule: - def unapply(x: TypeRef): (TypeRepr, String) = - (x.prefix, x.name.toString) - end TypeRef - - given TypeRefMethods: TypeRefMethods with - extension (self: TypeRef) - def isOpaqueAlias: Boolean = self.symbol.isOpaqueAlias - def translucentSuperType: TypeRepr = self.translucentSuperType - end extension - end TypeRefMethods - - type SuperType = dotc.core.Types.SuperType - - object SuperTypeTypeTest extends TypeTest[TypeRepr, SuperType]: - def unapply(x: TypeRepr): Option[SuperType & x.type] = x match - case tpe: (Types.SuperType & x.type) => Some(tpe) - case _ => None - end SuperTypeTypeTest - - object SuperType extends SuperTypeModule: - def apply(thistpe: TypeRepr, supertpe: TypeRepr): SuperType = - Types.SuperType(thistpe, supertpe) - def unapply(x: SuperType): (TypeRepr, TypeRepr) = - (x.thistpe, x.supertpe) - end SuperType - - given SuperTypeMethods: SuperTypeMethods with - extension (self: SuperType) - def thistpe: TypeRepr = self.thistpe - def supertpe: TypeRepr = self.thistpe - end extension - end SuperTypeMethods - - type Refinement = dotc.core.Types.RefinedType - - object RefinementTypeTest extends TypeTest[TypeRepr, Refinement]: - def unapply(x: TypeRepr): Option[Refinement & x.type] = x match - case tpe: (Types.RefinedType & x.type) => Some(tpe) - case _ => None - end RefinementTypeTest - - object Refinement extends RefinementModule: - def apply(parent: TypeRepr, name: String, info: TypeRepr): Refinement = - val name1 = - info match - case _: TypeBounds => name.toTypeName - case _ => name.toTermName - Types.RefinedType(parent, name1, info) - def unapply(x: Refinement): (TypeRepr, String, TypeRepr) = - (x.parent, x.name, x.info) - end Refinement - - given RefinementMethods: RefinementMethods with - extension (self: Refinement) - def parent: TypeRepr = self.parent - def name: String = self.refinedName.toString - def info: TypeRepr = self.refinedInfo - end extension - end RefinementMethods - - type AppliedType = dotc.core.Types.AppliedType - - object AppliedTypeTypeTest extends TypeTest[TypeRepr, AppliedType]: - def unapply(x: TypeRepr): Option[AppliedType & x.type] = x match - case tpe: (Types.AppliedType & x.type) if !tpe.tycon.isRef(dotc.core.Symbols.defn.MatchCaseClass) => Some(tpe) - case _ => None - end AppliedTypeTypeTest - - object AppliedType extends AppliedTypeModule: - def unapply(x: AppliedType): (TypeRepr, List[TypeRepr]) = - (x.tycon, x.args) - end AppliedType - - given AppliedTypeMethods: AppliedTypeMethods with - extension (self: AppliedType) - def tycon: TypeRepr = self.tycon - def args: List[TypeRepr] = self.args - end extension - end AppliedTypeMethods - - type AnnotatedType = dotc.core.Types.AnnotatedType - - object AnnotatedTypeTypeTest extends TypeTest[TypeRepr, AnnotatedType]: - def unapply(x: TypeRepr): Option[AnnotatedType & x.type] = x match - case tpe: (Types.AnnotatedType & x.type) => Some(tpe) - case _ => None - end AnnotatedTypeTypeTest - - object AnnotatedType extends AnnotatedTypeModule: - def apply(underlying: TypeRepr, annot: Term): AnnotatedType = - Types.AnnotatedType(underlying, Annotations.Annotation(annot)) - def unapply(x: AnnotatedType): (TypeRepr, Term) = - (x.underlying.stripTypeVar, x.annot.tree) - end AnnotatedType - - given AnnotatedTypeMethods: AnnotatedTypeMethods with - extension (self: AnnotatedType) - def underlying: TypeRepr = self.underlying.stripTypeVar - def annotation: Term = self.annot.tree - end extension - end AnnotatedTypeMethods - - type AndOrType = dotc.core.Types.AndOrType - - object AndOrTypeTypeTest extends TypeTest[TypeRepr, AndOrType]: - def unapply(x: TypeRepr): Option[AndOrType & x.type] = x match - case tpe: (Types.AndOrType & x.type) => Some(tpe) - case _ => None - end AndOrTypeTypeTest - - given AndOrTypeMethods: AndOrTypeMethods with - extension (self: AndOrType) - def left: TypeRepr = self.tp1.stripTypeVar - def right: TypeRepr = self.tp2.stripTypeVar - end extension - end AndOrTypeMethods - - type AndType = dotc.core.Types.AndType - - object AndTypeTypeTest extends TypeTest[TypeRepr, AndType]: - def unapply(x: TypeRepr): Option[AndType & x.type] = x match - case tpe: (Types.AndType & x.type) => Some(tpe) - case _ => None - end AndTypeTypeTest - - object AndType extends AndTypeModule: - def apply(lhs: TypeRepr, rhs: TypeRepr): AndType = Types.AndType(lhs, rhs) - def unapply(x: AndType): (TypeRepr, TypeRepr) = (x.left, x.right) - end AndType - - type OrType = dotc.core.Types.OrType - - object OrTypeTypeTest extends TypeTest[TypeRepr, OrType]: - def unapply(x: TypeRepr): Option[OrType & x.type] = x match - case tpe: (Types.OrType & x.type) => Some(tpe) - case _ => None - end OrTypeTypeTest - - object OrType extends OrTypeModule: - def apply(lhs: TypeRepr, rhs: TypeRepr): OrType = Types.OrType(lhs, rhs, soft = false) - def unapply(x: OrType): (TypeRepr, TypeRepr) = (x.left, x.right) - end OrType - - type MatchType = dotc.core.Types.MatchType - - object MatchTypeTypeTest extends TypeTest[TypeRepr, MatchType]: - def unapply(x: TypeRepr): Option[MatchType & x.type] = x match - case tpe: (Types.MatchType & x.type) => Some(tpe) - case _ => None - end MatchTypeTypeTest - - object MatchType extends MatchTypeModule: - def apply(bound: TypeRepr, scrutinee: TypeRepr, cases: List[TypeRepr]): MatchType = - Types.MatchType(bound, scrutinee, cases) - def unapply(x: MatchType): (TypeRepr, TypeRepr, List[TypeRepr]) = - (x.bound, x.scrutinee, x.cases) - end MatchType - - given MatchTypeMethods: MatchTypeMethods with - extension (self: MatchType) - def bound: TypeRepr = self.bound - def scrutinee: TypeRepr = self.scrutinee - def cases: List[TypeRepr] = self.cases - end extension - end MatchTypeMethods - - type ByNameType = dotc.core.Types.ExprType - - object ByNameTypeTypeTest extends TypeTest[TypeRepr, ByNameType]: - def unapply(x: TypeRepr): Option[ByNameType & x.type] = x match - case tpe: (Types.ExprType & x.type) => Some(tpe) - case _ => None - end ByNameTypeTypeTest - - object ByNameType extends ByNameTypeModule: - def apply(underlying: TypeRepr): TypeRepr = Types.ExprType(underlying) - def unapply(x: ByNameType): Some[TypeRepr] = Some(x.underlying) - end ByNameType - - given ByNameTypeMethods: ByNameTypeMethods with - extension (self: ByNameType) - def underlying: TypeRepr = self.resType.stripTypeVar - end extension - end ByNameTypeMethods - - type ParamRef = dotc.core.Types.ParamRef - - object ParamRefTypeTest extends TypeTest[TypeRepr, ParamRef]: - def unapply(x: TypeRepr): Option[ParamRef & x.type] = x match - case tpe: (Types.TypeParamRef & x.type) => Some(tpe) - case tpe: (Types.TermParamRef & x.type) => Some(tpe) - case _ => None - end ParamRefTypeTest - - object ParamRef extends ParamRefModule: - def unapply(x: ParamRef): (LambdaType, Int) = - (x.binder, x.paramNum) - end ParamRef - - given ParamRefMethods: ParamRefMethods with - extension (self: ParamRef) - def binder: LambdaType = self.binder.asInstanceOf[LambdaType] // Cast to tpd - def paramNum: Int = self.paramNum - end extension - end ParamRefMethods - - type ThisType = dotc.core.Types.ThisType - - object ThisTypeTypeTest extends TypeTest[TypeRepr, ThisType]: - def unapply(x: TypeRepr): Option[ThisType & x.type] = x match - case tpe: (Types.ThisType & x.type) => Some(tpe) - case _ => None - end ThisTypeTypeTest - - object ThisType extends ThisTypeModule: - def unapply(x: ThisType): Some[TypeRepr] = Some(x.tref) - end ThisType - - given ThisTypeMethods: ThisTypeMethods with - extension (self: ThisType) - def tref: TypeRepr = self.tref - end extension - end ThisTypeMethods - - type RecursiveThis = dotc.core.Types.RecThis - - object RecursiveThisTypeTest extends TypeTest[TypeRepr, RecursiveThis]: - def unapply(x: TypeRepr): Option[RecursiveThis & x.type] = x match - case tpe: (Types.RecThis & x.type) => Some(tpe) - case _ => None - end RecursiveThisTypeTest - - object RecursiveThis extends RecursiveThisModule: - def unapply(x: RecursiveThis): Some[RecursiveType] = Some(x.binder) - end RecursiveThis - - - given RecursiveThisMethods: RecursiveThisMethods with - extension (self: RecursiveThis) - def binder: RecursiveType = self.binder - end extension - end RecursiveThisMethods - - type RecursiveType = dotc.core.Types.RecType - - object RecursiveTypeTypeTest extends TypeTest[TypeRepr, RecursiveType]: - def unapply(x: TypeRepr): Option[RecursiveType & x.type] = x match - case tpe: (Types.RecType & x.type) => Some(tpe) - case _ => None - end RecursiveTypeTypeTest - - object RecursiveType extends RecursiveTypeModule: - def apply(parentExp: RecursiveType => TypeRepr): RecursiveType = - Types.RecType(parentExp) - def unapply(x: RecursiveType): Some[TypeRepr] = Some(x.underlying) - end RecursiveType - - given RecursiveTypeMethods: RecursiveTypeMethods with - extension (self: RecursiveType) - def underlying: TypeRepr = self.underlying.stripTypeVar - def recThis: RecursiveThis = self.recThis - end extension - end RecursiveTypeMethods - - type LambdaType = dotc.core.Types.LambdaType - - object LambdaTypeTypeTest extends TypeTest[TypeRepr, LambdaType]: - def unapply(x: TypeRepr): Option[LambdaType & x.type] = x match - case tpe: (Types.LambdaType & x.type) => Some(tpe) - case _ => None - end LambdaTypeTypeTest - - given LambdaTypeMethods: LambdaTypeMethods with - extension (self: LambdaType) - def paramNames: List[String] = self.paramNames.map(_.toString) - def paramTypes: List[TypeRepr] = self.paramInfos - def resType: TypeRepr = self.resType - end extension - end LambdaTypeMethods - - type MethodOrPoly = dotc.core.Types.MethodOrPoly - - object MethodOrPolyTypeTest extends TypeTest[TypeRepr, MethodOrPoly]: - def unapply(x: TypeRepr): Option[MethodOrPoly & x.type] = x match - case tpe: (Types.MethodOrPoly & x.type) => Some(tpe) - case _ => None - end MethodOrPolyTypeTest - - type MethodType = dotc.core.Types.MethodType - - object MethodTypeTypeTest extends TypeTest[TypeRepr, MethodType]: - def unapply(x: TypeRepr): Option[MethodType & x.type] = x match - case tpe: (Types.MethodType & x.type) => Some(tpe) - case _ => None - end MethodTypeTypeTest - - object MethodType extends MethodTypeModule: - def apply(paramNames: List[String])(paramInfosExp: MethodType => List[TypeRepr], resultTypeExp: MethodType => TypeRepr): MethodType = - Types.MethodType(paramNames.map(_.toTermName))(paramInfosExp, resultTypeExp) - def unapply(x: MethodType): (List[String], List[TypeRepr], TypeRepr) = - (x.paramNames.map(_.toString), x.paramTypes, x.resType) - end MethodType - - given MethodTypeMethods: MethodTypeMethods with - extension (self: MethodType) - def isErased: Boolean = self.isErasedMethod - def isImplicit: Boolean = self.isImplicitMethod - def param(idx: Int): TypeRepr = self.newParamRef(idx) - end extension - end MethodTypeMethods - - type PolyType = dotc.core.Types.PolyType - - object PolyTypeTypeTest extends TypeTest[TypeRepr, PolyType]: - def unapply(x: TypeRepr): Option[PolyType & x.type] = x match - case tpe: (Types.PolyType & x.type) => Some(tpe) - case _ => None - end PolyTypeTypeTest - - object PolyType extends PolyTypeModule: - def apply(paramNames: List[String])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => TypeRepr): PolyType = - Types.PolyType(paramNames.map(_.toTypeName))(paramBoundsExp, resultTypeExp) - def unapply(x: PolyType): (List[String], List[TypeBounds], TypeRepr) = - (x.paramNames.map(_.toString), x.paramBounds, x.resType) - end PolyType - - given PolyTypeMethods: PolyTypeMethods with - extension (self: PolyType) - def param(idx: Int): TypeRepr = self.newParamRef(idx) - def paramBounds: List[TypeBounds] = self.paramInfos - end extension - end PolyTypeMethods - - type TypeLambda = dotc.core.Types.TypeLambda - - object TypeLambdaTypeTest extends TypeTest[TypeRepr, TypeLambda]: - def unapply(x: TypeRepr): Option[TypeLambda & x.type] = x match - case tpe: (Types.TypeLambda & x.type) => Some(tpe) - case _ => None - end TypeLambdaTypeTest - - object TypeLambda extends TypeLambdaModule: - def apply(paramNames: List[String], boundsFn: TypeLambda => List[TypeBounds], bodyFn: TypeLambda => TypeRepr): TypeLambda = - Types.HKTypeLambda(paramNames.map(_.toTypeName))(boundsFn, bodyFn) - def unapply(x: TypeLambda): (List[String], List[TypeBounds], TypeRepr) = - (x.paramNames.map(_.toString), x.paramBounds, x.resType) - end TypeLambda - - given TypeLambdaMethods: TypeLambdaMethods with - extension (self: TypeLambda) - def param(idx: Int): TypeRepr = self.newParamRef(idx) - def paramBounds: List[TypeBounds] = self.paramInfos - end extension - end TypeLambdaMethods - - type MatchCase = dotc.core.Types.AppliedType - - given MatchCaseTypeTest: TypeTest[TypeRepr, MatchCase] with - def unapply(x: TypeRepr): Option[MatchCase & x.type] = x match - case x: (Types.AppliedType & x.type) if x.tycon.isRef(dotc.core.Symbols.defn.MatchCaseClass) => Some(x) - case _ => None - end MatchCaseTypeTest - - object MatchCase extends MatchCaseModule: - def apply(pattern: TypeRepr, rhs: TypeRepr): MatchCase = - Types.AppliedType(dotc.core.Symbols.defn.MatchCaseClass.typeRef, List(pattern, rhs)) - def unapply(x: MatchCase): (TypeRepr, TypeRepr) = (x.pattern, x.rhs) - end MatchCase - - given MatchCaseMethods: MatchCaseMethods with - extension (self: MatchCase) - def pattern: TypeRepr = self.args(0) - def rhs: TypeRepr = self.args(1) - end extension - end MatchCaseMethods - - type TypeBounds = dotc.core.Types.TypeBounds - - object TypeBoundsTypeTest extends TypeTest[TypeRepr, TypeBounds]: - def unapply(x: TypeRepr): Option[TypeBounds & x.type] = x match - case x: (Types.TypeBounds & x.type) => Some(x) - case _ => None - end TypeBoundsTypeTest - - object TypeBounds extends TypeBoundsModule: - def apply(low: TypeRepr, hi: TypeRepr): TypeBounds = Types.TypeBounds(low, hi) - def unapply(x: TypeBounds): (TypeRepr, TypeRepr) = (x.low.stripLazyRef, x.hi.stripLazyRef) - def empty: TypeBounds = Types .TypeBounds.empty - def upper(hi: TypeRepr): TypeBounds = Types .TypeBounds.upper(hi) - def lower(lo: TypeRepr): TypeBounds = Types .TypeBounds.lower(lo) - end TypeBounds - - given TypeBoundsMethods: TypeBoundsMethods with - extension (self: TypeBounds) - def low: TypeRepr = self.lo.stripLazyRef - def hi: TypeRepr = self.hi.stripLazyRef - end extension - end TypeBoundsMethods - - type NoPrefix = dotc.core.Types.NoPrefix.type - - object NoPrefixTypeTest extends TypeTest[TypeRepr, NoPrefix]: - def unapply(x: TypeRepr): Option[NoPrefix & x.type] = - if x == Types.NoPrefix then Some(x.asInstanceOf[NoPrefix & x.type]) else None - end NoPrefixTypeTest - - object NoPrefix extends NoPrefixModule: - def unapply(x: NoPrefix): true = true - end NoPrefix - - type Constant = dotc.core.Constants.Constant - - object Constant extends ConstantModule - - given ConstantMethods: ConstantMethods with - extension (self: Constant) - def value: Any = self.value - def show(using printer: Printer[Constant]): String = printer.show(self) - end extension - end ConstantMethods - - type BooleanConstant = dotc.core.Constants.Constant - - object BooleanConstantTypeTest extends TypeTest[Constant, BooleanConstant]: - def unapply(x: Constant): Option[BooleanConstant & x.type] = - if x.tag == dotc.core.Constants.BooleanTag then Some(x.asInstanceOf[BooleanConstant & x.type]) else None - end BooleanConstantTypeTest - - object BooleanConstant extends BooleanConstantModule: - def apply(x: Boolean): BooleanConstant = dotc.core.Constants.Constant(x) - def unapply(constant: BooleanConstant): Some[Boolean] = Some(constant.booleanValue) - end BooleanConstant - - type ByteConstant = dotc.core.Constants.Constant - - object ByteConstantTypeTest extends TypeTest[Constant, ByteConstant]: - def unapply(x: Constant): Option[ByteConstant & x.type] = - if x.tag == dotc.core.Constants.ByteTag then Some(x.asInstanceOf[ByteConstant & x.type]) else None - end ByteConstantTypeTest - - object ByteConstant extends ByteConstantModule: - def apply(x: Byte): ByteConstant = dotc.core.Constants.Constant(x) - def unapply(constant: ByteConstant): Some[Byte] = Some(constant.byteValue) - end ByteConstant - - type ShortConstant = dotc.core.Constants.Constant - - object ShortConstantTypeTest extends TypeTest[Constant, ShortConstant]: - def unapply(x: Constant): Option[ShortConstant & x.type] = - if x.tag == dotc.core.Constants.ShortTag then Some(x.asInstanceOf[ShortConstant & x.type]) else None - end ShortConstantTypeTest - - object ShortConstant extends ShortConstantModule: - def apply(x: Short): ShortConstant = dotc.core.Constants.Constant(x) - def unapply(constant: ShortConstant): Some[Short] = Some(constant.shortValue) - end ShortConstant - - type IntConstant = dotc.core.Constants.Constant - - object IntConstantTypeTest extends TypeTest[Constant, IntConstant]: - def unapply(x: Constant): Option[IntConstant & x.type] = - if x.tag == dotc.core.Constants.IntTag then Some(x.asInstanceOf[IntConstant & x.type]) else None - end IntConstantTypeTest - - object IntConstant extends IntConstantModule: - def apply(x: Int): IntConstant = dotc.core.Constants.Constant(x) - def unapply(constant: IntConstant): Some[Int] = Some(constant.intValue) - end IntConstant - - type LongConstant = dotc.core.Constants.Constant - - object LongConstantTypeTest extends TypeTest[Constant, LongConstant]: - def unapply(x: Constant): Option[LongConstant & x.type] = - if x.tag == dotc.core.Constants.LongTag then Some(x.asInstanceOf[LongConstant & x.type]) else None - end LongConstantTypeTest - - object LongConstant extends LongConstantModule: - def apply(x: Long): LongConstant = dotc.core.Constants.Constant(x) - def unapply(constant: LongConstant): Some[Long] = Some(constant.longValue) - end LongConstant - - type FloatConstant = dotc.core.Constants.Constant - - object FloatConstantTypeTest extends TypeTest[Constant, FloatConstant]: - def unapply(x: Constant): Option[FloatConstant & x.type] = - if x.tag == dotc.core.Constants.FloatTag then Some(x.asInstanceOf[FloatConstant & x.type]) else None - end FloatConstantTypeTest - - object FloatConstant extends FloatConstantModule: - def apply(x: Float): FloatConstant = dotc.core.Constants.Constant(x) - def unapply(constant: FloatConstant): Some[Float] = Some(constant.floatValue) - end FloatConstant - - type DoubleConstant = dotc.core.Constants.Constant - - object DoubleConstantTypeTest extends TypeTest[Constant, DoubleConstant]: - def unapply(x: Constant): Option[DoubleConstant & x.type] = - if x.tag == dotc.core.Constants.DoubleTag then Some(x.asInstanceOf[DoubleConstant & x.type]) else None - end DoubleConstantTypeTest - - object DoubleConstant extends DoubleConstantModule: - def apply(x: Double): DoubleConstant = dotc.core.Constants.Constant(x) - def unapply(constant: DoubleConstant): Some[Double] = Some(constant.doubleValue) - end DoubleConstant - - type CharConstant = dotc.core.Constants.Constant - - object CharConstantTypeTest extends TypeTest[Constant, CharConstant]: - def unapply(x: Constant): Option[CharConstant & x.type] = - if x.tag == dotc.core.Constants.CharTag then Some(x.asInstanceOf[CharConstant & x.type]) else None - end CharConstantTypeTest - - object CharConstant extends CharConstantModule: - def apply(x: Char): CharConstant = dotc.core.Constants.Constant(x) - def unapply(constant: CharConstant): Some[Char] = Some(constant.charValue) - end CharConstant - - type StringConstant = dotc.core.Constants.Constant - - object StringConstantTypeTest extends TypeTest[Constant, StringConstant]: - def unapply(x: Constant): Option[StringConstant & x.type] = - if x.tag == dotc.core.Constants.StringTag then Some(x.asInstanceOf[StringConstant & x.type]) else None - end StringConstantTypeTest - - object StringConstant extends StringConstantModule: - def apply(x: String): StringConstant = dotc.core.Constants.Constant(x) - def unapply(constant: StringConstant): Some[String] = Some(constant.stringValue) - end StringConstant - - type UnitConstant = dotc.core.Constants.Constant - - object UnitConstantTypeTest extends TypeTest[Constant, UnitConstant]: - def unapply(x: Constant): Option[UnitConstant & x.type] = - if x.tag == dotc.core.Constants.UnitTag then Some(x.asInstanceOf[UnitConstant & x.type]) else None - end UnitConstantTypeTest - - object UnitConstant extends UnitConstantModule: - def apply(): UnitConstant = dotc.core.Constants.Constant(()) - def unapply(constant: UnitConstant): true = true - end UnitConstant - - type NullConstant = dotc.core.Constants.Constant - - object NullConstantTypeTest extends TypeTest[Constant, NullConstant]: - def unapply(x: Constant): Option[NullConstant & x.type] = - if x.tag == dotc.core.Constants.NullTag then Some(x.asInstanceOf[NullConstant & x.type]) else None - end NullConstantTypeTest - - object NullConstant extends NullConstantModule: - def apply(): NullConstant = dotc.core.Constants.Constant(null) - def unapply(constant: NullConstant): true = true - end NullConstant - - type ClassOfConstant = dotc.core.Constants.Constant - - object ClassOfConstantTypeTest extends TypeTest[Constant, ClassOfConstant]: - def unapply(x: Constant): Option[ClassOfConstant & x.type] = - if x.tag == dotc.core.Constants.ClazzTag then Some(x.asInstanceOf[ClassOfConstant & x.type]) else None - end ClassOfConstantTypeTest - - object ClassOfConstant extends ClassOfConstantModule: - def apply(x: TypeRepr): ClassOfConstant = - // TODO check that the type is a valid class when creating this constant or let Ycheck do it? - dotc.core.Constants.Constant(x) - def unapply(constant: ClassOfConstant): Some[TypeRepr] = Some(constant.typeValue) - end ClassOfConstant - - object Implicits extends ImplicitsModule: - def search(tpe: TypeRepr): ImplicitSearchResult = - ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span) - end Implicits - - type ImplicitSearchResult = Tree - - type ImplicitSearchSuccess = Tree - - object ImplicitSearchSuccessTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]: - def unapply(x: ImplicitSearchResult): Option[ImplicitSearchSuccess & x.type] = - x.tpe match - case _: dotc.typer.Implicits.SearchFailureType => None - case _ => Some(x) - end ImplicitSearchSuccessTypeTest - - given ImplicitSearchSuccessMethods: ImplicitSearchSuccessMethods with - extension (self: ImplicitSearchSuccess) - def tree: Term = self - end extension - end ImplicitSearchSuccessMethods - - type ImplicitSearchFailure = Tree - - object ImplicitSearchFailureTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchFailure]: - def unapply(x: ImplicitSearchResult): Option[ImplicitSearchFailure & x.type] = - x.tpe match - case _: dotc.typer.Implicits.SearchFailureType => Some(x) - case _ => None - end ImplicitSearchFailureTypeTest - - given ImplicitSearchFailureMethods: ImplicitSearchFailureMethods with - extension (self: ImplicitSearchFailure) - def explanation: String = - self.tpe.asInstanceOf[dotc.typer.Implicits.SearchFailureType].explanation - end extension - end ImplicitSearchFailureMethods - - type DivergingImplicit = Tree - - object DivergingImplicitTypeTest extends TypeTest[ImplicitSearchResult, DivergingImplicit]: - def unapply(x: ImplicitSearchResult): Option[DivergingImplicit & x.type] = - x.tpe match - case _: dotc.typer.Implicits.DivergingImplicit => Some(x) - case _ => None - end DivergingImplicitTypeTest - - type NoMatchingImplicits = Tree - - object NoMatchingImplicitsTypeTest extends TypeTest[ImplicitSearchResult, NoMatchingImplicits]: - def unapply(x: ImplicitSearchResult): Option[NoMatchingImplicits & x.type] = - x.tpe match - case _: dotc.typer.Implicits.NoMatchingImplicits => Some(x) - case _ => None - end NoMatchingImplicitsTypeTest - - type AmbiguousImplicits = Tree - - object AmbiguousImplicitsTypeTest extends TypeTest[ImplicitSearchResult, AmbiguousImplicits]: - def unapply(x: ImplicitSearchResult): Option[AmbiguousImplicits & x.type] = - x.tpe match - case _: dotc.typer.Implicits.AmbiguousImplicits => Some(x) - case _ => None - end AmbiguousImplicitsTypeTest - - type Symbol = dotc.core.Symbols.Symbol - - object Symbol extends SymbolModule: - def spliceOwner: Symbol = ctx.owner - def requiredPackage(path: String): Symbol = dotc.core.Symbols.requiredPackage(path) - def requiredClass(path: String): Symbol = dotc.core.Symbols.requiredClass(path) - def requiredModule(path: String): Symbol = dotc.core.Symbols.requiredModule(path) - def requiredMethod(path: String): Symbol = dotc.core.Symbols.requiredMethod(path) - def classSymbol(fullName: String): Symbol = dotc.core.Symbols.requiredClass(fullName) - def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol = - newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol) - def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol = - dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin) - def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol = - dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin) - def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol = - dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | Case, tpe) - def noSymbol: Symbol = dotc.core.Symbols.NoSymbol - end Symbol - - given SymbolMethods: SymbolMethods with - extension (self: Symbol) - def owner: Symbol = self.denot.owner - def maybeOwner: Symbol = self.denot.maybeOwner - def flags: Flags = self.denot.flags - - def privateWithin: Option[TypeRepr] = - val within: Symbol = - self.denot.privateWithin - if (within.exists && !self.is(dotc.core.Flags.Protected)) Some(within.typeRef) - else None - - def protectedWithin: Option[TypeRepr] = - val within: Symbol = - self.denot.privateWithin - if (within.exists && self.is(dotc.core.Flags.Protected)) Some(within.typeRef) - else None - - def name: String = self.denot.name.toString - def fullName: String = self.denot.fullName.toString - def pos: Option[Position] = - if self.exists then Some(self.sourcePos) else None - - def docstring: Option[String] = - import dotc.core.Comments.CommentsContext - val docCtx = ctx.docCtx.getOrElse { - throw new RuntimeException( - "DocCtx could not be found and documentations are unavailable. This is a compiler-internal error." - ) - } - docCtx.docstring(self).map(_.raw) - - def tree: Tree = FromSymbol.definitionFromSym(self) - - def hasAnnotation(annotSym: Symbol): Boolean = - self.denot.hasAnnotation(annotSym) - - def getAnnotation(annotSym: Symbol): Option[Term] = - self.denot.getAnnotation(annotSym).map(_.tree) - - def annotations: List[Term] = - self.denot.annotations.flatMap { - case _: dotc.core.Annotations.BodyAnnotation => Nil - case annot => annot.tree :: Nil - } - - def isDefinedInCurrentRun: Boolean = - self.topLevelClass.asClass.isDefinedInCurrentRun - def isLocalDummy: Boolean = self.denot.isLocalDummy - def isRefinementClass: Boolean = self.denot.isRefinementClass - def isAliasType: Boolean = self.denot.isAliasType - def isAnonymousClass: Boolean = self.denot.isAnonymousClass - def isAnonymousFunction: Boolean = self.denot.isAnonymousFunction - def isAbstractType: Boolean = self.denot.isAbstractType - def isClassConstructor: Boolean = self.denot.isClassConstructor - def isType: Boolean = self.isType - def isTerm: Boolean = self.isTerm - def isPackageDef: Boolean = self.is(dotc.core.Flags.Package) - def isClassDef: Boolean = self.isClass - def isTypeDef: Boolean = - self.isType && !self.isClass && !self.is(dotc.core.Flags.Case) - def isValDef: Boolean = - self.isTerm && !self.is(dotc.core.Flags.Method) && !self.is(dotc.core.Flags.Case/*, FIXME add this check and fix sourcecode butNot = Enum | Module*/) - def isDefDef: Boolean = self.is(dotc.core.Flags.Method) - def isBind: Boolean = - self.is(dotc.core.Flags.Case, butNot = Enum | Module) && !self.isClass - def isNoSymbol: Boolean = self == Symbol.noSymbol - def exists: Boolean = self != Symbol.noSymbol - - def declaredField(name: String): Symbol = - val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName) - if (isField(sym)) sym else dotc.core.Symbols.NoSymbol - - def declaredFields: List[Symbol] = self.unforcedDecls.filter(isField) - - def memberField(name: String): Symbol = - appliedTypeRef(self).allMembers.iterator.map(_.symbol).find { - sym => isField(sym) && sym.name.toString == name - }.getOrElse(dotc.core.Symbols.NoSymbol) - - def memberFields: List[Symbol] = - appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect { - case sym if isField(sym) => sym.asTerm - }.toList - - def declaredMethod(name: String): List[Symbol] = - self.typeRef.decls.iterator.collect { - case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm - }.toList - - def declaredMethods: List[Symbol] = - self.typeRef.decls.iterator.collect { - case sym if isMethod(sym) => sym.asTerm - }.toList - - def memberMethod(name: String): List[Symbol] = - appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect { - case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm - }.toList - - def memberMethods: List[Symbol] = - appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect { - case sym if isMethod(sym) => sym.asTerm - }.toList - - def declaredType(name: String): List[Symbol] = - self.typeRef.decls.iterator.collect { - case sym if sym.isType && sym.name.toString == name => sym.asType - }.toList - - def declaredTypes: List[Symbol] = - self.typeRef.decls.iterator.collect { - case sym if sym.isType => sym.asType - }.toList - - def memberType(name: String): Symbol = - self.unforcedDecls.find(sym => sym.name == name.toTypeName) - - def memberTypes: List[Symbol] = - self.unforcedDecls.filter(_.isType) - - def declarations: List[Symbol] = - self.typeRef.info.decls.toList - - def paramSymss: List[List[Symbol]] = self.denot.paramSymss - def primaryConstructor: Symbol = self.denot.primaryConstructor - def allOverriddenSymbols: Iterator[Symbol] = self.denot.allOverriddenSymbols - def overridingSymbol(ofclazz: Symbol): Symbol = - if ofclazz.isClass then self.denot.overridingSymbol(ofclazz.asClass) - else dotc.core.Symbols.NoSymbol - - def caseFields: List[Symbol] = - if !self.isClass then Nil - else self.asClass.paramAccessors.collect { - case sym if sym.is(dotc.core.Flags.CaseAccessor) => sym.asTerm - } - - def isTypeParam: Boolean = self.isTypeParam - def signature: Signature = self.signature - def moduleClass: Symbol = self.denot.moduleClass - def companionClass: Symbol = self.denot.companionClass - def companionModule: Symbol = self.denot.companionModule - def children: List[Symbol] = self.denot.children - - def show(using printer: Printer[Symbol]): String = printer.show(self) - - end extension - - private def appliedTypeRef(sym: Symbol): TypeRepr = - sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef)) - - private def isMethod(sym: Symbol): Boolean = - sym.isTerm && sym.is(dotc.core.Flags.Method) && !sym.isConstructor - - private def isField(sym: Symbol): Boolean = - sym.isTerm && !sym.is(dotc.core.Flags.Method) - end SymbolMethods - - type Signature = dotc.core.Signature - - object Signature extends SignatureModule: - def unapply(sig: Signature): (List[String | Int], String) = - (sig.paramSigs, sig.resultSig) - end Signature - - given SignatureMethods: SignatureMethods with - extension (self: Signature) - def paramSigs: List[String | Int] = - self.paramsSig.map { - case paramSig: dotc.core.Names.TypeName => - paramSig.toString - case paramSig: Int => - paramSig - } - def resultSig: String = - self.resSig.toString - end extension - end SignatureMethods - - object defn extends defnModule: - def RootPackage: Symbol = dotc.core.Symbols.defn.RootPackage - def RootClass: Symbol = dotc.core.Symbols.defn.RootClass - def EmptyPackageClass: Symbol = dotc.core.Symbols.defn.EmptyPackageClass - def ScalaPackage: Symbol = dotc.core.Symbols.defn.ScalaPackageVal - def ScalaPackageClass: Symbol = dotc.core.Symbols.defn.ScalaPackageClass - def AnyClass: Symbol = dotc.core.Symbols.defn.AnyClass - def MatchableClass: Symbol = dotc.core.Symbols.defn.MatchableClass - def AnyValClass: Symbol = dotc.core.Symbols.defn.AnyValClass - def ObjectClass: Symbol = dotc.core.Symbols.defn.ObjectClass - def AnyRefClass: Symbol = dotc.core.Symbols.defn.AnyRefAlias - def NullClass: Symbol = dotc.core.Symbols.defn.NullClass - def NothingClass: Symbol = dotc.core.Symbols.defn.NothingClass - def UnitClass: Symbol = dotc.core.Symbols.defn.UnitClass - def ByteClass: Symbol = dotc.core.Symbols.defn.ByteClass - def ShortClass: Symbol = dotc.core.Symbols.defn.ShortClass - def CharClass: Symbol = dotc.core.Symbols.defn.CharClass - def IntClass: Symbol = dotc.core.Symbols.defn.IntClass - def LongClass: Symbol = dotc.core.Symbols.defn.LongClass - def FloatClass: Symbol = dotc.core.Symbols.defn.FloatClass - def DoubleClass: Symbol = dotc.core.Symbols.defn.DoubleClass - def BooleanClass: Symbol = dotc.core.Symbols.defn.BooleanClass - def StringClass: Symbol = dotc.core.Symbols.defn.StringClass - def ClassClass: Symbol = dotc.core.Symbols.defn.ClassClass - def ArrayClass: Symbol = dotc.core.Symbols.defn.ArrayClass - def PredefModule: Symbol = dotc.core.Symbols.defn.ScalaPredefModule - def Predef_classOf: Symbol = dotc.core.Symbols.defn.Predef_classOf - def JavaLangPackage: Symbol = dotc.core.Symbols.defn.JavaLangPackageVal - def ArrayModule: Symbol = dotc.core.Symbols.defn.ArrayModule - def Array_apply: Symbol = dotc.core.Symbols.defn.Array_apply - def Array_clone: Symbol = dotc.core.Symbols.defn.Array_clone - def Array_length: Symbol = dotc.core.Symbols.defn.Array_length - def Array_update: Symbol = dotc.core.Symbols.defn.Array_update - def RepeatedParamClass: Symbol = dotc.core.Symbols.defn.RepeatedParamClass - def RepeatedAnnot: Symbol = dotc.core.Symbols.defn.RepeatedAnnot - def OptionClass: Symbol = dotc.core.Symbols.defn.OptionClass - def NoneModule: Symbol = dotc.core.Symbols.defn.NoneModule - def SomeModule: Symbol = dotc.core.Symbols.defn.SomeClass.companionModule - def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass - def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol = - dotc.core.Symbols.defn.FunctionClass(arity, isImplicit, isErased) - def TupleClass(arity: Int): Symbol = - dotc.core.Symbols.defn.TupleType(arity).classSymbol.asClass - def isTupleClass(sym: Symbol): Boolean = - dotc.core.Symbols.defn.isTupleClass(sym) - def ScalaPrimitiveValueClasses: List[Symbol] = - UnitClass :: BooleanClass :: ScalaNumericValueClasses - def ScalaNumericValueClasses: List[Symbol] = - ByteClass :: ShortClass :: IntClass :: LongClass :: FloatClass :: DoubleClass :: CharClass :: Nil - end defn - - type Flags = dotc.core.Flags.FlagSet - - object Flags extends FlagsModule: - def Abstract: Flags = dotc.core.Flags.Abstract - def Artifact: Flags = dotc.core.Flags.Artifact - def Case: Flags = dotc.core.Flags.Case - def CaseAccessor: Flags = dotc.core.Flags.CaseAccessor - def Contravariant: Flags = dotc.core.Flags.Contravariant - def Covariant: Flags = dotc.core.Flags.Covariant - def Deferred: Flags = dotc.core.Flags.Deferred - def EmptyFlags = dotc.core.Flags.EmptyFlags - def Enum: Flags = dotc.core.Flags.Enum - def Erased: Flags = dotc.core.Flags.Erased - def Exported: Flags = dotc.core.Flags.Exported - def ExtensionMethod: Flags = dotc.core.Flags.ExtensionMethod - def FieldAccessor: Flags = dotc.core.Flags.Accessor - def Final: Flags = dotc.core.Flags.Final - def Given: Flags = dotc.core.Flags.Given - def HasDefault: Flags = dotc.core.Flags.HasDefault - def Implicit: Flags = dotc.core.Flags.Implicit - def Infix: Flags = dotc.core.Flags.Infix - def Inline: Flags = dotc.core.Flags.Inline - def JavaDefined: Flags = dotc.core.Flags.JavaDefined - def JavaStatic: Flags = dotc.core.Flags.JavaStatic - def Lazy: Flags = dotc.core.Flags.Lazy - def Local: Flags = dotc.core.Flags.Local - def Macro: Flags = dotc.core.Flags.Macro - def Method: Flags = dotc.core.Flags.Method - def Module: Flags = dotc.core.Flags.Module - def Mutable: Flags = dotc.core.Flags.Mutable - def NoInits: Flags = dotc.core.Flags.NoInits - def Opaque: Flags = dotc.core.Flags.Opaque - def Open: Flags = dotc.core.Flags.Open - def Override: Flags = dotc.core.Flags.Override - def Package: Flags = dotc.core.Flags.Package - def Param: Flags = dotc.core.Flags.Param - def ParamAccessor: Flags = dotc.core.Flags.ParamAccessor - def Private: Flags = dotc.core.Flags.Private - def PrivateLocal: Flags = dotc.core.Flags.PrivateLocal - def Protected: Flags = dotc.core.Flags.Protected - def Scala2x: Flags = dotc.core.Flags.Scala2x - def Sealed: Flags = dotc.core.Flags.Sealed - def StableRealizable: Flags = dotc.core.Flags.StableRealizable - def Static: Flags = dotc.core.Flags.JavaStatic - def Synthetic: Flags = dotc.core.Flags.Synthetic - def Trait: Flags = dotc.core.Flags.Trait - def Transparent: Flags = dotc.core.Flags.Transparent - end Flags - - given FlagsMethods: FlagsMethods with - extension (self: Flags) - def is(that: Flags): Boolean = self.isAllOf(that) - def |(that: Flags): Flags = dotc.core.Flags.or(self, that) // TODO: Replace with dotc.core.Flags.|(self)(that) once extension names have stabilized - def &(that: Flags): Flags = dotc.core.Flags.and(self, that)// TODO: Replace with dotc.core.Flags.&(self)(that) once extension names have stabilized - def show: String = Extractors.showFlags(using QuotesImpl.this)(self) - end extension - end FlagsMethods - - type Position = dotc.util.SourcePosition - - object Position extends PositionModule: - def ofMacroExpansion: dotc.util.SourcePosition = - MacroExpansion.position.getOrElse(dotc.util.SourcePosition(ctx.source, dotc.util.Spans.NoSpan)) - def apply(sourceFile: SourceFile, start: Int, end: Int): Position = - dotc.util.SourcePosition(sourceFile, dotc.util.Spans.Span(start, end)) - end Position - - given PositionMethods: PositionMethods with - extension (self: Position) - def start: Int = self.start - def end: Int = self.end - def sourceFile: SourceFile = self.source - def startLine: Int = self.startLine - def endLine: Int = self.endLine - def startColumn: Int = self.startColumn - def endColumn: Int = self.endColumn - def sourceCode: Option[String] = - // TODO detect when we do not have a source and return None - Some(new String(self.source.content(), self.start, self.end - self.start)) - end extension - end PositionMethods - - type SourceFile = dotc.util.SourceFile - - object SourceFile extends SourceFileModule { - def current: SourceFile = ctx.compilationUnit.source - } - - given SourceFileMethods: SourceFileMethods with - extension (self: SourceFile) - def jpath: java.nio.file.Path = self.file.jpath - def content: Option[String] = - // TODO detect when we do not have a source and return None - Some(new String(self.content())) - end extension - end SourceFileMethods - - object report extends reportModule: - - def error(msg: String): Unit = - dotc.report.error(msg, Position.ofMacroExpansion) - - def error(msg: String, expr: Expr[Any]): Unit = - dotc.report.error(msg, asTerm(expr).pos) - - def error(msg: String, pos: Position): Unit = - dotc.report.error(msg, pos) - - def throwError(msg: String): Nothing = - error(msg) - throw new scala.quoted.runtime.StopMacroExpansion - - def throwError(msg: String, expr: Expr[Any]): Nothing = - error(msg, expr) - throw new scala.quoted.runtime.StopMacroExpansion - - def throwError(msg: String, pos: Position): Nothing = - error(msg, pos) - throw new scala.quoted.runtime.StopMacroExpansion - - def warning(msg: String): Unit = - dotc.report.warning(msg, Position.ofMacroExpansion) - - def warning(msg: String, expr: Expr[Any]): Unit = - dotc.report.warning(msg, asTerm(expr).pos) - - def warning(msg: String, pos: Position): Unit = - dotc.report.warning(msg, pos) - - end report - - private def optional[T <: dotc.ast.Trees.Tree[?]](tree: T): Option[tree.type] = - if tree.isEmpty then None else Some(tree) - - private def withDefaultPos[T <: Tree](fn: Context ?=> T): T = - fn(using ctx.withSource(Position.ofMacroExpansion.source)).withSpan(Position.ofMacroExpansion.span) - - /** Checks that all definitions in this tree have the expected owner. - * Nested definitions are ignored and assumed to be correct by construction. - */ - private def yCheckedOwners(tree: Option[Tree], owner: Symbol): tree.type = - if yCheck then - tree match - case Some(tree) => - yCheckOwners(tree, owner) - case _ => - tree - - /** Checks that all definitions in this tree have the expected owner. - * Nested definitions are ignored and assumed to be correct by construction. - */ - private def yCheckedOwners(tree: Tree, owner: Symbol): tree.type = - if yCheck then - yCheckOwners(tree, owner) - tree - - /** Checks that all definitions in this tree have the expected owner. - * Nested definitions are ignored and assumed to be correct by construction. - */ - private def yCheckOwners(tree: Tree, owner: Symbol): Unit = - new tpd.TreeTraverser { - def traverse(t: Tree)(using Context): Unit = - t match - case t: tpd.DefTree => - val defOwner = t.symbol.owner - assert(defOwner == owner, - s"""Tree had an unexpected owner for ${t.symbol} - |Expected: $owner (${owner.fullName}) - |But was: $defOwner (${defOwner.fullName}) - | - | - |The code of the definition of ${t.symbol} is - |${Printer.TreeCode.show(t)} - | - |which was found in the code - |${Printer.TreeCode.show(tree)} - | - |which has the AST representation - |${Printer.TreeStructure.show(tree)} - | - |""".stripMargin) - case _ => traverseChildren(t) - }.traverse(tree) - - object Printer extends PrinterModule: - - lazy val TreeCode: Printer[Tree] = new Printer[Tree]: - def show(tree: Tree): String = - SourceCode.showTree(using QuotesImpl.this)(tree)(SyntaxHighlight.plain, fullNames = true) - - lazy val TreeShortCode: Printer[Tree] = new Printer[Tree]: - def show(tree: Tree): String = - SourceCode.showTree(using QuotesImpl.this)(tree)(SyntaxHighlight.plain, fullNames = false) - - lazy val TreeAnsiCode: Printer[Tree] = new Printer[Tree]: - def show(tree: Tree): String = - SourceCode.showTree(using QuotesImpl.this)(tree)(SyntaxHighlight.ANSI, fullNames = true) - - lazy val TreeStructure: Printer[Tree] = new Printer[Tree]: - def show(tree: Tree): String = - Extractors.showTree(using QuotesImpl.this)(tree) - - lazy val TypeReprCode: Printer[TypeRepr] = new Printer[TypeRepr]: - def show(tpe: TypeRepr): String = - SourceCode.showType(using QuotesImpl.this)(tpe)(SyntaxHighlight.plain, fullNames = true) - - lazy val TypeReprShortCode: Printer[TypeRepr] = new Printer[TypeRepr]: - def show(tpe: TypeRepr): String = - SourceCode.showType(using QuotesImpl.this)(tpe)(SyntaxHighlight.plain, fullNames = false) - - lazy val TypeReprAnsiCode: Printer[TypeRepr] = new Printer[TypeRepr]: - def show(tpe: TypeRepr): String = - SourceCode.showType(using QuotesImpl.this)(tpe)(SyntaxHighlight.ANSI, fullNames = true) - - lazy val TypeReprStructure: Printer[TypeRepr] = new Printer[TypeRepr]: - def show(tpe: TypeRepr): String = - Extractors.showType(using QuotesImpl.this)(tpe) - - lazy val ConstantCode: Printer[Constant] = new Printer[Constant]: - def show(const: Constant): String = - const.show(using ctx.fresh.setSetting(ctx.settings.color, "never")) - - lazy val ConstantStructure: Printer[Constant] = new Printer[Constant]: - def show(const: Constant): String = - Extractors.showConstant(using QuotesImpl.this)(const) - - end Printer - end reflect - - def unpickleExpr[T](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Expr[T] = - val tree = PickledQuotes.unpickleTerm(pickled, typeHole, termHole) - new ExprImpl(tree, hash).asInstanceOf[scala.quoted.Expr[T]] - - def unpickleType[T <: AnyKind](pickled: String | List[String], typeHole: (Int, Seq[Any]) => scala.quoted.Type[?], termHole: (Int, Seq[Any], scala.quoted.Quotes) => scala.quoted.Expr[?]): scala.quoted.Type[T] = - val tree = PickledQuotes.unpickleTypeTree(pickled, typeHole, termHole) - new TypeImpl(tree, hash).asInstanceOf[scala.quoted.Type[T]] - - object ExprMatch extends ExprMatchModule: - def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] = - val scrutineeTree = reflect.asTerm(scrutinee) - val patternTree = reflect.asTerm(pattern) - treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]] - end ExprMatch - - object TypeMatch extends TypeMatchModule: - def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Type[?])(using pattern: scala.quoted.Type[?]): Option[Tup] = - val scrutineeTree = reflect.TypeTree.of(using scrutinee) - val patternTree = reflect.TypeTree.of(using pattern) - treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]] - end TypeMatch - - private def treeMatch(scrutinee: reflect.Tree, pattern: reflect.Tree): Option[Tuple] = { - import reflect._ - def isTypeHoleDef(tree: Tree): Boolean = - tree match - case tree: TypeDef => - tree.symbol.hasAnnotation(dotc.core.Symbols.defn.QuotedRuntimePatterns_patternTypeAnnot) - case _ => false - - def extractTypeHoles(pat: Term): (Term, List[Symbol]) = - pat match - case tpd.Inlined(_, Nil, pat2) => extractTypeHoles(pat2) - case tpd.Block(stats @ ((typeHole: TypeDef) :: _), expr) if isTypeHoleDef(typeHole) => - val holes = stats.takeWhile(isTypeHoleDef).map(_.symbol) - val otherStats = stats.dropWhile(isTypeHoleDef) - (tpd.cpy.Block(pat)(otherStats, expr), holes) - case _ => - (pat, Nil) - - val (pat1, typeHoles) = extractTypeHoles(pattern) - - val ctx1 = - if typeHoles.isEmpty then ctx - else - val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(dotc.core.Mode.GadtConstraintInference) - ctx1.gadt.addToConstraint(typeHoles) - ctx1 - - val qctx1 = QuotesImpl()(using ctx1) - - val matcher = new Matcher.QuoteMatcher[qctx1.type](qctx1) { - def patternHoleSymbol: qctx1.reflect.Symbol = dotc.core.Symbols.defn.QuotedRuntimePatterns_patternHole.asInstanceOf - def higherOrderHoleSymbol: qctx1.reflect.Symbol = dotc.core.Symbols.defn.QuotedRuntimePatterns_higherOrderHole.asInstanceOf - } - - val matchings = - if pat1.isType then matcher.termMatch(scrutinee.asInstanceOf[matcher.qctx.reflect.Term], pat1.asInstanceOf[matcher.qctx.reflect.Term]) - else matcher.termMatch(scrutinee.asInstanceOf[matcher.qctx.reflect.Term], pat1.asInstanceOf[matcher.qctx.reflect.Term]) - - // val matchings = matcher.termMatch(scrutinee, pattern) - if typeHoles.isEmpty then matchings - else { - // After matching and doing all subtype checks, we have to approximate all the type bindings - // that we have found, seal them in a quoted.Type and add them to the result - def typeHoleApproximation(sym: Symbol) = - ctx1.gadt.approximation(sym, !sym.hasAnnotation(dotc.core.Symbols.defn.QuotedRuntimePatterns_fromAboveAnnot)).asInstanceOf[qctx1.reflect.TypeRepr].asType - matchings.map { tup => - Tuple.fromIArray(typeHoles.map(typeHoleApproximation).toArray.asInstanceOf[IArray[Object]]) ++ tup - } - } - } - - private[this] val hash = QuotesImpl.scopeId(using ctx) - override def hashCode: Int = hash - -end QuotesImpl diff --git a/compiler/src-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala similarity index 100% rename from compiler/src-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala rename to compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala diff --git a/library/src-non-bootstrapped/scala/IArray.scala b/library/src-non-bootstrapped/scala/IArray.scala deleted file mode 100644 index 2419f968ec51..000000000000 --- a/library/src-non-bootstrapped/scala/IArray.scala +++ /dev/null @@ -1,278 +0,0 @@ -package scala -import reflect.ClassTag - -object opaques: - opaque type IArray[+T] = Array[_ <: T] - - private[scala] type Sub[A] >: Array[A] <: IArray[A] - private[scala] type Sup[A] >: IArray[A] <: Array[_ <: A] - - given arrayOps: Object with { - - extension (arr: IArray[Byte]) def apply(n: Int): Byte = arr.asInstanceOf[Array[Byte]].apply(n) - extension (arr: IArray[Short]) def apply(n: Int): Short = arr.asInstanceOf[Array[Short]].apply(n) - extension (arr: IArray[Char]) def apply(n: Int): Char = arr.asInstanceOf[Array[Char]].apply(n) - extension (arr: IArray[Int]) def apply(n: Int): Int = arr.asInstanceOf[Array[Int]].apply(n) - extension (arr: IArray[Long]) def apply(n: Int): Long = arr.asInstanceOf[Array[Long]].apply(n) - extension (arr: IArray[Float]) def apply(n: Int): Float = arr.asInstanceOf[Array[Float]].apply(n) - extension (arr: IArray[Double]) def apply(n: Int): Double = arr.asInstanceOf[Array[Double]].apply(n) - extension [T <: Object](arr: IArray[T]) def apply (n: Int): T = arr.asInstanceOf[Array[T]].apply(n) - extension [T](arr: IArray[T]) def apply (n: Int): T = arr.asInstanceOf[Array[T]].apply(n) - - extension (arr: IArray[Byte]) def length: Int = arr.asInstanceOf[Array[Byte]].length - extension (arr: IArray[Short]) def length: Int = arr.asInstanceOf[Array[Short]].length - extension (arr: IArray[Char]) def length: Int = arr.asInstanceOf[Array[Char]].length - extension (arr: IArray[Int]) def length: Int = arr.asInstanceOf[Array[Int]].length - extension (arr: IArray[Long]) def length: Int = arr.asInstanceOf[Array[Long]].length - extension (arr: IArray[Float]) def length: Int = arr.asInstanceOf[Array[Float]].length - extension (arr: IArray[Double]) def length: Int = arr.asInstanceOf[Array[Double]].length - extension (arr: IArray[Object]) def length: Int = arr.asInstanceOf[Array[Object]].length - extension [T](arr: IArray[T]) def length: Int = arr.asInstanceOf[Array[T]].length - - extension [T, U >: T: ClassTag](arr: IArray[T]) def ++(that: IArray[U]): IArray[U] = - genericArrayOps(arr) ++ that - - extension [T](arr: IArray[T]) def contains(elem: T): Boolean = - genericArrayOps(arr).exists(_ == elem) - - extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U]): Int = - genericArrayOps(arr).copyToArray(xs) - - extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U], start: Int): Int = - genericArrayOps(arr).copyToArray(xs, start) - - extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U], start: Int, len: Int): Int = - genericArrayOps(arr).copyToArray(xs, start, len) - - extension [T](arr: IArray[T]) def count(p: T => Boolean): Int = - genericArrayOps(arr).count(p) - - extension [T](arr: IArray[T]) def drop(n: Int): IArray[T] = - genericArrayOps(arr).drop(n) - - extension [T](arr: IArray[T]) def dropRight(n: Int): IArray[T] = - genericArrayOps(arr).dropRight(n) - - extension [T](arr: IArray[T]) def dropWhile(p: T => Boolean): IArray[T] = - genericArrayOps(arr).dropWhile(p) - - extension [T](arr: IArray[T]) def exists(p: T => Boolean): Boolean = - genericArrayOps(arr).exists(p) - - extension [T](arr: IArray[T]) def filter(p: T => Boolean): IArray[T] = - genericArrayOps(arr).filter(p) - - extension [T](arr: IArray[T]) def filterNot(p: T => Boolean): IArray[T] = - genericArrayOps(arr).filterNot(p) - - extension [T](arr: IArray[T]) def find(p: T => Boolean): Option[T] = - genericArrayOps(arr).find(p) - - extension [T, U: ClassTag](arr: IArray[T]) def flatMap(f: T => IterableOnce[U]): IArray[U] = - genericArrayOps(arr).flatMap(f) - - extension [T, U: ClassTag](arr: IArray[T]) def flatten(using T => Iterable[U]): IArray[U] = - genericArrayOps(arr).flatten - - extension [T, U >: T: ClassTag](arr: IArray[T]) def fold(z: U)(op: (U, U) => U): U = - genericArrayOps(arr).fold(z)(op) - - extension [T, U: ClassTag](arr: IArray[T]) def foldLeft(z: U)(op: (U, T) => U): U = - genericArrayOps(arr).foldLeft(z)(op) - - extension [T, U: ClassTag](arr: IArray[T]) def foldRight(z: U)(op: (T, U) => U): U = - genericArrayOps(arr).foldRight(z)(op) - - extension [T](arr: IArray[T]) def forall(p: T => Boolean): Boolean = - genericArrayOps(arr).forall(p) - - extension [T, U](arr: IArray[T]) def foreach(f: T => U): Unit = - genericArrayOps(arr).foreach(f) - - extension [T](arr: IArray[T]) def head: T = - genericArrayOps(arr).head - - extension [T](arr: IArray[T]) def headOption: Option[T] = - genericArrayOps(arr).headOption - - extension [T](arr: IArray[T]) def indexOf(elem: T, from: Int = 0): Int = - // `asInstanceOf` needed because `elem` does not have type `arr.T` - // We could use `arr.iterator.indexOf(elem, from)` or `arr.indexWhere(_ == elem, from)` - // but these would incur some overhead. - genericArrayOps(arr).indexOf(elem.asInstanceOf, from) - - extension [T](arr: IArray[T]) def indexWhere(p: T => Boolean, from: Int = 0): Int = - genericArrayOps(arr).indexWhere(p, from) - - extension [T](arr: IArray[T]) def indices: Range = - genericArrayOps(arr).indices - - extension [T](arr: IArray[T]) def init: IArray[T] = - genericArrayOps(arr).init - - extension [T](arr: IArray[T]) def isEmpty: Boolean = - genericArrayOps(arr).isEmpty - - extension [T](arr: IArray[T]) def iterator: Iterator[T] = - genericArrayOps(arr).iterator - - extension [T](arr: IArray[T]) def last: T = - genericArrayOps(arr).last - - extension [T](arr: IArray[T]) def lastOption: Option[T] = - genericArrayOps(arr).lastOption - - extension [T](arr: IArray[T]) def lastIndexOf(elem: T, end: Int = arr.length - 1): Int = - // see: same issue in `indexOf` - genericArrayOps(arr).lastIndexOf(elem.asInstanceOf, end) - - extension [T](arr: IArray[T]) def lastIndexWhere(p: T => Boolean, end: Int = arr.length - 1): Int = - genericArrayOps(arr).lastIndexWhere(p, end) - - extension [T, U: ClassTag](arr: IArray[T]) def map(f: T => U): IArray[U] = - genericArrayOps(arr).map(f) - - extension [T](arr: IArray[T]) def nonEmpty: Boolean = - genericArrayOps(arr).nonEmpty - - extension [T](arr: IArray[T]) def partition(p: T => Boolean): (IArray[T], IArray[T]) = - genericArrayOps(arr).partition(p) - - extension [T](arr: IArray[T]) def reverse: IArray[T] = - genericArrayOps(arr).reverse - - extension [T, U >: T: ClassTag](arr: IArray[T]) def scan(z: U)(op: (U, U) => U): IArray[U] = - genericArrayOps(arr).scan(z)(op) - - extension [T, U: ClassTag](arr: IArray[T]) def scanLeft(z: U)(op: (U, T) => U): IArray[U] = - genericArrayOps(arr).scanLeft(z)(op) - - extension [T, U: ClassTag](arr: IArray[T]) def scanRight(z: U)(op: (T, U) => U): IArray[U] = - genericArrayOps(arr).scanRight(z)(op) - - extension [T](arr: IArray[T]) def size: Int = - arr.length - - extension [T](arr: IArray[T]) def slice(from: Int, until: Int): IArray[T] = - genericArrayOps(arr).slice(from, until) - - extension [T, U: ClassTag](arr: IArray[T]) def sortBy(f: T => U)(using math.Ordering[U]): IArray[T] = - genericArrayOps(arr).sortBy(f) - - extension [T](arr: IArray[T]) def sortWith(f: (T, T) => Boolean): IArray[T] = - genericArrayOps(arr).sortWith(f) - - extension [T](arr: IArray[T]) def sorted(using math.Ordering[T]): IArray[T] = - genericArrayOps(arr).sorted - - extension [T](arr: IArray[T]) def span(p: T => Boolean): (IArray[T], IArray[T]) = - genericArrayOps(arr).span(p) - - extension [T](arr: IArray[T]) def splitAt(n: Int): (IArray[T], IArray[T]) = - genericArrayOps(arr).splitAt(n) - - extension [T, U >: T: ClassTag](arr: IArray[T]) def startsWith(that: IArray[U], offset: Int = 0): Boolean = - genericArrayOps(arr).startsWith(that) - - extension [T](arr: IArray[T]) def tail: IArray[T] = - genericArrayOps(arr).tail - - extension [T](arr: IArray[T]) def take(n: Int): IArray[T] = - genericArrayOps(arr).take(n) - - extension [T](arr: IArray[T]) def takeRight(n: Int): IArray[T] = - genericArrayOps(arr).takeRight(n) - - extension [T](arr: IArray[T]) def takeWhile(p: T => Boolean): IArray[T] = - genericArrayOps(arr).takeWhile(p) - - extension [T](arr: IArray[T]) def toArray: Array[T] = - arr.clone.asInstanceOf[Array[T]] - - extension [U: ClassTag, V: ClassTag](arr: IArray[(U, V)]) def unzip: (IArray[U], IArray[V]) = - genericArrayOps(arr).unzip - - extension [T, U: ClassTag](arr: IArray[T]) def zip(that: IArray[U]): IArray[(T, U)] = - genericArrayOps(arr).zip(that) - } -end opaques - -type IArray[+T] = opaques.IArray[T] - -object IArray { - import opaques.Sub - import opaques.Sup - - private given [A]: Conversion[Array[A], IArray[A]] = identity[Sub[A]] - - def unsafeFromArray[T](s: Array[T]): IArray[T] = s - - def empty[T: ClassTag]: IArray[T] = new Array[T](0) - - def emptyBooleanIArray: IArray[Boolean] = Array.emptyBooleanArray - def emptyByteIArray: IArray[Byte] = Array.emptyByteArray - def emptyCharIArray: IArray[Char] = Array.emptyCharArray - def emptyDoubleIArray: IArray[Double] = Array.emptyDoubleArray - def emptyFloatIArray: IArray[Float] = Array.emptyFloatArray - def emptyIntIArray: IArray[Int] = Array.emptyIntArray - def emptyLongIArray: IArray[Long] = Array.emptyLongArray - def emptyShortIArray: IArray[Short] = Array.emptyShortArray - def emptyObjectIArray: IArray[Object] = Array.emptyObjectArray - - inline def apply[T](inline xs: T*)(using inline ct: ClassTag[T]): IArray[T] = Array(xs: _*).asInstanceOf - inline def apply(inline x: Boolean, inline xs: Boolean*): IArray[Boolean] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Byte, inline xs: Byte*): IArray[Byte] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Short, inline xs: Short*): IArray[Short] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Char, inline xs: Char*): IArray[Char] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Int, inline xs: Int*): IArray[Int] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Long, inline xs: Long*): IArray[Long] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Float, inline xs: Float*): IArray[Float] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Double, inline xs: Double*): IArray[Double] = Array(x, xs: _*).asInstanceOf - inline def apply(inline x: Unit, inline xs: Unit*): IArray[Unit] = Array(x, xs: _*).asInstanceOf - - def concat[T: ClassTag](xss: IArray[T]*): IArray[T] = - // `Array.concat` should arguably take in a `Seq[Array[_ <: T]]`, - // but since it currently takes a `Seq[Array[T]]` we have to perform a cast, - // knowing tacitly that `concat` is not going to do the wrong thing. - Array.concat[T](xss.asInstanceOf[Seq[Array[T]]]: _*) - - def fill[T: ClassTag](n: Int)(elem: => T): IArray[T] = - Array.fill(n)(elem) - - def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): IArray[IArray[T]] = - // We cannot avoid a cast here as Array.fill creates inner arrays out of our control: - Array.fill(n1, n2)(elem).asInstanceOf - - def fill[T: ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): IArray[IArray[IArray[T]]] = - Array.fill(n1, n2, n3)(elem).asInstanceOf - - def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): IArray[IArray[IArray[IArray[T]]]] = - Array.fill(n1, n2, n3, n4)(elem).asInstanceOf - - def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): IArray[IArray[IArray[IArray[IArray[T]]]]] = - Array.fill(n1, n2, n3, n4, n5)(elem).asInstanceOf - - def tabulate[T: ClassTag](n: Int)(f: Int => T): IArray[T] = - Array.tabulate(n)(f) - - def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): IArray[IArray[T]] = - Array.tabulate(n1, n2)(f).asInstanceOf - - def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): IArray[IArray[IArray[T]]] = - Array.tabulate(n1, n2, n3)(f).asInstanceOf - - def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): IArray[IArray[IArray[IArray[T]]]] = - Array.tabulate(n1, n2, n3, n4)(f).asInstanceOf - - def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): IArray[IArray[IArray[IArray[IArray[T]]]]] = - Array.tabulate(n1, n2, n3, n4, n5)(f).asInstanceOf - - def range(start: Int, end: Int): IArray[Int] = Array.range(start, end) - - def range(start: Int, end: Int, step: Int): IArray[Int] = Array.range(start, end, step) - - def iterate[T: ClassTag](start: T, len: Int)(f: T => T): IArray[T] = Array.iterate(start, len)(f) - - def unapplySeq[T](x: IArray[T]) = - Array.unapplySeq((x: Sup[T]): Array[_ <: T]) -} diff --git a/library/src-non-bootstrapped/scala/Tuple.scala b/library/src-non-bootstrapped/scala/Tuple.scala deleted file mode 100644 index 4ebbb456d775..000000000000 --- a/library/src-non-bootstrapped/scala/Tuple.scala +++ /dev/null @@ -1,278 +0,0 @@ -package scala -import annotation.showAsInfix -import compiletime._ - -/** Tuple of arbitrary arity */ -sealed trait Tuple extends Product { - import Tuple._ - - /** Create a copy this tuple as an Array */ - inline def toArray: Array[Object] = - scala.runtime.Tuple.toArray(this) - - /** Create a copy this tuple as a List */ - inline def toList: List[Union[this.type]] = - this.productIterator.toList - .asInstanceOf[List[Union[this.type]]] - - /** Create a copy this tuple as an IArray */ - inline def toIArray: IArray[Object] = - scala.runtime.Tuple.toIArray(this) - - /** Return a new tuple by prepending the element to `this` tuple. - * This operation is O(this.size) - */ - inline def *: [H, This >: this.type <: Tuple] (x: H): H *: This = - scala.runtime.Tuple.cons(x, this).asInstanceOf[H *: This] - - /** Return a new tuple by concatenating `this` tuple with `that` tuple. - * This operation is O(this.size + that.size) - */ - inline def ++ [This >: this.type <: Tuple](that: Tuple): Concat[This, that.type] = - scala.runtime.Tuple.concat(this, that).asInstanceOf[Concat[This, that.type]] - - /** Return the size (or arity) of the tuple */ - inline def size[This >: this.type <: Tuple]: Size[This] = - scala.runtime.Tuple.size(this).asInstanceOf[Size[This]] - - /** Given two tuples, `(a1, ..., an)` and `(a1, ..., an)`, returns a tuple - * `((a1, b1), ..., (an, bn))`. If the two tuples have different sizes, - * the extra elements of the larger tuple will be disregarded. - * The result is typed as `((A1, B1), ..., (An, Bn))` if at least one of the - * tuple types has a `EmptyTuple` tail. Otherwise the result type is - * `(A1, B1) *: ... *: (Ai, Bi) *: Tuple` - */ - inline def zip[This >: this.type <: Tuple, T2 <: Tuple](t2: T2): Zip[This, T2] = - scala.runtime.Tuple.zip(this, t2).asInstanceOf[Zip[This, T2]] - - /** Called on a tuple `(a1, ..., an)`, returns a new tuple `(f(a1), ..., f(an))`. - * The result is typed as `(F[A1], ..., F[An])` if the tuple type is fully known. - * If the tuple is of the form `a1 *: ... *: Tuple` (that is, the tail is not known - * to be the cons type. - */ - inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] = - scala.runtime.Tuple.map(this, f).asInstanceOf[Map[this.type, F]] - - /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting - * of its first n elements. - */ - inline def take[This >: this.type <: Tuple](n: Int): Take[This, n.type] = - scala.runtime.Tuple.take(this, n).asInstanceOf[Take[This, n.type]] - - - /** Given a tuple `(a1, ..., am)`, returns the tuple `(an+1, ..., am)` consisting - * all its elements except the first n ones. - */ - inline def drop[This >: this.type <: Tuple](n: Int): Drop[This, n.type] = - scala.runtime.Tuple.drop(this, n).asInstanceOf[Drop[This, n.type]] - - /** Given a tuple `(a1, ..., am)`, returns a pair of the tuple `(a1, ..., an)` - * consisting of the first n elements, and the tuple `(an+1, ..., am)` consisting - * of the remaining elements. - */ - inline def splitAt[This >: this.type <: Tuple](n: Int): Split[This, n.type] = - scala.runtime.Tuple.splitAt(this, n).asInstanceOf[Split[This, n.type]] -} - -object Tuple { - - /** Type of the head of a tuple */ - type Head[X <: NonEmptyTuple] = X match { - case x *: _ => x - } - - /** Type of the tail of a tuple */ - type Tail[X <: NonEmptyTuple] <: Tuple = X match { - case _ *: xs => xs - } - - /** Type of the concatenation of two tuples */ - type Concat[X <: Tuple, +Y <: Tuple] <: Tuple = X match { - case EmptyTuple => Y - case x1 *: xs1 => x1 *: Concat[xs1, Y] - } - - /** Type of the element a position N in the tuple X */ - type Elem[X <: Tuple, N <: Int] = X match { - case x *: xs => - N match { - case 0 => x - case S[n1] => Elem[xs, n1] - } - } - - /** Literal constant Int size of a tuple */ - type Size[X <: Tuple] <: Int = X match { - case EmptyTuple => 0 - case x *: xs => S[Size[xs]] - } - - /** Fold a tuple `(T1, ..., Tn)` into `F[T1, F[... F[Tn, Z]...]]]` */ - type Fold[T <: Tuple, Z, F[_, _]] = T match - case EmptyTuple => Z - case h *: t => F[h, Fold[t, Z, F]] - - /** Converts a tuple `(T1, ..., Tn)` to `(F[T1], ..., F[Tn])` */ - type Map[Tup <: Tuple, F[_]] <: Tuple = Tup match { - case EmptyTuple => EmptyTuple - case h *: t => F[h] *: Map[t, F] - } - - /** Converts a tuple `(T1, ..., Tn)` to a flattened `(..F[T1], ..., ..F[Tn])` */ - type FlatMap[Tup <: Tuple, F[_] <: Tuple] <: Tuple = Tup match { - case EmptyTuple => EmptyTuple - case h *: t => Concat[F[h], FlatMap[t, F]] - } - - /** Filters out those members of the tuple for which the predicate `P` returns `false`. - * A predicate `P[X]` is a type that can be either `true` or `false`. For example: - * ``` - * type IsString[x] = x match { - * case String => true - * case _ => false - * } - * Filter[(1, "foo", 2, "bar"), IsString] =:= ("foo", "bar") - * ``` - */ - type Filter[Tup <: Tuple, P[_] <: Boolean] <: Tuple = Tup match { - case EmptyTuple => EmptyTuple - case h *: t => P[h] match { - case true => h *: Filter[t, P] - case false => Filter[t, P] - } - } - - /** Given two tuples, `A1 *: ... *: An * At` and `B1 *: ... *: Bn *: Bt` - * where at least one of `At` or `Bt` is `EmptyTuple` or `Tuple`, - * returns the tuple type `(A1, B1) *: ... *: (An, Bn) *: Ct` - * where `Ct` is `EmptyTuple` if `At` or `Bt` is `EmptyTuple`, otherwise `Ct` is `Tuple`. - */ - type Zip[T1 <: Tuple, T2 <: Tuple] <: Tuple = (T1, T2) match { - case (h1 *: t1, h2 *: t2) => (h1, h2) *: Zip[t1, t2] - case (EmptyTuple, _) => EmptyTuple - case (_, EmptyTuple) => EmptyTuple - case _ => Tuple - } - - /** Converts a tuple `(F[T1], ..., F[Tn])` to `(T1, ... Tn)` */ - type InverseMap[X <: Tuple, F[_]] <: Tuple = X match { - case F[x] *: t => x *: InverseMap[t, F] - case EmptyTuple => EmptyTuple - } - - /** Implicit evidence. IsMappedBy[F][X] is present in the implicit scope iff - * X is a tuple for which each element's type is constructed via `F`. E.g. - * (F[A1], ..., F[An]), but not `(F[A1], B2, ..., F[An])` where B2 does not - * have the shape of `F[A]`. - */ - type IsMappedBy[F[_]] = [X <: Tuple] =>> X =:= Map[InverseMap[X, F], F] - - /** Transforms a tuple `(T1, ..., Tn)` into `(T1, ..., Ti)`. */ - type Take[T <: Tuple, N <: Int] <: Tuple = N match { - case 0 => EmptyTuple - case S[n1] => T match { - case EmptyTuple => EmptyTuple - case x *: xs => x *: Take[xs, n1] - } - } - - /** Transforms a tuple `(T1, ..., Tn)` into `(Ti+1, ..., Tn)`. */ - type Drop[T <: Tuple, N <: Int] <: Tuple = N match { - case 0 => T - case S[n1] => T match { - case EmptyTuple => EmptyTuple - case x *: xs => Drop[xs, n1] - } - } - - /** Splits a tuple (T1, ..., Tn) into a pair of two tuples `(T1, ..., Ti)` and - * `(Ti+1, ..., Tn)`. - */ - type Split[T <: Tuple, N <: Int] = (Take[T, N], Drop[T, N]) - - /** Given a tuple `(T1, ..., Tn)`, returns a union of its - * member types: `T1 | ... | Tn`. Returns `Nothing` if the tuple is empty. - */ - type Union[T <: Tuple] = Fold[T, Nothing, [x, y] =>> x | y] - - /** Empty tuple */ - def apply(): EmptyTuple = EmptyTuple - - /** Tuple with one element */ - def apply[T](x: T): T *: EmptyTuple = Tuple1(x) - - /** Matches an empty tuple. */ - def unapply(x: EmptyTuple): true = true - - /** Convert an array into a tuple of unknown arity and types */ - def fromArray[T](xs: Array[T]): Tuple = { - val xs2 = xs match { - case xs: Array[Object] => xs - case xs => xs.map(_.asInstanceOf[Object]) - } - scala.runtime.Tuple.fromArray(xs2).asInstanceOf[Tuple] - } - - /** Convert an immutable array into a tuple of unknown arity and types */ - def fromIArray[T](xs: IArray[T]): Tuple = { - val xs2: IArray[Object] = xs match { - case xs: IArray[Object] @unchecked => xs - case xs => - // TODO support IArray.map - xs.asInstanceOf[Array[T]].map(_.asInstanceOf[Object]).asInstanceOf[IArray[Object]] - } - scala.runtime.Tuple.fromIArray(xs2).asInstanceOf[Tuple] - } - - /** Convert a Product into a tuple of unknown arity and types */ - def fromProduct(product: Product): Tuple = - scala.runtime.Tuple.fromProduct(product) - - def fromProductTyped[P <: Product](p: P)(using m: scala.deriving.Mirror.ProductOf[P]): m.MirroredElemTypes = - scala.runtime.Tuple.fromProduct(p).asInstanceOf[m.MirroredElemTypes] -} - -/** A tuple of 0 elements */ -type EmptyTuple = EmptyTuple.type - -/** A tuple of 0 elements. */ -object EmptyTuple extends Tuple { - override def productArity: Int = 0 - - @throws(classOf[IndexOutOfBoundsException]) - override def productElement(n: Int): Any = - throw new IndexOutOfBoundsException(n.toString()) - - def canEqual(that: Any): Boolean = this == that - - override def toString(): String = "()" -} - -/** Tuple of arbitrary non-zero arity */ -sealed trait NonEmptyTuple extends Tuple { - import Tuple._ - - /** Get the i-th element of this tuple. - * Equivalent to productElement but with a precise return type. - */ - inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] = - scala.runtime.Tuple.apply(this, n).asInstanceOf[Elem[This, n.type]] - - /** Get the head of this tuple */ - inline def head[This >: this.type <: NonEmptyTuple]: Head[This] = - scala.runtime.Tuple.apply(this, 0).asInstanceOf[Head[This]] - - /** Get the tail of this tuple. - * This operation is O(this.size) - */ - inline def tail[This >: this.type <: NonEmptyTuple]: Tail[This] = - scala.runtime.Tuple.tail(this).asInstanceOf[Tail[This]] - -} - -@showAsInfix -sealed abstract class *:[+H, +T <: Tuple] extends NonEmptyTuple - -object *: { - def unapply[H, T <: Tuple](x: H *: T): (H, T) = (x.head, x.tail) -} diff --git a/library/src-non-bootstrapped/scala/quoted/Expr.scala b/library/src-non-bootstrapped/scala/quoted/Expr.scala deleted file mode 100644 index bf2b8f025002..000000000000 --- a/library/src-non-bootstrapped/scala/quoted/Expr.scala +++ /dev/null @@ -1,3 +0,0 @@ -package scala.quoted - -abstract class Expr[+T] private[scala] diff --git a/library/src-non-bootstrapped/scala/quoted/FromExpr.scala b/library/src-non-bootstrapped/scala/quoted/FromExpr.scala deleted file mode 100644 index a6165d22b130..000000000000 --- a/library/src-non-bootstrapped/scala/quoted/FromExpr.scala +++ /dev/null @@ -1,4 +0,0 @@ -package scala.quoted - -trait FromExpr[T]: - def unapply(x: Expr[T])(using Quotes): Option[T] diff --git a/library/src-non-bootstrapped/scala/quoted/Quotes.scala b/library/src-non-bootstrapped/scala/quoted/Quotes.scala deleted file mode 100644 index 3667970d53f9..000000000000 --- a/library/src-non-bootstrapped/scala/quoted/Quotes.scala +++ /dev/null @@ -1,2800 +0,0 @@ -package scala.quoted - -import scala.reflect.TypeTest - -inline def quotes(using q: Quotes): q.type = q - -trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => - - extension [T](self: Expr[T]) - def show: String - - def matches(that: Expr[Any]): Boolean - - def value(using FromExpr[T]): Option[T] = - given Quotes = Quotes.this - summon[FromExpr[T]].unapply(self) - - def valueOrError(using FromExpr[T]): T = - val fromExpr = summon[FromExpr[T]] - def reportError = - val msg = s"Expected a known value. \n\nThe value of: ${self.show}\ncould not be extracted using $fromExpr" - reflect.report.throwError(msg, self) - given Quotes = Quotes.this - fromExpr.unapply(self).getOrElse(reportError) - - end extension - - extension [X](self: Expr[Any]) - def isExprOf(using Type[X]): Boolean - - def asExprOf(using Type[X]): Expr[X] - end extension - - val reflect: reflectModule - - trait reflectModule { self: reflect.type => - - extension (expr: Expr[Any]) - def asTerm: Term - - type Tree <: AnyRef - - val Tree: TreeModule - - trait TreeModule { this: Tree.type => - } - - given TreeMethods: TreeMethods - - trait TreeMethods { - - extension (self: Tree) - def pos: Position - - def symbol: Symbol - - def show(using Printer[Tree]): String - - def isExpr: Boolean - - def asExpr: Expr[Any] - end extension - - extension [T](self: Tree) - def asExprOf(using Type[T]): Expr[T] - - extension [ThisTree <: Tree](self: ThisTree) - def changeOwner(newOwner: Symbol): ThisTree - end extension - - } - - type PackageClause <: Tree - - given PackageClauseTypeTest: TypeTest[Tree, PackageClause] - - val PackageClause: PackageClauseModule - - trait PackageClauseModule { this: PackageClause.type => - def apply(pid: Ref, stats: List[Tree]): PackageClause - def copy(original: Tree)(pid: Ref, stats: List[Tree]): PackageClause - def unapply(tree: PackageClause): (Ref, List[Tree]) - } - - given PackageClauseMethods: PackageClauseMethods - - trait PackageClauseMethods: - extension (self: PackageClause) - def pid: Ref - def stats: List[Tree] - end extension - end PackageClauseMethods - - type Import <: Statement - - given ImportTypeTest: TypeTest[Tree, Import] - - val Import: ImportModule - - trait ImportModule { this: Import.type => - def apply(expr: Term, selectors: List[Selector]): Import - def copy(original: Tree)(expr: Term, selectors: List[Selector]): Import - def unapply(tree: Import): (Term, List[Selector]) - } - - given ImportMethods: ImportMethods - - trait ImportMethods: - extension (self: Import) - def expr: Term - def selectors: List[Selector] - end extension - end ImportMethods - - type Export <: Statement - - given ExportTypeTest: TypeTest[Tree, Export] - - val Export: ExportModule - - trait ExportModule { this: Export.type => - def unapply(tree: Export): (Term, List[Selector]) - } - - given ExportMethods: ExportMethods - - trait ExportMethods: - extension (self: Export) - def expr: Term - def selectors: List[Selector] - end extension - end ExportMethods - - type Statement <: Tree - - given StatementTypeTest: TypeTest[Tree, Statement] - - type Definition <: Statement - - given DefinitionTypeTest: TypeTest[Tree, Definition] - - val Definition: DefinitionModule - - trait DefinitionModule { this: Definition.type => } - - given DefinitionMethods: DefinitionMethods - - trait DefinitionMethods: - extension (self: Definition) - def name: String - end extension - end DefinitionMethods - - type ClassDef <: Definition - - given ClassDefTypeTest: TypeTest[Tree, ClassDef] - - val ClassDef: ClassDefModule - - trait ClassDefModule { this: ClassDef.type => - def copy(original: Tree)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement]): ClassDef - def unapply(cdef: ClassDef): (String, DefDef, List[Tree /* Term | TypeTree */], List[TypeTree], Option[ValDef], List[Statement]) - } - - given ClassDefMethods: ClassDefMethods - - trait ClassDefMethods: - extension (self: ClassDef) - def constructor: DefDef - def parents: List[Tree /* Term | TypeTree */] - def derived: List[TypeTree] - def self: Option[ValDef] - def body: List[Statement] - end extension - end ClassDefMethods - - type DefDef <: Definition - - given DefDefTypeTest: TypeTest[Tree, DefDef] - - val DefDef: DefDefModule - - trait DefDefModule { this: DefDef.type => - def apply(symbol: Symbol, rhsFn: List[TypeRepr] => List[List[Term]] => Option[Term]): DefDef - def copy(original: Tree)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term]): DefDef - def copy(original: Tree)(name: String, paramss: List[ParamClause], tpt: TypeTree, rhs: Option[Term]): DefDef = ??? - // def unapply(ddef: DefDef): (String, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term]) - def unapply(ddef: DefDef): (String, List[ParamClause], TypeTree, Option[Term]) = ??? - } - - given DefDefMethods: DefDefMethods - - trait DefDefMethods: - extension (self: DefDef) - def paramss: List[ParamClause] = ??? - def typeParams: List[TypeDef] - def returnTpt: TypeTree - def rhs: Option[Term] - end extension - end DefDefMethods - - type ValDef <: Definition - - given ValDefTypeTest: TypeTest[Tree, ValDef] - - val ValDef: ValDefModule - - trait ValDefModule { this: ValDef.type => - def apply(symbol: Symbol, rhs: Option[Term]): ValDef - def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef - def unapply(vdef: ValDef): (String, TypeTree, Option[Term]) - - def let(owner: Symbol, name: String, rhs: Term)(body: Ident => Term): Term - - def let(owner: Symbol, rhs: Term)(body: Ident => Term): Term = - let(owner, "x", rhs)(body) - - def let(owner: Symbol, terms: List[Term])(body: List[Ident] => Term): Term - } - - given ValDefMethods: ValDefMethods - - trait ValDefMethods: - extension (self: ValDef) - def tpt: TypeTree - def rhs: Option[Term] - end extension - end ValDefMethods - - type TypeDef <: Definition - - given TypeDefTypeTest: TypeTest[Tree, TypeDef] - - val TypeDef: TypeDefModule - - trait TypeDefModule { this: TypeDef.type => - def apply(symbol: Symbol): TypeDef - def copy(original: Tree)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/): TypeDef - def unapply(tdef: TypeDef): (String, Tree /*TypeTree | TypeBoundsTree*/ /* TypeTree | TypeBoundsTree */) - } - - given TypeDefMethods: TypeDefMethods - - trait TypeDefMethods: - extension (self: TypeDef) - def rhs: Tree /*TypeTree | TypeBoundsTree*/ - end extension - end TypeDefMethods - - type Term <: Statement - - given TermTypeTest: TypeTest[Tree, Term] - - val Term: TermModule - - trait TermModule { this: Term.type => - - def betaReduce(term: Term): Option[Term] - - } - - given TermMethods: TermMethods - - trait TermMethods { - extension (self: Term) - - def tpe: TypeRepr - - def underlyingArgument: Term - - def underlying: Term - - def etaExpand(owner: Symbol): Term - - def appliedTo(arg: Term): Term - - def appliedTo(arg: Term, args: Term*): Term - - def appliedToArgs(args: List[Term]): Apply - - def appliedToArgss(argss: List[List[Term]]): Term - - def appliedToNone: Apply - - def appliedToType(targ: TypeRepr): Term - - def appliedToTypes(targs: List[TypeRepr]): Term - - def appliedToTypeTrees(targs: List[TypeTree]): Term - - def select(sym: Symbol): Select - - end extension - - } - - type Ref <: Term - - given RefTypeTest: TypeTest[Tree, Ref] - - val Ref: RefModule - - trait RefModule { this: Ref.type => - - def term(tp: TermRef): Ref - - def apply(sym: Symbol): Ref - } - - type Ident <: Ref - - given IdentTypeTest: TypeTest[Tree, Ident] - - val Ident: IdentModule - - trait IdentModule { this: Ident.type => - def apply(tmref: TermRef): Term - - def copy(original: Tree)(name: String): Ident - - def unapply(tree: Ident): Some[String] - } - - given IdentMethods: IdentMethods - - trait IdentMethods: - extension (self: Ident) - def name: String - end extension - end IdentMethods - - type Select <: Ref - - given SelectTypeTest: TypeTest[Tree, Select] - - val Select: SelectModule - - trait SelectModule { this: Select.type => - def apply(qualifier: Term, symbol: Symbol): Select - - def unique(qualifier: Term, name: String): Select - - def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term]): Apply - - def overloaded(qualifier: Term, name: String, targs: List[TypeRepr], args: List[Term], returnType: TypeRepr): Apply - - def copy(original: Tree)(qualifier: Term, name: String): Select - - def unapply(x: Select): (Term, String) - } - - given SelectMethods: SelectMethods - - trait SelectMethods: - extension (self: Select) - def qualifier: Term - def name: String - def signature: Option[Signature] - end extension - end SelectMethods - - given LiteralTypeTest: TypeTest[Tree, Literal] - - type Literal <: Term - - val Literal: LiteralModule - - trait LiteralModule { this: Literal.type => - - def apply(constant: Constant): Literal - - def copy(original: Tree)(constant: Constant): Literal - - def unapply(x: Literal): Some[Constant] - } - - given LiteralMethods: LiteralMethods - - trait LiteralMethods: - extension (self: Literal) - def constant: Constant - end extension - end LiteralMethods - - type This <: Term - - given ThisTypeTest: TypeTest[Tree, This] - - val This: ThisModule - - trait ThisModule { this: This.type => - - def apply(cls: Symbol): This - - def copy(original: Tree)(qual: Option[String]): This - - def unapply(x: This): Some[Option[String]] - } - - given ThisMethods: ThisMethods - - trait ThisMethods: - extension (self: This) - def id: Option[String] - end extension - end ThisMethods - - type New <: Term - - given NewTypeTest: TypeTest[Tree, New] - - val New: NewModule - - trait NewModule { this: New.type => - - def apply(tpt: TypeTree): New - - def copy(original: Tree)(tpt: TypeTree): New - - def unapply(x: New): Some[TypeTree] - } - - given NewMethods: NewMethods - - trait NewMethods: - extension (self: New) - def tpt: TypeTree - end extension - end NewMethods - - type NamedArg <: Term - - given NamedArgTypeTest: TypeTest[Tree, NamedArg] - - val NamedArg: NamedArgModule - - trait NamedArgModule { this: NamedArg.type => - - def apply(name: String, arg: Term): NamedArg - - def copy(original: Tree)(name: String, arg: Term): NamedArg - - def unapply(x: NamedArg): (String, Term) - } - - given NamedArgMethods: NamedArgMethods - - trait NamedArgMethods: - extension (self: NamedArg) - def name: String - def value: Term - end extension - end NamedArgMethods - - type Apply <: Term - - given ApplyTypeTest: TypeTest[Tree, Apply] - - val Apply: ApplyModule - - trait ApplyModule { this: Apply.type => - - def apply(fun: Term, args: List[Term]): Apply - - def copy(original: Tree)(fun: Term, args: List[Term]): Apply - - def unapply(x: Apply): (Term, List[Term]) - } - - given ApplyMethods: ApplyMethods - - trait ApplyMethods: - extension (self: Apply) - def fun: Term - def args: List[Term] - end extension - end ApplyMethods - - type TypeApply <: Term - - given TypeApplyTypeTest: TypeTest[Tree, TypeApply] - - val TypeApply: TypeApplyModule - - trait TypeApplyModule { this: TypeApply.type => - - def apply(fun: Term, args: List[TypeTree]): TypeApply - - def copy(original: Tree)(fun: Term, args: List[TypeTree]): TypeApply - - def unapply(x: TypeApply): (Term, List[TypeTree]) - } - - given TypeApplyMethods: TypeApplyMethods - - trait TypeApplyMethods: - extension (self: TypeApply) - def fun: Term - def args: List[TypeTree] - end extension - end TypeApplyMethods - - given SuperTypeTest: TypeTest[Tree, Super] - - type Super <: Term - - val Super: SuperModule - - trait SuperModule { this: Super.type => - - def apply(qual: Term, mix: Option[String]): Super - - def copy(original: Tree)(qual: Term, mix: Option[String]): Super - - def unapply(x: Super): (Term, Option[String]) - } - - given SuperMethods: SuperMethods - - trait SuperMethods: - extension (self: Super) - def qualifier: Term - def id: Option[String] - def idPos: Position - end extension - end SuperMethods - - given TypedTypeTest: TypeTest[Tree, Typed] - - type Typed <: Term - - val Typed: TypedModule - - trait TypedModule { this: Typed.type => - - def apply(expr: Term, tpt: TypeTree): Typed - - def copy(original: Tree)(expr: Term, tpt: TypeTree): Typed - - def unapply(x: Typed): (Term, TypeTree) - } - - given TypedMethods: TypedMethods - - trait TypedMethods: - extension (self: Typed) - def expr: Term - def tpt: TypeTree - end extension - end TypedMethods - - type Assign <: Term - - given AssignTypeTest: TypeTest[Tree, Assign] - - val Assign: AssignModule - - trait AssignModule { this: Assign.type => - - def apply(lhs: Term, rhs: Term): Assign - - def copy(original: Tree)(lhs: Term, rhs: Term): Assign - - def unapply(x: Assign): (Term, Term) - } - - given AssignMethods: AssignMethods - - trait AssignMethods: - extension (self: Assign) - def lhs: Term - def rhs: Term - end extension - end AssignMethods - - type Block <: Term - - given BlockTypeTest: TypeTest[Tree, Block] - - val Block: BlockModule - - trait BlockModule { this: Block.type => - - def apply(stats: List[Statement], expr: Term): Block - - def copy(original: Tree)(stats: List[Statement], expr: Term): Block - - def unapply(x: Block): (List[Statement], Term) - } - - given BlockMethods: BlockMethods - - trait BlockMethods: - extension (self: Block) - def statements: List[Statement] - def expr: Term - end extension - end BlockMethods - - given ClosureTypeTest: TypeTest[Tree, Closure] - - type Closure <: Term - - val Closure: ClosureModule - - trait ClosureModule { this: Closure.type => - - def apply(meth: Term, tpe: Option[TypeRepr]): Closure - - def copy(original: Tree)(meth: Tree, tpe: Option[TypeRepr]): Closure - - def unapply(x: Closure): (Term, Option[TypeRepr]) - } - - given ClosureMethods: ClosureMethods - - trait ClosureMethods: - extension (self: Closure) - def meth: Term - def tpeOpt: Option[TypeRepr] - end extension - end ClosureMethods - - val Lambda: LambdaModule - - trait LambdaModule { this: Lambda.type => - def unapply(tree: Block): Option[(List[ValDef], Term)] - - def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block - } - - given IfTypeTest: TypeTest[Tree, If] - - type If <: Term - - val If: IfModule - - trait IfModule { this: If.type => - - def apply(cond: Term, thenp: Term, elsep: Term): If - - def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term): If - - def unapply(tree: If): (Term, Term, Term) - } - - given IfMethods: IfMethods - - trait IfMethods: - extension (self: If) - def cond: Term - def thenp: Term - def elsep: Term - def isInline: Boolean - end extension - end IfMethods - - type Match <: Term - - given MatchTypeTest: TypeTest[Tree, Match] - - val Match: MatchModule - - trait MatchModule { this: Match.type => - - def apply(selector: Term, cases: List[CaseDef]): Match - - def copy(original: Tree)(selector: Term, cases: List[CaseDef]): Match - - def unapply(x: Match): (Term, List[CaseDef]) - } - - given MatchMethods: MatchMethods - - trait MatchMethods: - extension (self: Match) - def scrutinee: Term - def cases: List[CaseDef] - def isInline: Boolean - end extension - end MatchMethods - - type SummonFrom <: Term - - given SummonFromTypeTest: TypeTest[Tree, SummonFrom] - - val SummonFrom: SummonFromModule - - trait SummonFromModule { this: SummonFrom.type => - - def apply(cases: List[CaseDef]): SummonFrom - - def copy(original: Tree)(cases: List[CaseDef]): SummonFrom - - def unapply(x: SummonFrom): Some[List[CaseDef]] - } - - given SummonFromMethods: SummonFromMethods - - trait SummonFromMethods: - extension (self: SummonFrom) - def cases: List[CaseDef] - end extension - end SummonFromMethods - - type Try <: Term - - given TryTypeTest: TypeTest[Tree, Try] - - val Try: TryModule - - trait TryModule { this: Try.type => - - def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try - - def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try - - def unapply(x: Try): (Term, List[CaseDef], Option[Term]) - } - - given TryMethods: TryMethods - - trait TryMethods: - extension (self: Try) - def body: Term - def cases: List[CaseDef] - def finalizer: Option[Term] - end extension - end TryMethods - - given ReturnTypeTest: TypeTest[Tree, Return] - - type Return <: Term - - val Return: ReturnModule - - trait ReturnModule { this: Return.type => - - def apply(expr: Term, from: Symbol): Return - - def copy(original: Tree)(expr: Term, from: Symbol): Return - - def unapply(x: Return): (Term, Symbol) - } - - given ReturnMethods: ReturnMethods - - trait ReturnMethods: - extension (self: Return) - def expr: Term - def from: Symbol - end extension - end ReturnMethods - - type Repeated <: Term - - given RepeatedTypeTest: TypeTest[Tree, Repeated] - - val Repeated: RepeatedModule - - trait RepeatedModule { this: Repeated.type => - def apply(elems: List[Term], tpt: TypeTree): Repeated - def copy(original: Tree)(elems: List[Term], tpt: TypeTree): Repeated - def unapply(x: Repeated): (List[Term], TypeTree) - } - - given RepeatedMethods: RepeatedMethods - - trait RepeatedMethods: - extension (self: Repeated) - def elems: List[Term] - def elemtpt: TypeTree - end extension - end RepeatedMethods - - type Inlined <: Term - - given InlinedTypeTest: TypeTest[Tree, Inlined] - - val Inlined: InlinedModule - - trait InlinedModule { this: Inlined.type => - def apply(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term): Inlined - def copy(original: Tree)(call: Option[Tree /* Term | TypeTree */], bindings: List[Definition], expansion: Term): Inlined - def unapply(x: Inlined): (Option[Tree /* Term | TypeTree */], List[Definition], Term) - } - - given InlinedMethods: InlinedMethods - - trait InlinedMethods: - extension (self: Inlined) - def call: Option[Tree /* Term | TypeTree */] - def bindings: List[Definition] - def body: Term - end extension - end InlinedMethods - - type SelectOuter <: Term - - given SelectOuterTypeTest: TypeTest[Tree, SelectOuter] - - val SelectOuter: SelectOuterModule - - trait SelectOuterModule { this: SelectOuter.type => - def apply(qualifier: Term, name: String, levels: Int): SelectOuter - def copy(original: Tree)(qualifier: Term, name: String, levels: Int): SelectOuter - def unapply(x: SelectOuter): (Term, String, Int) - } - - given SelectOuterMethods: SelectOuterMethods - - trait SelectOuterMethods: - extension (self: SelectOuter) - def qualifier: Term - def name: String - def level: Int - end extension - end SelectOuterMethods - - type While <: Term - - given WhileTypeTest: TypeTest[Tree, While] - - val While: WhileModule - - trait WhileModule { this: While.type => - - def apply(cond: Term, body: Term): While - - def copy(original: Tree)(cond: Term, body: Term): While - - def unapply(x: While): (Term, Term) - } - - given WhileMethods: WhileMethods - - trait WhileMethods: - extension (self: While) - def cond: Term - def body: Term - end extension - end WhileMethods - - type TypeTree <: Tree - - given TypeTreeTypeTest: TypeTest[Tree, TypeTree] - - val TypeTree: TypeTreeModule - - trait TypeTreeModule { this: TypeTree.type => - def of[T <: AnyKind](using Type[T]): TypeTree - } - - given TypeTreeMethods: TypeTreeMethods - - trait TypeTreeMethods: - extension (self: TypeTree) - def tpe: TypeRepr - end extension - end TypeTreeMethods - - type Inferred <: TypeTree - - given InferredTypeTest: TypeTest[Tree, Inferred] - - val Inferred: InferredModule - - trait InferredModule { this: Inferred.type => - def apply(tpe: TypeRepr): Inferred - def unapply(x: Inferred): true - } - - type TypeIdent <: TypeTree - - given TypeIdentTypeTest: TypeTest[Tree, TypeIdent] - - val TypeIdent: TypeIdentModule - - trait TypeIdentModule { this: TypeIdent.type => - def apply(sym: Symbol): TypeTree - def copy(original: Tree)(name: String): TypeIdent - def unapply(x: TypeIdent): Some[String] - } - - given TypeIdentMethods: TypeIdentMethods - - trait TypeIdentMethods: - extension (self: TypeIdent) - def name: String - end extension - end TypeIdentMethods - - type TypeSelect <: TypeTree - - given TypeSelectTypeTest: TypeTest[Tree, TypeSelect] - - val TypeSelect: TypeSelectModule - - trait TypeSelectModule { this: TypeSelect.type => - def apply(qualifier: Term, name: String): TypeSelect - def copy(original: Tree)(qualifier: Term, name: String): TypeSelect - def unapply(x: TypeSelect): (Term, String) - } - - given TypeSelectMethods: TypeSelectMethods - - trait TypeSelectMethods: - extension (self: TypeSelect) - def qualifier: Term - def name: String - end extension - end TypeSelectMethods - - type TypeProjection <: TypeTree - - given TypeProjectionTypeTest: TypeTest[Tree, TypeProjection] - - val TypeProjection: TypeProjectionModule - - trait TypeProjectionModule { this: TypeProjection.type => - def copy(original: Tree)(qualifier: TypeTree, name: String): TypeProjection - def unapply(x: TypeProjection): (TypeTree, String) - } - - given TypeProjectionMethods: TypeProjectionMethods - - trait TypeProjectionMethods: - extension (self: TypeProjection) - def qualifier: TypeTree - def name: String - end extension - end TypeProjectionMethods - - type Singleton <: TypeTree - - given SingletonTypeTest: TypeTest[Tree, Singleton] - - val Singleton: SingletonModule - - trait SingletonModule { this: Singleton.type => - def apply(ref: Term): Singleton - def copy(original: Tree)(ref: Term): Singleton - def unapply(x: Singleton): Some[Term] - } - - given SingletonMethods: SingletonMethods - - trait SingletonMethods: - extension (self: Singleton) - def ref: Term - end extension - end SingletonMethods - - type Refined <: TypeTree - - given RefinedTypeTest: TypeTest[Tree, Refined] - - val Refined: RefinedModule - - trait RefinedModule { this: Refined.type => - def copy(original: Tree)(tpt: TypeTree, refinements: List[Definition]): Refined - def unapply(x: Refined): (TypeTree, List[Definition]) - } - - given RefinedMethods: RefinedMethods - - trait RefinedMethods: - extension (self: Refined) - def tpt: TypeTree - def refinements: List[Definition] - end extension - end RefinedMethods - - type Applied <: TypeTree - - given AppliedTypeTest: TypeTest[Tree, Applied] - - val Applied: AppliedModule - - trait AppliedModule { this: Applied.type => - def apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/]): Applied - def copy(original: Tree)(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/]): Applied - def unapply(x: Applied): (TypeTree, List[Tree /*TypeTree | TypeBoundsTree*/]) - } - - given AppliedMethods: AppliedMethods - - trait AppliedMethods: - extension (self: Applied) - def tpt: TypeTree - def args: List[Tree /*TypeTree | TypeBoundsTree*/] - end extension - end AppliedMethods - - type Annotated <: TypeTree - - given AnnotatedTypeTest: TypeTest[Tree, Annotated] - - val Annotated: AnnotatedModule - - trait AnnotatedModule { this: Annotated.type => - def apply(arg: TypeTree, annotation: Term): Annotated - def copy(original: Tree)(arg: TypeTree, annotation: Term): Annotated - def unapply(x: Annotated): (TypeTree, Term) - } - - given AnnotatedMethods: AnnotatedMethods - - trait AnnotatedMethods: - extension (self: Annotated) - def arg: TypeTree - def annotation: Term - end extension - end AnnotatedMethods - - type MatchTypeTree <: TypeTree - - given MatchTypeTreeTypeTest: TypeTest[Tree, MatchTypeTree] - - val MatchTypeTree: MatchTypeTreeModule - - trait MatchTypeTreeModule { this: MatchTypeTree.type => - def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef]): MatchTypeTree - def copy(original: Tree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef]): MatchTypeTree - def unapply(x: MatchTypeTree): (Option[TypeTree], TypeTree, List[TypeCaseDef]) - } - - given MatchTypeTreeMethods: MatchTypeTreeMethods - - trait MatchTypeTreeMethods: - extension (self: MatchTypeTree) - def bound: Option[TypeTree] - def selector: TypeTree - def cases: List[TypeCaseDef] - end extension - end MatchTypeTreeMethods - - type ByName <: TypeTree - - given ByNameTypeTest: TypeTest[Tree, ByName] - - val ByName: ByNameModule - - trait ByNameModule { this: ByName.type => - def apply(result: TypeTree): ByName - def copy(original: Tree)(result: TypeTree): ByName - def unapply(x: ByName): Some[TypeTree] - } - - given ByNameMethods: ByNameMethods - - trait ByNameMethods: - extension (self: ByName) - def result: TypeTree - end extension - end ByNameMethods - - type LambdaTypeTree <: TypeTree - - given LambdaTypeTreeTypeTest: TypeTest[Tree, LambdaTypeTree] - - val LambdaTypeTree: LambdaTypeTreeModule - - trait LambdaTypeTreeModule { this: LambdaTypeTree.type => - def apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/): LambdaTypeTree - def copy(original: Tree)(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/): LambdaTypeTree - def unapply(tree: LambdaTypeTree): (List[TypeDef], Tree /*TypeTree | TypeBoundsTree*/) - } - - given LambdaTypeTreeMethods: LambdaTypeTreeMethods - - trait LambdaTypeTreeMethods: - extension (self: LambdaTypeTree) - def tparams: List[TypeDef] - def body: Tree /*TypeTree | TypeBoundsTree*/ - end extension - end LambdaTypeTreeMethods - - type TypeBind <: TypeTree - - given TypeBindTypeTest: TypeTest[Tree, TypeBind] - - val TypeBind: TypeBindModule - - trait TypeBindModule { this: TypeBind.type => - def copy(original: Tree)(name: String, tpt: Tree /*TypeTree | TypeBoundsTree*/): TypeBind - def unapply(x: TypeBind): (String, Tree /*TypeTree | TypeBoundsTree*/) - } - - given TypeBindMethods: TypeBindMethods - - trait TypeBindMethods: - extension (self: TypeBind) - def name: String - def body: Tree /*TypeTree | TypeBoundsTree*/ - end extension - end TypeBindMethods - - type TypeBlock <: TypeTree - - given TypeBlockTypeTest: TypeTest[Tree, TypeBlock] - - val TypeBlock: TypeBlockModule - - trait TypeBlockModule { this: TypeBlock.type => - def apply(aliases: List[TypeDef], tpt: TypeTree): TypeBlock - def copy(original: Tree)(aliases: List[TypeDef], tpt: TypeTree): TypeBlock - def unapply(x: TypeBlock): (List[TypeDef], TypeTree) - } - - given TypeBlockMethods: TypeBlockMethods - - trait TypeBlockMethods: - extension (self: TypeBlock) - def aliases: List[TypeDef] - def tpt: TypeTree - end extension - end TypeBlockMethods - - type TypeBoundsTree <: Tree /*TypeTree | TypeBoundsTree*/ - - given TypeBoundsTreeTypeTest: TypeTest[Tree, TypeBoundsTree] - - val TypeBoundsTree: TypeBoundsTreeModule - - trait TypeBoundsTreeModule { this: TypeBoundsTree.type => - def apply(low: TypeTree, hi: TypeTree): TypeBoundsTree - def copy(original: Tree)(low: TypeTree, hi: TypeTree): TypeBoundsTree - def unapply(x: TypeBoundsTree): (TypeTree, TypeTree) - } - - given TypeBoundsTreeMethods: TypeBoundsTreeMethods - - trait TypeBoundsTreeMethods: - extension (self: TypeBoundsTree) - def tpe: TypeBounds - def low: TypeTree - def hi: TypeTree - end extension - end TypeBoundsTreeMethods - - type WildcardTypeTree <: Tree - - given WildcardTypeTreeTypeTest: TypeTest[Tree, WildcardTypeTree] - - val WildcardTypeTree: WildcardTypeTreeModule - - trait WildcardTypeTreeModule { this: WildcardTypeTree.type => - def apply(tpe: TypeRepr): WildcardTypeTree - def unapply(x: WildcardTypeTree): true - } - - given WildcardTypeTreeMethods: WildcardTypeTreeMethods - - trait WildcardTypeTreeMethods: - extension (self: WildcardTypeTree) - def tpe: TypeRepr - end extension - end WildcardTypeTreeMethods - - type CaseDef <: Tree - - given CaseDefTypeTest: TypeTest[Tree, CaseDef] - - val CaseDef: CaseDefModule - - trait CaseDefModule { this: CaseDef.type => - def apply(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef - def copy(original: Tree)(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef - def unapply(x: CaseDef): (Tree, Option[Term], Term) - } - - given CaseDefMethods: CaseDefMethods - - trait CaseDefMethods: - extension (self: CaseDef) - def pattern: Tree - def guard: Option[Term] - def rhs: Term - end extension - end CaseDefMethods - - type TypeCaseDef <: Tree - - given TypeCaseDefTypeTest: TypeTest[Tree, TypeCaseDef] - - val TypeCaseDef: TypeCaseDefModule - - trait TypeCaseDefModule { this: TypeCaseDef.type => - def apply(pattern: TypeTree, rhs: TypeTree): TypeCaseDef - def copy(original: Tree)(pattern: TypeTree, rhs: TypeTree): TypeCaseDef - def unapply(tree: TypeCaseDef): (TypeTree, TypeTree) - } - - given TypeCaseDefMethods: TypeCaseDefMethods - - trait TypeCaseDefMethods: - extension (self: TypeCaseDef) - def pattern: TypeTree - def rhs: TypeTree - end extension - end TypeCaseDefMethods - - type Bind <: Tree - - given BindTypeTest: TypeTest[Tree, Bind] - - val Bind: BindModule - - trait BindModule { this: Bind.type => - def apply(sym: Symbol, pattern: Tree): Bind - def copy(original: Tree)(name: String, pattern: Tree): Bind - def unapply(pattern: Bind): (String, Tree) - } - - given BindMethods: BindMethods - - trait BindMethods: - extension (self: Bind) - def name: String - def pattern: Tree - end extension - end BindMethods - - type Unapply <: Tree - - given UnapplyTypeTest: TypeTest[Tree, Unapply] - - val Unapply: UnapplyModule - - trait UnapplyModule { this: Unapply.type => - def copy(original: Tree)(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply - def unapply(x: Unapply): (Term, List[Term], List[Tree]) - } - - given UnapplyMethods: UnapplyMethods - - trait UnapplyMethods: - extension (self: Unapply) - def fun: Term - def implicits: List[Term] - def patterns: List[Tree] - end extension - end UnapplyMethods - - type Alternatives <: Tree - - given AlternativesTypeTest: TypeTest[Tree, Alternatives] - - val Alternatives: AlternativesModule - - trait AlternativesModule { this: Alternatives.type => - def apply(patterns: List[Tree]): Alternatives - def copy(original: Tree)(patterns: List[Tree]): Alternatives - def unapply(x: Alternatives): Some[List[Tree]] - } - - given AlternativesMethods: AlternativesMethods - - trait AlternativesMethods: - extension (self: Alternatives) - def patterns: List[Tree] - end extension - end AlternativesMethods - - type ParamClause <: AnyRef - - given ParamClauseMethods: ParamClauseMethods = ??? - - trait ParamClauseMethods: - extension (self: ParamClause) - def params: List[ValDef] | List[TypeDef] - end ParamClauseMethods - - type TermParamClause <: ParamClause - - given TermParamClauseTypeTest: TypeTest[ParamClause, TermParamClause] = ??? - - val TermParamClause: TermParamClauseModule = ??? - - trait TermParamClauseModule { this: TermParamClause.type => - def apply(params: List[ValDef]): TermParamClause - def unapply(x: TermParamClause): Some[List[ValDef]] - } - - type TypeParamClause <: AnyRef - - given TypeParamClauseTypeTest: TypeTest[ParamClause, TypeParamClause] = ??? - - val TypeParamClause: TypeParamClauseModule = ??? - - trait TypeParamClauseModule { this: TypeParamClause.type => - def apply(params: List[TypeDef]): TypeParamClause - def unapply(x: TypeParamClause): Some[List[TypeDef]] - } - - type Selector <: AnyRef - - val Selector: SelectorModule - - trait SelectorModule { this: Selector.type => } - - type SimpleSelector <: Selector - - given SimpleSelectorTypeTest: TypeTest[Selector, SimpleSelector] - - val SimpleSelector: SimpleSelectorModule - - trait SimpleSelectorModule { this: SimpleSelector.type => - def unapply(x: SimpleSelector): Some[String] - } - - given SimpleSelectorMethods: SimpleSelectorMethods - - trait SimpleSelectorMethods: - extension (self: SimpleSelector) - def name: String - def namePos: Position - end extension - end SimpleSelectorMethods - - type RenameSelector <: Selector - - given RenameSelectorTypeTest: TypeTest[Selector, RenameSelector] - - val RenameSelector: RenameSelectorModule - - trait RenameSelectorModule { this: RenameSelector.type => - def unapply(x: RenameSelector): (String, String) - } - - given RenameSelectorMethods: RenameSelectorMethods - - trait RenameSelectorMethods: - extension (self: RenameSelector) - def fromName: String - def fromPos: Position - def toName: String - def toPos: Position - end extension - end RenameSelectorMethods - - type OmitSelector <: Selector - - given OmitSelectorTypeTest: TypeTest[Selector, OmitSelector] - - val OmitSelector: OmitSelectorModule - - trait OmitSelectorModule { this: OmitSelector.type => - def unapply(x: OmitSelector): Some[String] - } - - given OmitSelectorMethods: OmitSelectorMethods - - trait OmitSelectorMethods: - extension (self: OmitSelector) - def name: String - def namePos: Position - end OmitSelectorMethods - - type GivenSelector <: Selector - - given GivenSelectorTypeTest: TypeTest[Selector, GivenSelector] - - val GivenSelector: GivenSelectorModule - - trait GivenSelectorModule { this: GivenSelector.type => - def unapply(x: GivenSelector): Some[Option[TypeTree]] - } - - given GivenSelectorMethods: GivenSelectorMethods - - trait GivenSelectorMethods: - extension (self: GivenSelector) - def bound: Option[TypeTree] - end GivenSelectorMethods - - type TypeRepr - - val TypeRepr: TypeReprModule - - trait TypeReprModule { this: TypeRepr.type => - def of[T <: AnyKind](using Type[T]): TypeRepr - - def typeConstructorOf(clazz: Class[?]): TypeRepr - } - - given TypeReprMethods: TypeReprMethods - - trait TypeReprMethods { - extension (self: TypeRepr) - - def show(using Printer[TypeRepr]): String - - def asType: Type[?] - - def =:=(that: TypeRepr): Boolean - - def <:<(that: TypeRepr): Boolean - - def widen: TypeRepr - - def widenTermRefExpr: TypeRepr - def widenTermRefByName: TypeRepr = widenTermRefExpr - - def dealias: TypeRepr - - def simplified: TypeRepr - - def classSymbol: Option[Symbol] - def typeSymbol: Symbol - def termSymbol: Symbol - def isSingleton: Boolean - def memberType(member: Symbol): TypeRepr - - def baseClasses: List[Symbol] - - def baseType(cls: Symbol): TypeRepr - - def derivesFrom(cls: Symbol): Boolean - - def isFunctionType: Boolean - - def isContextFunctionType: Boolean - - def isErasedFunctionType: Boolean - - def isDependentFunctionType: Boolean - - def select(sym: Symbol): TypeRepr - - def appliedTo(targ: TypeRepr): TypeRepr - - def appliedTo(targs: List[TypeRepr]): TypeRepr - - end extension - } - - type ConstantType <: TypeRepr - - given ConstantTypeTypeTest: TypeTest[TypeRepr, ConstantType] - - val ConstantType: ConstantTypeModule - - trait ConstantTypeModule { this: ConstantType.type => - def apply(x : Constant): ConstantType - def unapply(x: ConstantType): Some[Constant] - } - - given ConstantTypeMethods: ConstantTypeMethods - - trait ConstantTypeMethods: - extension (self: ConstantType) - def constant: Constant - end extension - end ConstantTypeMethods - - type NamedType <: TypeRepr - - given NamedTypeTypeTest: TypeTest[TypeRepr, NamedType] - - given NamedTypeMethods: NamedTypeMethods - - trait NamedTypeMethods: - extension (self: NamedType) - def qualifier: TypeRepr - def name: String - end extension - end NamedTypeMethods - - type TermRef <: NamedType - - given TermRefTypeTest: TypeTest[TypeRepr, TermRef] - - val TermRef: TermRefModule - - trait TermRefModule { this: TermRef.type => - def apply(qual: TypeRepr, name: String): TermRef - def unapply(x: TermRef): (TypeRepr, String) - } - - type TypeRef <: NamedType - - given TypeRefTypeTest: TypeTest[TypeRepr, TypeRef] - - val TypeRef: TypeRefModule - - trait TypeRefModule { this: TypeRef.type => - def unapply(x: TypeRef): (TypeRepr, String) - } - - given TypeRefMethods: TypeRefMethods - - trait TypeRefMethods: - extension (self: TypeRef) - def isOpaqueAlias: Boolean - def translucentSuperType: TypeRepr - end extension - end TypeRefMethods - - type SuperType <: TypeRepr - - given SuperTypeTypeTest: TypeTest[TypeRepr, SuperType] - - val SuperType: SuperTypeModule - - trait SuperTypeModule { this: SuperType.type => - def apply(thistpe: TypeRepr, supertpe: TypeRepr): SuperType - def unapply(x: SuperType): (TypeRepr, TypeRepr) - } - - given SuperTypeMethods: SuperTypeMethods - - trait SuperTypeMethods { this: SuperTypeMethods => - extension (self: SuperType) - def thistpe: TypeRepr - def supertpe: TypeRepr - end extension - } - - type Refinement <: TypeRepr - - given RefinementTypeTest: TypeTest[TypeRepr, Refinement] - - val Refinement: RefinementModule - - trait RefinementModule { this: Refinement.type => - def apply(parent: TypeRepr, name: String, info: TypeRepr): Refinement - def unapply(x: Refinement): (TypeRepr, String, TypeRepr) - } - - given RefinementMethods: RefinementMethods - - trait RefinementMethods: - extension (self: Refinement) - def parent: TypeRepr - def name: String - def info: TypeRepr - end extension - end RefinementMethods - - type AppliedType <: TypeRepr - - given AppliedTypeTypeTest: TypeTest[TypeRepr, AppliedType] - - val AppliedType: AppliedTypeModule - - trait AppliedTypeModule { this: AppliedType.type => - def unapply(x: AppliedType): (TypeRepr, List[TypeRepr]) - } - - given AppliedTypeMethods: AppliedTypeMethods - - trait AppliedTypeMethods: - extension (self: AppliedType) - def tycon: TypeRepr - def args: List[TypeRepr] - end extension - end AppliedTypeMethods - - type AnnotatedType <: TypeRepr - - given AnnotatedTypeTypeTest: TypeTest[TypeRepr, AnnotatedType] - - val AnnotatedType: AnnotatedTypeModule - - trait AnnotatedTypeModule { this: AnnotatedType.type => - def apply(underlying: TypeRepr, annot: Term): AnnotatedType - def unapply(x: AnnotatedType): (TypeRepr, Term) - } - - given AnnotatedTypeMethods: AnnotatedTypeMethods - - trait AnnotatedTypeMethods: - extension (self: AnnotatedType) - def underlying: TypeRepr - def annotation: Term - end extension - end AnnotatedTypeMethods - - type AndOrType <: TypeRepr - - given AndOrTypeTypeTest: TypeTest[TypeRepr, AndOrType] - - given AndOrTypeMethods: AndOrTypeMethods - - trait AndOrTypeMethods: - extension (self: AndOrType) - def left: TypeRepr - def right: TypeRepr - end extension - end AndOrTypeMethods - - type AndType <: AndOrType - - given AndTypeTypeTest: TypeTest[TypeRepr, AndType] - - val AndType: AndTypeModule - - trait AndTypeModule { this: AndType.type => - def apply(lhs: TypeRepr, rhs: TypeRepr): AndType - def unapply(x: AndType): (TypeRepr, TypeRepr) - } - - type OrType <: AndOrType - - given OrTypeTypeTest: TypeTest[TypeRepr, OrType] - - val OrType: OrTypeModule - - trait OrTypeModule { this: OrType.type => - def apply(lhs: TypeRepr, rhs: TypeRepr): OrType - def unapply(x: OrType): (TypeRepr, TypeRepr) - } - - type MatchType <: TypeRepr - - given MatchTypeTypeTest: TypeTest[TypeRepr, MatchType] - - val MatchType: MatchTypeModule - - trait MatchTypeModule { this: MatchType.type => - def apply(bound: TypeRepr, scrutinee: TypeRepr, cases: List[TypeRepr]): MatchType - def unapply(x: MatchType): (TypeRepr, TypeRepr, List[TypeRepr]) - } - - given MatchTypeMethods: MatchTypeMethods - - trait MatchTypeMethods: - extension (self: MatchType) - def bound: TypeRepr - def scrutinee: TypeRepr - def cases: List[TypeRepr] - end extension - end MatchTypeMethods - - type ByNameType <: TypeRepr - - given ByNameTypeTypeTest: TypeTest[TypeRepr, ByNameType] - - val ByNameType: ByNameTypeModule - - trait ByNameTypeModule { this: ByNameType.type => - def apply(underlying: TypeRepr): TypeRepr - def unapply(x: ByNameType): Some[TypeRepr] - } - - given ByNameTypeMethods: ByNameTypeMethods - - trait ByNameTypeMethods: - extension (self: ByNameType) - def underlying: TypeRepr - end extension - end ByNameTypeMethods - - type ParamRef <: TypeRepr - - given ParamRefTypeTest: TypeTest[TypeRepr, ParamRef] - - val ParamRef: ParamRefModule - - trait ParamRefModule { this: ParamRef.type => - def unapply(x: ParamRef): (TypeRepr, Int) - } - - given ParamRefMethods: ParamRefMethods - - trait ParamRefMethods: - extension (self: ParamRef) - def binder: TypeRepr - def paramNum: Int - end extension - end ParamRefMethods - - type ThisType <: TypeRepr - - given ThisTypeTypeTest: TypeTest[TypeRepr, ThisType] - - val ThisType: ThisTypeModule - - trait ThisTypeModule { this: ThisType.type => - def unapply(x: ThisType): Some[TypeRepr] - } - - given ThisTypeMethods: ThisTypeMethods - - trait ThisTypeMethods: - extension (self: ThisType) - def tref: TypeRepr - end extension - end ThisTypeMethods - - type RecursiveThis <: TypeRepr - - given RecursiveThisTypeTest: TypeTest[TypeRepr, RecursiveThis] - - val RecursiveThis: RecursiveThisModule - - trait RecursiveThisModule { this: RecursiveThis.type => - def unapply(x: RecursiveThis): Some[RecursiveType] - } - - given RecursiveThisMethods: RecursiveThisMethods - - trait RecursiveThisMethods: - extension (self: RecursiveThis) - def binder: RecursiveType - end extension - end RecursiveThisMethods - - type RecursiveType <: TypeRepr - - given RecursiveTypeTypeTest: TypeTest[TypeRepr, RecursiveType] - - val RecursiveType: RecursiveTypeModule - - trait RecursiveTypeModule { this: RecursiveType.type => - - def apply(parentExp: RecursiveType => TypeRepr): RecursiveType - - def unapply(x: RecursiveType): Some[TypeRepr] - } - - given RecursiveTypeMethods: RecursiveTypeMethods - - trait RecursiveTypeMethods: - extension (self: RecursiveType) - def underlying: TypeRepr - def recThis: RecursiveThis - end extension - end RecursiveTypeMethods - - type LambdaType <: TypeRepr - - given LambdaTypeTypeTest: TypeTest[TypeRepr, LambdaType] - - given LambdaTypeMethods: LambdaTypeMethods - - trait LambdaTypeMethods: - extension (self: LambdaType) - def paramNames: List[String] - def paramTypes: List[TypeRepr] - def resType: TypeRepr - end extension - end LambdaTypeMethods - - type MethodOrPoly <: LambdaType - - given MethodOrPolyTypeTest: TypeTest[TypeRepr, MethodOrPoly] - - type MethodType <: MethodOrPoly - - given MethodTypeTypeTest: TypeTest[TypeRepr, MethodType] - - val MethodType: MethodTypeModule - - trait MethodTypeModule { this: MethodType.type => - def apply(paramNames: List[String])(paramInfosExp: MethodType => List[TypeRepr], resultTypeExp: MethodType => TypeRepr): MethodType - def unapply(x: MethodType): (List[String], List[TypeRepr], TypeRepr) - } - - given MethodTypeMethods: MethodTypeMethods - - trait MethodTypeMethods: - extension (self: MethodType) - def isImplicit: Boolean - def isErased: Boolean - def param(idx: Int): TypeRepr - end extension - end MethodTypeMethods - - type PolyType <: MethodOrPoly - - given PolyTypeTypeTest: TypeTest[TypeRepr, PolyType] - - val PolyType: PolyTypeModule - - trait PolyTypeModule { this: PolyType.type => - def apply(paramNames: List[String])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => TypeRepr): PolyType - def unapply(x: PolyType): (List[String], List[TypeBounds], TypeRepr) - } - - given PolyTypeMethods: PolyTypeMethods - - trait PolyTypeMethods: - extension (self: PolyType) - def param(idx: Int): TypeRepr - def paramBounds: List[TypeBounds] - end extension - end PolyTypeMethods - - type TypeLambda <: LambdaType - - given TypeLambdaTypeTest: TypeTest[TypeRepr, TypeLambda] - - val TypeLambda: TypeLambdaModule - - trait TypeLambdaModule { this: TypeLambda.type => - def apply(paramNames: List[String], boundsFn: TypeLambda => List[TypeBounds], bodyFn: TypeLambda => TypeRepr): TypeLambda - def unapply(x: TypeLambda): (List[String], List[TypeBounds], TypeRepr) - } - - given TypeLambdaMethods: TypeLambdaMethods - - trait TypeLambdaMethods: - extension (self: TypeLambda) - def param(idx: Int) : TypeRepr - def paramBounds: List[TypeBounds] - end extension - end TypeLambdaMethods - - type MatchCase <: TypeRepr - - given MatchCaseTypeTest: TypeTest[TypeRepr, MatchCase] - - val MatchCase: MatchCaseModule - - trait MatchCaseModule { this: MatchCase.type => - def apply(pattern: TypeRepr, rhs: TypeRepr): MatchCase - def unapply(x: MatchCase): (TypeRepr, TypeRepr) - } - - given MatchCaseMethods: MatchCaseMethods - - trait MatchCaseMethods: - extension (self: MatchCase) - def pattern: TypeRepr - def rhs: TypeRepr - end extension - end MatchCaseMethods - - type TypeBounds <: TypeRepr - - given TypeBoundsTypeTest: TypeTest[TypeRepr, TypeBounds] - - val TypeBounds: TypeBoundsModule - - trait TypeBoundsModule { this: TypeBounds.type => - def apply(low: TypeRepr, hi: TypeRepr): TypeBounds - def unapply(x: TypeBounds): (TypeRepr, TypeRepr) - def empty: TypeBounds - def upper(hi: TypeRepr): TypeBounds - def lower(lo: TypeRepr): TypeBounds - } - - given TypeBoundsMethods: TypeBoundsMethods - - trait TypeBoundsMethods: - extension (self: TypeBounds) - def low: TypeRepr - def hi: TypeRepr - end extension - end TypeBoundsMethods - - type NoPrefix <: TypeRepr - - given NoPrefixTypeTest: TypeTest[TypeRepr, NoPrefix] - - val NoPrefix: NoPrefixModule - - trait NoPrefixModule { this: NoPrefix.type => - def unapply(x: NoPrefix): true - } - - type Constant <: AnyRef - - val Constant: ConstantModule - - trait ConstantModule { this: Constant.type => } - - given ConstantMethods: ConstantMethods - - trait ConstantMethods { - extension (self: Constant) - def value: Any - - def show(using Printer[Constant]): String - - end extension - } - - type BooleanConstant <: Constant - - given BooleanConstantTypeTest: TypeTest[Constant, BooleanConstant] - - val BooleanConstant: BooleanConstantModule - - trait BooleanConstantModule { this: BooleanConstant.type => - def apply(x: Boolean): BooleanConstant - def unapply(constant: BooleanConstant): Some[Boolean] - } - - type ByteConstant <: Constant - - given ByteConstantTypeTest: TypeTest[Constant, ByteConstant] - - val ByteConstant: ByteConstantModule - - trait ByteConstantModule { this: ByteConstant.type => - def apply(x: Byte): ByteConstant - def unapply(constant: ByteConstant): Some[Byte] - } - - type ShortConstant <: Constant - - given ShortConstantTypeTest: TypeTest[Constant, ShortConstant] - - val ShortConstant: ShortConstantModule - - trait ShortConstantModule { this: ShortConstant.type => - def apply(x: Short): ShortConstant - def unapply(constant: ShortConstant): Some[Short] - } - - type IntConstant <: Constant - - given IntConstantTypeTest: TypeTest[Constant, IntConstant] - - val IntConstant: IntConstantModule - - trait IntConstantModule { this: IntConstant.type => - def apply(x: Int): IntConstant - def unapply(constant: IntConstant): Some[Int] - } - - type LongConstant <: Constant - - given LongConstantTypeTest: TypeTest[Constant, LongConstant] - - val LongConstant: LongConstantModule - - trait LongConstantModule { this: LongConstant.type => - def apply(x: Long): LongConstant - def unapply(constant: LongConstant): Some[Long] - } - - type FloatConstant <: Constant - - given FloatConstantTypeTest: TypeTest[Constant, FloatConstant] - - val FloatConstant: FloatConstantModule - - trait FloatConstantModule { this: FloatConstant.type => - def apply(x: Float): FloatConstant - def unapply(constant: FloatConstant): Some[Float] - } - - type DoubleConstant <: Constant - - given DoubleConstantTypeTest: TypeTest[Constant, DoubleConstant] - - val DoubleConstant: DoubleConstantModule - - trait DoubleConstantModule { this: DoubleConstant.type => - def apply(x: Double): DoubleConstant - def unapply(constant: DoubleConstant): Some[Double] - } - - type CharConstant <: Constant - - given CharConstantTypeTest: TypeTest[Constant, CharConstant] - - val CharConstant: CharConstantModule - - trait CharConstantModule { this: CharConstant.type => - def apply(x: Char): CharConstant - def unapply(constant: CharConstant): Some[Char] - } - - type StringConstant <: Constant - - given StringConstantTypeTest: TypeTest[Constant, StringConstant] - - val StringConstant: StringConstantModule - - trait StringConstantModule { this: StringConstant.type => - def apply(x: String): StringConstant - def unapply(constant: StringConstant): Some[String] - } - - type UnitConstant <: Constant - - given UnitConstantTypeTest: TypeTest[Constant, UnitConstant] - - val UnitConstant: UnitConstantModule - - trait UnitConstantModule { this: UnitConstant.type => - def apply(): UnitConstant - def unapply(constant: UnitConstant): true - } - - type NullConstant <: Constant - - given NullConstantTypeTest: TypeTest[Constant, NullConstant] - - val NullConstant: NullConstantModule - - trait NullConstantModule { this: NullConstant.type => - def apply(): NullConstant - def unapply(constant: NullConstant): Boolean - } - - type ClassOfConstant <: Constant - - given ClassOfConstantTypeTest: TypeTest[Constant, ClassOfConstant] - - val ClassOfConstant: ClassOfConstantModule - - trait ClassOfConstantModule { this: ClassOfConstant.type => - def apply(tpe: TypeRepr): ClassOfConstant - def unapply(constant: ClassOfConstant): Option[TypeRepr] - } - - val Implicits: ImplicitsModule - - trait ImplicitsModule { self: Implicits.type => - def search(tpe: TypeRepr): ImplicitSearchResult - } - - type ImplicitSearchResult <: AnyRef - - given ImplicitSearchSuccessTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] - - type ImplicitSearchSuccess <: ImplicitSearchResult - - given ImplicitSearchSuccessMethods: ImplicitSearchSuccessMethods - - trait ImplicitSearchSuccessMethods: - extension (self: ImplicitSearchSuccess) - def tree: Term - end extension - end ImplicitSearchSuccessMethods - - type ImplicitSearchFailure <: ImplicitSearchResult - - given ImplicitSearchFailureTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchFailure] - - given ImplicitSearchFailureMethods: ImplicitSearchFailureMethods - - trait ImplicitSearchFailureMethods: - extension (self: ImplicitSearchFailure) - def explanation: String - end extension - end ImplicitSearchFailureMethods - - type DivergingImplicit <: ImplicitSearchFailure - - given DivergingImplicitTypeTest: TypeTest[ImplicitSearchResult, DivergingImplicit] - - type NoMatchingImplicits <: ImplicitSearchFailure - - given NoMatchingImplicitsTypeTest: TypeTest[ImplicitSearchResult, NoMatchingImplicits] - - type AmbiguousImplicits <: ImplicitSearchFailure - - given AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearchResult, AmbiguousImplicits] - - type Symbol <: AnyRef - - val Symbol: SymbolModule - - trait SymbolModule { this: Symbol.type => - - def spliceOwner: Symbol - - def requiredPackage(path: String): Symbol - - def requiredClass(path: String): Symbol - - def requiredModule(path: String): Symbol - - def requiredMethod(path: String): Symbol - - def classSymbol(fullName: String): Symbol - - def newMethod(parent: Symbol, name: String, tpe: TypeRepr): Symbol - - def newMethod(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol - - def newVal(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol - - def newBind(parent: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol - - def noSymbol: Symbol - } - - given SymbolMethods: SymbolMethods - - trait SymbolMethods { - extension (self: Symbol) - - def owner: Symbol - - def maybeOwner: Symbol - - def flags: Flags - - def privateWithin: Option[TypeRepr] - - def protectedWithin: Option[TypeRepr] - - def name: String - - def fullName: String - - def pos: Option[Position] - - def docstring: Option[String] - - def tree: Tree - - def hasAnnotation(annotSym: Symbol): Boolean - - def getAnnotation(annotSym: Symbol): Option[Term] - - def annotations: List[Term] - - def isDefinedInCurrentRun: Boolean - - def isLocalDummy: Boolean - - def isRefinementClass: Boolean - - def isAliasType: Boolean - - def isAnonymousClass: Boolean - - def isAnonymousFunction: Boolean - - def isAbstractType: Boolean - - def isClassConstructor: Boolean - - def isType: Boolean - - def isTerm: Boolean - - def isPackageDef: Boolean - - def isClassDef: Boolean - - def isTypeDef: Boolean - - def isValDef: Boolean - - def isDefDef: Boolean - - def isBind: Boolean - - def isNoSymbol: Boolean - - def exists: Boolean - - def declaredField(name: String): Symbol - - def declaredFields: List[Symbol] - - def memberField(name: String): Symbol - - def memberFields: List[Symbol] - - def declaredMethod(name: String): List[Symbol] - - def declaredMethods: List[Symbol] - - def memberMethod(name: String): List[Symbol] - - def memberMethods: List[Symbol] - - def declaredType(name: String): List[Symbol] - - def declaredTypes: List[Symbol] - - def memberType(name: String): Symbol - - def memberTypes: List[Symbol] - - def declarations: List[Symbol] - - def paramSymss: List[List[Symbol]] - - def allOverriddenSymbols: Iterator[Symbol] - - def overridingSymbol(ofclazz: Symbol): Symbol - - def primaryConstructor: Symbol - - def caseFields: List[Symbol] - - def isTypeParam: Boolean - - def signature: Signature - - def moduleClass: Symbol - - def companionClass: Symbol - - def companionModule: Symbol - - def children: List[Symbol] - end extension - } - - type Signature <: AnyRef - - val Signature: SignatureModule - - trait SignatureModule { this: Signature.type => - def unapply(sig: Signature): (List[String | Int], String) - } - - given SignatureMethods: SignatureMethods - - trait SignatureMethods { - extension (self: Signature) - - def paramSigs: List[String | Int] - - def resultSig: String - - end extension - } - - val defn: defnModule - - trait defnModule { self: defn.type => - - def RootPackage: Symbol - - def RootClass: Symbol - - def EmptyPackageClass: Symbol - - def ScalaPackage: Symbol - - def ScalaPackageClass: Symbol - - def AnyClass: Symbol - - def MatchableClass: Symbol - - def AnyValClass: Symbol - - def ObjectClass: Symbol - - def AnyRefClass: Symbol - - def NullClass: Symbol - - def NothingClass: Symbol - - def UnitClass: Symbol - - def ByteClass: Symbol - - def ShortClass: Symbol - - def CharClass: Symbol - - def IntClass: Symbol - - def LongClass: Symbol - - def FloatClass: Symbol - - def DoubleClass: Symbol - - def BooleanClass: Symbol - - def StringClass: Symbol - - def ClassClass: Symbol - - def ArrayClass: Symbol - - def PredefModule: Symbol - - def Predef_classOf: Symbol - - def JavaLangPackage: Symbol - - def ArrayModule: Symbol - - def Array_apply: Symbol - - def Array_clone: Symbol - - def Array_length: Symbol - - def Array_update: Symbol - - def RepeatedParamClass: Symbol - - def RepeatedAnnot: Symbol - - def OptionClass: Symbol - - def NoneModule: Symbol - - def SomeModule: Symbol - - def ProductClass: Symbol - - def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol - - def TupleClass(arity: Int): Symbol - - def isTupleClass(sym: Symbol): Boolean - - def ScalaPrimitiveValueClasses: List[Symbol] - - def ScalaNumericValueClasses: List[Symbol] - - } - - type Flags - - val Flags: FlagsModule - - trait FlagsModule { this: Flags.type => - - def Abstract: Flags - - def Artifact: Flags - - def Case: Flags - - def CaseAccessor: Flags - - def Contravariant: Flags - - def Covariant: Flags - - def Deferred: Flags - - def EmptyFlags: Flags - - def Enum: Flags - - def Erased: Flags - - def Exported: Flags - - def ExtensionMethod: Flags - - def FieldAccessor: Flags - - def Final: Flags - - def Given: Flags - - def HasDefault: Flags - - def Implicit: Flags - - def Infix: Flags - - def Inline: Flags - - def JavaDefined: Flags - - def JavaStatic: Flags - - def Lazy: Flags - - def Local: Flags - - def Macro: Flags - - def Method: Flags - - def Module: Flags - - def Mutable: Flags - - def NoInits: Flags - - def Opaque: Flags - - def Open: Flags - - def Override: Flags - - def Package: Flags - - def Param: Flags - - def ParamAccessor: Flags - - def Private: Flags - - def PrivateLocal: Flags - - def Protected: Flags - - def Scala2x: Flags - - def Sealed: Flags - - def StableRealizable: Flags - - def Static: Flags - - def Synthetic: Flags - - def Trait: Flags - - def Transparent: Flags - - } - - given FlagsMethods: FlagsMethods - - trait FlagsMethods { - extension (self: Flags) - def is(that: Flags): Boolean - - def |(that: Flags): Flags - - def &(that: Flags): Flags - - def show: String - - end extension - } - - type Position <: AnyRef - - val Position: PositionModule - - trait PositionModule { this: Position.type => - def ofMacroExpansion: Position - - def apply(sourceFile: SourceFile, start: Int, end: Int): Position - } - - given PositionMethods: PositionMethods - - trait PositionMethods { - extension (self: Position) - - def start: Int - - def end: Int - - def sourceFile: SourceFile - - def startLine: Int - - def endLine: Int - - def startColumn: Int - - def endColumn: Int - - def sourceCode: Option[String] - - end extension - } - - type SourceFile <: AnyRef - - val SourceFile: SourceFileModule - - trait SourceFileModule { this: SourceFile.type => - def current: SourceFile - } - - given SourceFileMethods: SourceFileMethods - - trait SourceFileMethods { - extension (self: SourceFile) - def jpath: java.nio.file.Path - - def content: Option[String] - end extension - } - - val report: reportModule - - trait reportModule { self: report.type => - - def error(msg: String): Unit - - def error(msg: String, expr: Expr[Any]): Unit - - def error(msg: String, pos: Position): Unit - - def throwError(msg: String): Nothing - - def throwError(msg: String, expr: Expr[Any]): Nothing - - def throwError(msg: String, pos: Position): Nothing - - def warning(msg: String): Unit - - def warning(msg: String, expr: Expr[Any]): Unit - - def warning(msg: String, pos: Position): Unit - - } - - trait TreeAccumulator[X]: - - def foldTree(x: X, tree: Tree)(owner: Symbol): X - - def foldTrees(x: X, trees: Iterable[Tree])(owner: Symbol): X = trees.foldLeft(x)((acc, y) => foldTree(acc, y)(owner)) - - def foldOverTree(x: X, tree: Tree)(owner: Symbol): X = { - tree match { - case Ident(_) => - x - case Select(qualifier, _) => - foldTree(x, qualifier)(owner) - case This(qual) => - x - case Super(qual, _) => - foldTree(x, qual)(owner) - case Apply(fun, args) => - foldTrees(foldTree(x, fun)(owner), args)(owner) - case TypeApply(fun, args) => - foldTrees(foldTree(x, fun)(owner), args)(owner) - case Literal(const) => - x - case New(tpt) => - foldTree(x, tpt)(owner) - case Typed(expr, tpt) => - foldTree(foldTree(x, expr)(owner), tpt)(owner) - case NamedArg(_, arg) => - foldTree(x, arg)(owner) - case Assign(lhs, rhs) => - foldTree(foldTree(x, lhs)(owner), rhs)(owner) - case Block(stats, expr) => - foldTree(foldTrees(x, stats)(owner), expr)(owner) - case If(cond, thenp, elsep) => - foldTree(foldTree(foldTree(x, cond)(owner), thenp)(owner), elsep)(owner) - case While(cond, body) => - foldTree(foldTree(x, cond)(owner), body)(owner) - case Closure(meth, tpt) => - foldTree(x, meth)(owner) - case Match(selector, cases) => - foldTrees(foldTree(x, selector)(owner), cases)(owner) - case Return(expr, _) => - foldTree(x, expr)(owner) - case Try(block, handler, finalizer) => - foldTrees(foldTrees(foldTree(x, block)(owner), handler)(owner), finalizer)(owner) - case Repeated(elems, elemtpt) => - foldTrees(foldTree(x, elemtpt)(owner), elems)(owner) - case Inlined(call, bindings, expansion) => - foldTree(foldTrees(x, bindings)(owner), expansion)(owner) - case vdef @ ValDef(_, tpt, rhs) => - val owner = vdef.symbol - foldTrees(foldTree(x, tpt)(owner), rhs)(owner) - case ddef @ DefDef(_, paramss, tpt, rhs) => - val owner = ddef.symbol - // foldTrees(foldTree(vparamss.foldLeft(foldTrees(x, tparams)(owner))((acc, y) => foldTrees(acc, y)(owner)), tpt)(owner), rhs)(owner) - ??? - case tdef @ TypeDef(_, rhs) => - val owner = tdef.symbol - foldTree(x, rhs)(owner) - case cdef @ ClassDef(_, constr, parents, derived, self, body) => - val owner = cdef.symbol - foldTrees(foldTrees(foldTrees(foldTrees(foldTree(x, constr)(owner), parents)(owner), derived)(owner), self)(owner), body)(owner) - case Import(expr, _) => - foldTree(x, expr)(owner) - case Export(expr, _) => - foldTree(x, expr)(owner) - case clause @ PackageClause(pid, stats) => - foldTrees(foldTree(x, pid)(owner), stats)(clause.symbol) - case Inferred() => x - case TypeIdent(_) => x - case TypeSelect(qualifier, _) => foldTree(x, qualifier)(owner) - case TypeProjection(qualifier, _) => foldTree(x, qualifier)(owner) - case Singleton(ref) => foldTree(x, ref)(owner) - case Refined(tpt, refinements) => foldTrees(foldTree(x, tpt)(owner), refinements)(owner) - case Applied(tpt, args) => foldTrees(foldTree(x, tpt)(owner), args)(owner) - case ByName(result) => foldTree(x, result)(owner) - case Annotated(arg, annot) => foldTree(foldTree(x, arg)(owner), annot)(owner) - case LambdaTypeTree(typedefs, arg) => foldTree(foldTrees(x, typedefs)(owner), arg)(owner) - case TypeBind(_, tbt) => foldTree(x, tbt)(owner) - case TypeBlock(typedefs, tpt) => foldTree(foldTrees(x, typedefs)(owner), tpt)(owner) - case MatchTypeTree(boundopt, selector, cases) => - foldTrees(foldTree(boundopt.fold(x)(y => foldTree(x, y)(owner)), selector)(owner), cases)(owner) - case WildcardTypeTree() => x - case TypeBoundsTree(lo, hi) => foldTree(foldTree(x, lo)(owner), hi)(owner) - case CaseDef(pat, guard, body) => foldTree(foldTrees(foldTree(x, pat)(owner), guard)(owner), body)(owner) - case TypeCaseDef(pat, body) => foldTree(foldTree(x, pat)(owner), body)(owner) - case Bind(_, body) => foldTree(x, body)(owner) - case Unapply(fun, implicits, patterns) => foldTrees(foldTrees(foldTree(x, fun)(owner), implicits)(owner), patterns)(owner) - case Alternatives(patterns) => foldTrees(x, patterns)(owner) - } - } - end TreeAccumulator - - trait TreeTraverser extends TreeAccumulator[Unit]: - - def traverseTree(tree: Tree)(owner: Symbol): Unit = traverseTreeChildren(tree)(owner) - - def foldTree(x: Unit, tree: Tree)(owner: Symbol): Unit = traverseTree(tree)(owner) - - protected def traverseTreeChildren(tree: Tree)(owner: Symbol): Unit = foldOverTree((), tree)(owner) - - end TreeTraverser - - trait TreeMap: - - def transformTree(tree: Tree)(owner: Symbol): Tree = { - tree match { - case tree: PackageClause => - PackageClause.copy(tree)(transformTerm(tree.pid).asInstanceOf[Ref], transformTrees(tree.stats)(tree.symbol)) - case tree: Import => - Import.copy(tree)(transformTerm(tree.expr)(owner), tree.selectors) - case tree: Export => - tree - case tree: Statement => - transformStatement(tree)(owner) - case tree: TypeTree => transformTypeTree(tree)(owner) - case tree: TypeBoundsTree => - TypeBoundsTree.copy(tree)(transformTypeTree(tree.low)(owner), transformTypeTree(tree.hi)(owner)) - case tree: WildcardTypeTree => tree - case tree: CaseDef => - transformCaseDef(tree)(owner) - case tree: TypeCaseDef => - transformTypeCaseDef(tree)(owner) - case pattern: Bind => - Bind.copy(pattern)(pattern.name, pattern.pattern) - case pattern: Unapply => - Unapply.copy(pattern)(transformTerm(pattern.fun)(owner), transformSubTrees(pattern.implicits)(owner), transformTrees(pattern.patterns)(owner)) - case pattern: Alternatives => - Alternatives.copy(pattern)(transformTrees(pattern.patterns)(owner)) - } - } - - def transformStatement(tree: Statement)(owner: Symbol): Statement = { - tree match { - case tree: Term => - transformTerm(tree)(owner) - case tree: ValDef => - val owner = tree.symbol - val tpt1 = transformTypeTree(tree.tpt)(owner) - val rhs1 = tree.rhs.map(x => transformTerm(x)(owner)) - ValDef.copy(tree)(tree.name, tpt1, rhs1) - case tree: DefDef => - val owner = tree.symbol - // DefDef.copy(tree)(tree.name, transformSubTrees(tree.typeParams)(owner), tree.paramss mapConserve (x => transformSubTrees(x)(owner)), transformTypeTree(tree.returnTpt)(owner), tree.rhs.map(x => transformTerm(x)(owner))) - ??? - case tree: TypeDef => - val owner = tree.symbol - TypeDef.copy(tree)(tree.name, transformTree(tree.rhs)(owner)) - case tree: ClassDef => - ClassDef.copy(tree)(tree.name, tree.constructor, tree.parents, tree.derived, tree.self, tree.body) - case tree: Import => - Import.copy(tree)(transformTerm(tree.expr)(owner), tree.selectors) - case tree: Export => - tree - } - } - - def transformTerm(tree: Term)(owner: Symbol): Term = { - tree match { - case Ident(name) => - tree - case Select(qualifier, name) => - Select.copy(tree)(transformTerm(qualifier)(owner), name) - case This(qual) => - tree - case Super(qual, mix) => - Super.copy(tree)(transformTerm(qual)(owner), mix) - case Apply(fun, args) => - Apply.copy(tree)(transformTerm(fun)(owner), transformTerms(args)(owner)) - case TypeApply(fun, args) => - TypeApply.copy(tree)(transformTerm(fun)(owner), transformTypeTrees(args)(owner)) - case Literal(const) => - tree - case New(tpt) => - New.copy(tree)(transformTypeTree(tpt)(owner)) - case Typed(expr, tpt) => - Typed.copy(tree)(transformTerm(expr)(owner), transformTypeTree(tpt)(owner)) - case tree: NamedArg => - NamedArg.copy(tree)(tree.name, transformTerm(tree.value)(owner)) - case Assign(lhs, rhs) => - Assign.copy(tree)(transformTerm(lhs)(owner), transformTerm(rhs)(owner)) - case Block(stats, expr) => - Block.copy(tree)(transformStats(stats)(owner), transformTerm(expr)(owner)) - case If(cond, thenp, elsep) => - If.copy(tree)(transformTerm(cond)(owner), transformTerm(thenp)(owner), transformTerm(elsep)(owner)) - case Closure(meth, tpt) => - Closure.copy(tree)(transformTerm(meth)(owner), tpt) - case Match(selector, cases) => - Match.copy(tree)(transformTerm(selector)(owner), transformCaseDefs(cases)(owner)) - case Return(expr, from) => - Return.copy(tree)(transformTerm(expr)(owner), from) - case While(cond, body) => - While.copy(tree)(transformTerm(cond)(owner), transformTerm(body)(owner)) - case Try(block, cases, finalizer) => - Try.copy(tree)(transformTerm(block)(owner), transformCaseDefs(cases)(owner), finalizer.map(x => transformTerm(x)(owner))) - case Repeated(elems, elemtpt) => - Repeated.copy(tree)(transformTerms(elems)(owner), transformTypeTree(elemtpt)(owner)) - case Inlined(call, bindings, expansion) => - Inlined.copy(tree)(call, transformSubTrees(bindings)(owner), transformTerm(expansion)(owner)) - } - } - - def transformTypeTree(tree: TypeTree)(owner: Symbol): TypeTree = tree match { - case Inferred() => tree - case tree: TypeIdent => tree - case tree: TypeSelect => - TypeSelect.copy(tree)(tree.qualifier, tree.name) - case tree: TypeProjection => - TypeProjection.copy(tree)(tree.qualifier, tree.name) - case tree: Annotated => - Annotated.copy(tree)(tree.arg, tree.annotation) - case tree: Singleton => - Singleton.copy(tree)(transformTerm(tree.ref)(owner)) - case tree: Refined => - Refined.copy(tree)(transformTypeTree(tree.tpt)(owner), transformTrees(tree.refinements)(owner).asInstanceOf[List[Definition]]) - case tree: Applied => - Applied.copy(tree)(transformTypeTree(tree.tpt)(owner), transformTrees(tree.args)(owner)) - case tree: MatchTypeTree => - MatchTypeTree.copy(tree)(tree.bound.map(b => transformTypeTree(b)(owner)), transformTypeTree(tree.selector)(owner), transformTypeCaseDefs(tree.cases)(owner)) - case tree: ByName => - ByName.copy(tree)(transformTypeTree(tree.result)(owner)) - case tree: LambdaTypeTree => - LambdaTypeTree.copy(tree)(transformSubTrees(tree.tparams)(owner), transformTree(tree.body)(owner)) - case tree: TypeBind => - TypeBind.copy(tree)(tree.name, tree.body) - case tree: TypeBlock => - TypeBlock.copy(tree)(tree.aliases, tree.tpt) - } - - def transformCaseDef(tree: CaseDef)(owner: Symbol): CaseDef = { - CaseDef.copy(tree)(transformTree(tree.pattern)(owner), tree.guard.map(x => transformTerm(x)(owner)), transformTerm(tree.rhs)(owner)) - } - - def transformTypeCaseDef(tree: TypeCaseDef)(owner: Symbol): TypeCaseDef = { - TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern)(owner), transformTypeTree(tree.rhs)(owner)) - } - - def transformStats(trees: List[Statement])(owner: Symbol): List[Statement] = - trees mapConserve (x => transformStatement(x)(owner)) - - def transformTrees(trees: List[Tree])(owner: Symbol): List[Tree] = - trees mapConserve (x => transformTree(x)(owner)) - - def transformTerms(trees: List[Term])(owner: Symbol): List[Term] = - trees mapConserve (x => transformTerm(x)(owner)) - - def transformTypeTrees(trees: List[TypeTree])(owner: Symbol): List[TypeTree] = - trees mapConserve (x => transformTypeTree(x)(owner)) - - def transformCaseDefs(trees: List[CaseDef])(owner: Symbol): List[CaseDef] = - trees mapConserve (x => transformCaseDef(x)(owner)) - - def transformTypeCaseDefs(trees: List[TypeCaseDef])(owner: Symbol): List[TypeCaseDef] = - trees mapConserve (x => transformTypeCaseDef(x)(owner)) - - def transformSubTrees[Tr <: Tree](trees: List[Tr])(owner: Symbol): List[Tr] = - transformTrees(trees)(owner).asInstanceOf[List[Tr]] - - end TreeMap - - trait Printer[T]: - def show(x: T): String - end Printer - - given TreePrinter: Printer[Tree] = Printer.TreeCode - - given TypeReprPrinter: Printer[TypeRepr] = Printer.TypeReprCode - - given ConstantPrinter: Printer[Constant] = Printer.ConstantCode - - val Printer: PrinterModule - - trait PrinterModule { self: Printer.type => - def TreeCode: Printer[Tree] - - def TreeShortCode: Printer[Tree] - - def TreeAnsiCode: Printer[Tree] - - def TreeStructure: Printer[Tree] - - def TypeReprCode: Printer[TypeRepr] - - def TypeReprShortCode: Printer[TypeRepr] - - def TypeReprAnsiCode: Printer[TypeRepr] - - def TypeReprStructure: Printer[TypeRepr] - - def ConstantCode: Printer[Constant] - - def ConstantStructure: Printer[Constant] - } - - } - - type Nested = Quotes - -} diff --git a/library/src-non-bootstrapped/scala/runtime/Tuple.scala b/library/src-non-bootstrapped/scala/runtime/Tuple.scala deleted file mode 100644 index 387539f77390..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/Tuple.scala +++ /dev/null @@ -1,525 +0,0 @@ -package scala.runtime - -object Tuple { - - inline val MaxSpecialized = 22 - - def toArray(self: Tuple): Array[Object] = (self: Any) match { - case EmptyTuple => Array.emptyObjectArray - case self: TupleXXL => self.toArray - case self: Product => productToArray(self) - } - - def toIArray(self: Tuple): IArray[Object] = (self: Any) match { - case EmptyTuple => Array.emptyObjectArray.asInstanceOf[IArray[Object]] - case self: TupleXXL => self.elems - case self: Product => productToArray(self).asInstanceOf[IArray[Object]] - } - - def productToArray(self: Product): Array[Object] = { - val arr = new Array[Object](self.productArity) - var i = 0 - while (i < arr.length) { - arr(i) = self.productElement(i).asInstanceOf[Object] - i += 1 - } - arr - } - - def fromArray(xs: Array[Object]): Tuple = xs.length match { - case 0 => EmptyTuple - case 1 => Tuple1(xs(0)) - case 2 => Tuple2(xs(0), xs(1)) - case 3 => Tuple3(xs(0), xs(1), xs(2)) - case 4 => Tuple4(xs(0), xs(1), xs(2), xs(3)) - case 5 => Tuple5(xs(0), xs(1), xs(2), xs(3), xs(4)) - case 6 => Tuple6(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5)) - case 7 => Tuple7(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6)) - case 8 => Tuple8(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7)) - case 9 => Tuple9(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8)) - case 10 => Tuple10(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9)) - case 11 => Tuple11(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10)) - case 12 => Tuple12(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11)) - case 13 => Tuple13(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12)) - case 14 => Tuple14(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13)) - case 15 => Tuple15(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14)) - case 16 => Tuple16(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15)) - case 17 => Tuple17(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16)) - case 18 => Tuple18(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17)) - case 19 => Tuple19(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18)) - case 20 => Tuple20(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19)) - case 21 => Tuple21(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20)) - case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)) - case _ => TupleXXL.fromIArray(xs.clone().asInstanceOf[IArray[Object]]).asInstanceOf[Tuple] - } - - def fromIArray(xs: IArray[Object]): Tuple = - if (xs.length <= 22) fromArray(xs.asInstanceOf[Array[Object]]) - else TupleXXL.fromIArray(xs).asInstanceOf[Tuple] - - def fromProduct(xs: Product): Tuple = (xs.productArity match { - case 1 => - xs match { - case xs: Tuple1[_] => xs - case xs => Tuple1(xs.productElement(0)) - } - case 2 => - xs match { - case xs: Tuple2[_, _] => xs - case xs => Tuple2(xs.productElement(0), xs.productElement(1)) - } - case 3 => - xs match { - case xs: Tuple3[_, _, _] => xs - case xs => Tuple3(xs.productElement(0), xs.productElement(1), xs.productElement(2)) - } - case 4 => - xs match { - case xs: Tuple4[_, _, _, _] => xs - case xs => Tuple4(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3)) - } - case 5 => - xs match { - case xs: Tuple5[_, _, _, _, _] => xs - case xs => Tuple5(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4)) - } - case 6 => - xs match { - case xs: Tuple6[_, _, _, _, _, _] => xs - case xs => Tuple6(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5)) - } - case 7 => - xs match { - case xs: Tuple7[_, _, _, _, _, _, _] => xs - case xs => Tuple7(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6)) - } - case 8 => - xs match { - case xs: Tuple8[_, _, _, _, _, _, _, _] => xs - case xs => Tuple8(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7)) - } - case 9 => - xs match { - case xs: Tuple9[_, _, _, _, _, _, _, _, _] => xs - case xs => Tuple9(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8)) - } - case 10 => - xs match { - case xs: Tuple10[_, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple10(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9)) - } - case 11 => - xs match { - case xs: Tuple11[_, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple11(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10)) - } - case 12 => - xs match { - case xs: Tuple12[_, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple12(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11)) - } - case 13 => - xs match { - case xs: Tuple13[_, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple13(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12)) - } - case 14 => - xs match { - case xs: Tuple14[_, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple14(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13)) - } - case 15 => - xs match { - case xs: Tuple15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple15(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14)) - } - case 16 => - xs match { - case xs: Tuple16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple16(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15)) - } - case 17 => - xs match { - case xs: Tuple17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple17(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16)) - } - case 18 => - xs match { - case xs: Tuple18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple18(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16), xs.productElement(17)) - } - case 19 => - xs match { - case xs: Tuple19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple19(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16), xs.productElement(17), xs.productElement(18)) - } - case 20 => - xs match { - case xs: Tuple20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple20(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16), xs.productElement(17), xs.productElement(18), xs.productElement(19)) - } - case 21 => - xs match { - case xs: Tuple21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple21(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16), xs.productElement(17), xs.productElement(18), xs.productElement(19), xs.productElement(20)) - } - case 22 => - xs match { - case xs: Tuple22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => xs - case xs => Tuple22(xs.productElement(0), xs.productElement(1), xs.productElement(2), xs.productElement(3), xs.productElement(4), xs.productElement(5), xs.productElement(6), xs.productElement(7), xs.productElement(8), xs.productElement(9), xs.productElement(10), xs.productElement(11), xs.productElement(12), xs.productElement(13), xs.productElement(14), xs.productElement(15), xs.productElement(16), xs.productElement(17), xs.productElement(18), xs.productElement(19), xs.productElement(20), xs.productElement(21)) - } - case _ => - (xs match { - case xs: TupleXXL => xs - case xs => TupleXXL.fromIArray(xs.productIterator.map(_.asInstanceOf[Object]).toArray.asInstanceOf[IArray[Object]]) // TODO use Iterator.toIArray - }).asInstanceOf[Tuple] - }) - - // Cons for Tuple1 to Tuple22 - private def specialCaseCons(x: Any, self: Tuple): Tuple = { - (self: Any) match { - case EmptyTuple => - Tuple1(x) - case self: Tuple1[_] => - Tuple2(x, self._1) - case self: Tuple2[_, _] => - Tuple3(x, self._1, self._2) - case self: Tuple3[_, _, _] => - Tuple4(x, self._1, self._2, self._3) - case self: Tuple4[_, _, _, _] => - Tuple5(x, self._1, self._2, self._3, self._4) - case self: Tuple5[_, _, _, _, _] => - Tuple6(x, self._1, self._2, self._3, self._4, self._5) - case self: Tuple6[_, _, _, _, _, _] => - Tuple7(x, self._1, self._2, self._3, self._4, self._5, self._6) - case self: Tuple7[_, _, _, _, _, _, _] => - Tuple8(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7) - case self: Tuple8[_, _, _, _, _, _, _, _] => - Tuple9(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8) - case self: Tuple9[_, _, _, _, _, _, _, _, _] => - Tuple10(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9) - case self: Tuple10[_, _, _, _, _, _, _, _, _, _] => - Tuple11(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10) - case self: Tuple11[_, _, _, _, _, _, _, _, _, _, _] => - Tuple12(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11) - case self: Tuple12[_, _, _, _, _, _, _, _, _, _, _, _] => - Tuple13(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12) - case self: Tuple13[_, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple14(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13) - case self: Tuple14[_, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple15(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14) - case self: Tuple15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple16(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15) - case self: Tuple16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple17(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16) - case self: Tuple17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple18(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17) - case self: Tuple18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple19(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18) - case self: Tuple19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple20(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19) - case self: Tuple20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple21(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19, self._20) - case self: Tuple21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple22(x, self._1, self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19, self._20, self._21) - case self: Tuple22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - val arr: Array[Object] = Array( - x.asInstanceOf[Object], self._1.asInstanceOf[Object], self._2.asInstanceOf[Object], - self._3.asInstanceOf[Object], self._4.asInstanceOf[Object], self._5.asInstanceOf[Object], - self._6.asInstanceOf[Object], self._7.asInstanceOf[Object], self._8.asInstanceOf[Object], - self._9.asInstanceOf[Object], self._10.asInstanceOf[Object], self._11.asInstanceOf[Object], - self._12.asInstanceOf[Object], self._13.asInstanceOf[Object], self._14.asInstanceOf[Object], - self._15.asInstanceOf[Object], self._16.asInstanceOf[Object], self._17.asInstanceOf[Object], - self._18.asInstanceOf[Object], self._19.asInstanceOf[Object], self._20.asInstanceOf[Object], - self._21.asInstanceOf[Object], self._22.asInstanceOf[Object], - ) - TupleXXL.fromIArray(arr.asInstanceOf[IArray[Object]]).asInstanceOf[Tuple] - } - } - - // Cons for TupleXXL - private def xxlCons(x: Any, xxl: TupleXXL): TupleXXL = { - val arr = new Array[Object](xxl.productArity + 1) - arr(0) = x.asInstanceOf[Object] - System.arraycopy(xxl.elems, 0, arr, 1, xxl.productArity) - TupleXXL.fromIArray(arr.asInstanceOf[IArray[Object]]) - } - - def cons(x: Any, self: Tuple): Tuple = (self: Any) match { - case xxl: TupleXXL => xxlCons(x, xxl).asInstanceOf[Tuple] - case _ => specialCaseCons(x, self) - } - - def concat[This <: Tuple, That <: Tuple](self: This, that: That): Tuple = { - val selfSize: Int = self.size - // If one of the tuples is empty, we can leave early - if selfSize == 0 then - return that - - val thatSize: Int = that.size - if thatSize == 0 then - return self - - val arr = new Array[Object](selfSize + thatSize) - - // Copies the tuple to an array, at the given offset - inline def copyToArray[T <: Tuple](tuple: T, size: Int, array: Array[Object], offset: Int): Unit = (tuple: Any) match { - case xxl: TupleXXL => - System.arraycopy(xxl.elems, 0, array, offset, size) - case _ => - tuple.productIterator.asInstanceOf[Iterator[Object]] - .copyToArray(array, offset, size) - } - - // In the general case, we copy the two tuples to an array, and convert it back to a tuple - copyToArray(self, selfSize, arr, 0) - copyToArray(that, thatSize, arr, selfSize) - fromIArray(arr.asInstanceOf[IArray[Object]]) - } - - def size(self: Tuple): Int = (self: Any) match { - case EmptyTuple => 0 - case self: Product => self.productArity - } - - // Tail for Tuple1 to Tuple22 - private def specialCaseTail(self: Tuple): Tuple = { - (self: Any) match { - case self: Tuple1[_] => - EmptyTuple - case self: Tuple2[_, _] => - Tuple1(self._2) - case self: Tuple3[_, _, _] => - Tuple2(self._2, self._3) - case self: Tuple4[_, _, _, _] => - Tuple3(self._2, self._3, self._4) - case self: Tuple5[_, _, _, _, _] => - Tuple4(self._2, self._3, self._4, self._5) - case self: Tuple6[_, _, _, _, _, _] => - Tuple5(self._2, self._3, self._4, self._5, self._6) - case self: Tuple7[_, _, _, _, _, _, _] => - Tuple6(self._2, self._3, self._4, self._5, self._6, self._7) - case self: Tuple8[_, _, _, _, _, _, _, _] => - Tuple7(self._2, self._3, self._4, self._5, self._6, self._7, self._8) - case self: Tuple9[_, _, _, _, _, _, _, _, _] => - Tuple8(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9) - case self: Tuple10[_, _, _, _, _, _, _, _, _, _] => - Tuple9(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10) - case self: Tuple11[_, _, _, _, _, _, _, _, _, _, _] => - Tuple10(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11) - case self: Tuple12[_, _, _, _, _, _, _, _, _, _, _, _] => - Tuple11(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12) - case self: Tuple13[_, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple12(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13) - case self: Tuple14[_, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple13(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14) - case self: Tuple15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple14(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15) - case self: Tuple16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple15(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16) - case self: Tuple17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple16(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17) - case self: Tuple18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple17(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18) - case self: Tuple19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple18(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19) - case self: Tuple20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple19(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19, self._20) - case self: Tuple21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple20(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19, self._20, self._21) - case self: Tuple22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] => - Tuple21(self._2, self._3, self._4, self._5, self._6, self._7, self._8, self._9, self._10, self._11, self._12, self._13, self._14, self._15, self._16, self._17, self._18, self._19, self._20, self._21, self._22) - } - } - - // Tail for TupleXXL - private def xxlTail(xxl: TupleXXL): Tuple = { - if (xxl.productArity == 23) { - val elems = xxl.elems - Tuple22( - elems(1), elems(2), elems(3), elems(4), elems(5), elems(6), elems(7), - elems(8), elems(9), elems(10), elems(11), elems(12), elems(13), elems(14), - elems(15), elems(16), elems(17), elems(18), elems(19), elems(20), - elems(21), elems(22) - ) - } else { - val arr = new Array[Object](xxl.elems.length - 1) - System.arraycopy(xxl.elems, 1, arr, 0, xxl.elems.length - 1) - TupleXXL.fromIArray(arr.asInstanceOf[IArray[Object]]).asInstanceOf[Tuple] - } - } - - def tail(self: NonEmptyTuple): Tuple = (self: Any) match { - case xxl: TupleXXL => xxlTail(xxl) - case _ => specialCaseTail(self) - } - - def apply(self: NonEmptyTuple, n: Int): Any = - self.productElement(n) - - // Benchmarks showed that this is faster than doing (it1 zip it2).copyToArray(...) - private def zipIterators(it1: Iterator[Any], it2: Iterator[Any], size: Int): IArray[Object] = { - val arr = new Array[Object](size) - var i = 0 - while (i < size) { - arr(i) = (it1.next(), it2.next()) - i += 1 - } - arr.asInstanceOf[IArray[Object]] - } - - def zip(t1: Tuple, t2: Tuple): Tuple = { - val t1Size: Int = t1.size - val t2Size: Int = t2.size - val size = Math.min(t1Size, t2Size) - if size == 0 then EmptyTuple - else Tuple.fromIArray( - zipIterators( - t1.productIterator, - t2.productIterator, - size - ) - ) - } - - def map[F[_]](self: Tuple, f: [t] => t => F[t]): Tuple = self match { - case EmptyTuple => self - case _ => fromIArray(self.productIterator.map(f(_).asInstanceOf[Object]).toArray.asInstanceOf[IArray[Object]]) // TODO use toIArray - } - - def take(self: Tuple, n: Int): Tuple = { - if (n < 0) throw new IndexOutOfBoundsException(n.toString) - val selfSize: Int = self.size - val actualN = Math.min(n, selfSize) - - if (actualN == 0) EmptyTuple - else { - val arr = (self: Any) match { - case xxl: TupleXXL => - xxl.elems.asInstanceOf[Array[Object]].take(actualN) - case _ => - val arr = new Array[Object](actualN) - self.productIterator.asInstanceOf[Iterator[Object]] - .copyToArray(arr, 0, actualN) - arr - } - - fromIArray(arr.asInstanceOf[IArray[Object]]) - } - } - - def drop(self: Tuple, n: Int): Tuple = { - if (n < 0) throw new IndexOutOfBoundsException(n.toString) - val size = self.size - val actualN = Math.min(n, size) - val rem = size - actualN - - if (rem == 0) EmptyTuple - else { - val arr = (self: Any) match { - case xxl: TupleXXL => - xxl.elems.asInstanceOf[Array[Object]].drop(actualN) - case _ => - val arr = new Array[Object](rem) - self.productIterator.asInstanceOf[Iterator[Object]] - .drop(actualN).copyToArray(arr, 0, rem) - arr - } - - fromIArray(arr.asInstanceOf[IArray[Object]]) - } - } - - def splitAt(self: Tuple, n: Int): (Tuple, Tuple) = { - if (n < 0) throw new IndexOutOfBoundsException(n.toString) - val size = self.size - val actualN = Math.min(n, size) - val (arr1, arr2) = (self: Any) match { - case EmptyTuple => (Array.empty[Object], Array.empty[Object]) - case xxl: TupleXXL => - xxl.elems.asInstanceOf[Array[Object]].splitAt(actualN) - case _ => - val arr1 = new Array[Object](actualN) - val arr2 = new Array[Object](size - actualN) - val it = self.productIterator.asInstanceOf[Iterator[Object]] - it.copyToArray(arr1, 0, actualN) - it.copyToArray(arr2, 0, size - actualN) - (arr1, arr2) - } - - ( - fromIArray(arr1.asInstanceOf[IArray[Object]]), - fromIArray(arr2.asInstanceOf[IArray[Object]]) - ) - } - - def consIterator(head: Any, tail: Tuple): Iterator[Any] = - Iterator.single(head) ++ tail.productIterator - - def concatIterator(tup1: Tuple, tup2: Tuple): Iterator[Any] = - tup1.productIterator ++ tup2.productIterator - - def isInstanceOfTuple(x: Any): Boolean = - x match - case x: Product => - x.productArity match - case 0 => x == EmptyTuple - case 1 => x.isInstanceOf[Tuple1[_]] - case 2 => x.isInstanceOf[Tuple2[_, _]] - case 3 => x.isInstanceOf[Tuple3[_, _, _]] - case 4 => x.isInstanceOf[Tuple4[_, _, _, _]] - case 5 => x.isInstanceOf[Tuple5[_, _, _, _, _]] - case 6 => x.isInstanceOf[Tuple6[_, _, _, _, _, _]] - case 7 => x.isInstanceOf[Tuple7[_, _, _, _, _, _, _]] - case 8 => x.isInstanceOf[Tuple8[_, _, _, _, _, _, _, _]] - case 9 => x.isInstanceOf[Tuple9[_, _, _, _, _, _, _, _, _]] - case 10 => x.isInstanceOf[Tuple10[_, _, _, _, _, _, _, _, _, _]] - case 11 => x.isInstanceOf[Tuple11[_, _, _, _, _, _, _, _, _, _, _]] - case 12 => x.isInstanceOf[Tuple12[_, _, _, _, _, _, _, _, _, _, _, _]] - case 13 => x.isInstanceOf[Tuple13[_, _, _, _, _, _, _, _, _, _, _, _, _]] - case 14 => x.isInstanceOf[Tuple14[_, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 15 => x.isInstanceOf[Tuple15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 16 => x.isInstanceOf[Tuple16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 17 => x.isInstanceOf[Tuple17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 18 => x.isInstanceOf[Tuple18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 19 => x.isInstanceOf[Tuple19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 20 => x.isInstanceOf[Tuple20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 21 => x.isInstanceOf[Tuple21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 22 => x.isInstanceOf[Tuple22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case _ => x.isInstanceOf[TupleXXL] - case _ => - false - - def isInstanceOfEmptyTuple(x: Any): Boolean = x == EmptyTuple - - def isInstanceOfNonEmptyTuple(x: Any): Boolean = - x match - case x: Product => - x.productArity match - case 1 => x.isInstanceOf[Tuple1[_]] - case 2 => x.isInstanceOf[Tuple2[_, _]] - case 3 => x.isInstanceOf[Tuple3[_, _, _]] - case 4 => x.isInstanceOf[Tuple4[_, _, _, _]] - case 5 => x.isInstanceOf[Tuple5[_, _, _, _, _]] - case 6 => x.isInstanceOf[Tuple6[_, _, _, _, _, _]] - case 7 => x.isInstanceOf[Tuple7[_, _, _, _, _, _, _]] - case 8 => x.isInstanceOf[Tuple8[_, _, _, _, _, _, _, _]] - case 9 => x.isInstanceOf[Tuple9[_, _, _, _, _, _, _, _, _]] - case 10 => x.isInstanceOf[Tuple10[_, _, _, _, _, _, _, _, _, _]] - case 11 => x.isInstanceOf[Tuple11[_, _, _, _, _, _, _, _, _, _, _]] - case 12 => x.isInstanceOf[Tuple12[_, _, _, _, _, _, _, _, _, _, _, _]] - case 13 => x.isInstanceOf[Tuple13[_, _, _, _, _, _, _, _, _, _, _, _, _]] - case 14 => x.isInstanceOf[Tuple14[_, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 15 => x.isInstanceOf[Tuple15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 16 => x.isInstanceOf[Tuple16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 17 => x.isInstanceOf[Tuple17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 18 => x.isInstanceOf[Tuple18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 19 => x.isInstanceOf[Tuple19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 20 => x.isInstanceOf[Tuple20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 21 => x.isInstanceOf[Tuple21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case 22 => x.isInstanceOf[Tuple22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]] - case _ => x.isInstanceOf[TupleXXL] - case _ => - false - -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcB$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcB$sp.java deleted file mode 100644 index 195c0995b261..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcB$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcB$sp extends JFunction0 { - abstract byte apply$mcB$sp(); - - default Object apply() { return (Byte) apply$mcB$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcC$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcC$sp.java deleted file mode 100644 index 707236792482..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcC$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcC$sp extends JFunction0 { - abstract char apply$mcC$sp(); - - default Object apply() { return (Character) apply$mcC$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcD$sp.java deleted file mode 100644 index 85ef20b36036..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcD$sp extends JFunction0 { - abstract double apply$mcD$sp(); - - default Object apply() { return (Double) apply$mcD$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcF$sp.java deleted file mode 100644 index e701f930795f..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcF$sp extends JFunction0 { - abstract float apply$mcF$sp(); - - default Object apply() { return (Float) apply$mcF$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcI$sp.java deleted file mode 100644 index d78dd229d9bd..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcI$sp extends JFunction0 { - abstract int apply$mcI$sp(); - - default Object apply() { return (Integer) apply$mcI$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcJ$sp.java deleted file mode 100644 index c71224e9aab7..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcJ$sp extends JFunction0 { - abstract long apply$mcJ$sp(); - - default Object apply() { return (Long) apply$mcJ$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcS$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcS$sp.java deleted file mode 100644 index 6db47964bd87..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcS$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcS$sp extends JFunction0 { - abstract short apply$mcS$sp(); - - default Object apply() { return (Short) apply$mcS$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcV$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcV$sp.java deleted file mode 100644 index d893d50a78b4..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcV$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcV$sp extends JFunction0 { - abstract void apply$mcV$sp(); - - default Object apply() { apply$mcV$sp(); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcZ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcZ$sp.java deleted file mode 100644 index d72dffc491c0..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0$mcZ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0$mcZ$sp extends JFunction0 { - abstract boolean apply$mcZ$sp(); - - default Object apply() { return (Boolean) apply$mcZ$sp(); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction0.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction0.java deleted file mode 100644 index 948cf87e792b..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction0.java +++ /dev/null @@ -1,37 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction0 extends scala.Function0, java.io.Serializable { - default void apply$mcV$sp() { - apply(); - } - default byte apply$mcB$sp() { - return scala.runtime.BoxesRunTime.unboxToByte(apply()); - } - default short apply$mcS$sp() { - return scala.runtime.BoxesRunTime.unboxToShort(apply()); - } - default int apply$mcI$sp() { - return scala.runtime.BoxesRunTime.unboxToInt(apply()); - } - default long apply$mcJ$sp() { - return scala.runtime.BoxesRunTime.unboxToLong(apply()); - } - default char apply$mcC$sp() { - return scala.runtime.BoxesRunTime.unboxToChar(apply()); - } - default float apply$mcF$sp() { - return scala.runtime.BoxesRunTime.unboxToFloat(apply()); - } - default double apply$mcD$sp() { - return scala.runtime.BoxesRunTime.unboxToDouble(apply()); - } - default boolean apply$mcZ$sp() { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply()); - } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDD$sp.java deleted file mode 100644 index b057f42ec137..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcDD$sp extends JFunction1 { - abstract double apply$mcDD$sp(double v1); - - default Object apply(Object t) { return (Double) apply$mcDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDF$sp.java deleted file mode 100644 index 28b906fb8a02..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcDF$sp extends JFunction1 { - abstract double apply$mcDF$sp(float v1); - - default Object apply(Object t) { return (Double) apply$mcDF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDI$sp.java deleted file mode 100644 index 21ad24a3c800..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcDI$sp extends JFunction1 { - abstract double apply$mcDI$sp(int v1); - - default Object apply(Object t) { return (Double) apply$mcDI$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDJ$sp.java deleted file mode 100644 index ea6eaadfa7e7..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcDJ$sp extends JFunction1 { - abstract double apply$mcDJ$sp(long v1); - - default Object apply(Object t) { return (Double) apply$mcDJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFD$sp.java deleted file mode 100644 index 428d42719609..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcFD$sp extends JFunction1 { - abstract float apply$mcFD$sp(double v1); - - default Object apply(Object t) { return (Float) apply$mcFD$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFF$sp.java deleted file mode 100644 index c89c378e8d01..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcFF$sp extends JFunction1 { - abstract float apply$mcFF$sp(float v1); - - default Object apply(Object t) { return (Float) apply$mcFF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFI$sp.java deleted file mode 100644 index 36d632643701..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcFI$sp extends JFunction1 { - abstract float apply$mcFI$sp(int v1); - - default Object apply(Object t) { return (Float) apply$mcFI$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFJ$sp.java deleted file mode 100644 index 2a34039af8d5..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcFJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcFJ$sp extends JFunction1 { - abstract float apply$mcFJ$sp(long v1); - - default Object apply(Object t) { return (Float) apply$mcFJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcID$sp.java deleted file mode 100644 index 2c1e0e812d9d..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcID$sp extends JFunction1 { - abstract int apply$mcID$sp(double v1); - - default Object apply(Object t) { return (Integer) apply$mcID$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIF$sp.java deleted file mode 100644 index df88d4d98b65..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcIF$sp extends JFunction1 { - abstract int apply$mcIF$sp(float v1); - - default Object apply(Object t) { return (Integer) apply$mcIF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcII$sp.java deleted file mode 100644 index e059db6474e7..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcII$sp extends JFunction1 { - abstract int apply$mcII$sp(int v1); - - default Object apply(Object t) { return (Integer) apply$mcII$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIJ$sp.java deleted file mode 100644 index b6cb3ffef2bf..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcIJ$sp extends JFunction1 { - abstract int apply$mcIJ$sp(long v1); - - default Object apply(Object t) { return (Integer) apply$mcIJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJD$sp.java deleted file mode 100644 index 3ab5dc39abb7..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcJD$sp extends JFunction1 { - abstract long apply$mcJD$sp(double v1); - - default Object apply(Object t) { return (Long) apply$mcJD$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJF$sp.java deleted file mode 100644 index 9c9f77404fa9..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcJF$sp extends JFunction1 { - abstract long apply$mcJF$sp(float v1); - - default Object apply(Object t) { return (Long) apply$mcJF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJI$sp.java deleted file mode 100644 index 5d605e6c208f..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcJI$sp extends JFunction1 { - abstract long apply$mcJI$sp(int v1); - - default Object apply(Object t) { return (Long) apply$mcJI$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJJ$sp.java deleted file mode 100644 index c54a7ff4209a..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcJJ$sp extends JFunction1 { - abstract long apply$mcJJ$sp(long v1); - - default Object apply(Object t) { return (Long) apply$mcJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVD$sp.java deleted file mode 100644 index 068d66f44e19..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcVD$sp extends JFunction1 { - abstract void apply$mcVD$sp(double v1); - - default Object apply(Object t) { apply$mcVD$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVF$sp.java deleted file mode 100644 index 61693d481ddc..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcVF$sp extends JFunction1 { - abstract void apply$mcVF$sp(float v1); - - default Object apply(Object t) { apply$mcVF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVI$sp.java deleted file mode 100644 index 0f3e8cec2c5a..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcVI$sp extends JFunction1 { - abstract void apply$mcVI$sp(int v1); - - default Object apply(Object t) { apply$mcVI$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVJ$sp.java deleted file mode 100644 index 567f9867aab6..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcVJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcVJ$sp extends JFunction1 { - abstract void apply$mcVJ$sp(long v1); - - default Object apply(Object t) { apply$mcVJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZD$sp.java deleted file mode 100644 index 0efd96e002a7..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcZD$sp extends JFunction1 { - abstract boolean apply$mcZD$sp(double v1); - - default Object apply(Object t) { return (Boolean) apply$mcZD$sp(scala.runtime.BoxesRunTime.unboxToDouble(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZF$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZF$sp.java deleted file mode 100644 index 931d21b7bf97..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZF$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcZF$sp extends JFunction1 { - abstract boolean apply$mcZF$sp(float v1); - - default Object apply(Object t) { return (Boolean) apply$mcZF$sp(scala.runtime.BoxesRunTime.unboxToFloat(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZI$sp.java deleted file mode 100644 index fcbe909c5139..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcZI$sp extends JFunction1 { - abstract boolean apply$mcZI$sp(int v1); - - default Object apply(Object t) { return (Boolean) apply$mcZI$sp(scala.runtime.BoxesRunTime.unboxToInt(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZJ$sp.java deleted file mode 100644 index 64b2d3a920fa..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1$mcZJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1$mcZJ$sp extends JFunction1 { - abstract boolean apply$mcZJ$sp(long v1); - - default Object apply(Object t) { return (Boolean) apply$mcZJ$sp(scala.runtime.BoxesRunTime.unboxToLong(t)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction1.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction1.java deleted file mode 100644 index aaee46b5c9ad..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction1.java +++ /dev/null @@ -1,311 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction1 extends scala.Function1, java.io.Serializable { - - @Override - @SuppressWarnings("unchecked") - default scala.Function1 andThen(scala.Function1 g) { - return x -> g.apply(this.apply(x)); - } - @Override - @SuppressWarnings("unchecked") - default scala.Function1 compose(scala.Function1 g) { - return x -> this.apply(g.apply(x)); - } - @SuppressWarnings("unchecked") - default void apply$mcVI$sp(int v1) { - apply((T1) ((Integer) v1)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZI$sp(int v1) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Integer) v1))); - } - @SuppressWarnings("unchecked") - default int apply$mcII$sp(int v1) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Integer) v1))); - } - @SuppressWarnings("unchecked") - default float apply$mcFI$sp(int v1) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Integer) v1))); - } - @SuppressWarnings("unchecked") - default long apply$mcJI$sp(int v1) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Integer) v1))); - } - @SuppressWarnings("unchecked") - default double apply$mcDI$sp(int v1) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Integer) v1))); - } - @SuppressWarnings("unchecked") - default void apply$mcVJ$sp(long v1) { - apply((T1) ((Long) v1)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZJ$sp(long v1) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Long) v1))); - } - @SuppressWarnings("unchecked") - default int apply$mcIJ$sp(long v1) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Long) v1))); - } - @SuppressWarnings("unchecked") - default float apply$mcFJ$sp(long v1) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Long) v1))); - } - @SuppressWarnings("unchecked") - default long apply$mcJJ$sp(long v1) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Long) v1))); - } - @SuppressWarnings("unchecked") - default double apply$mcDJ$sp(long v1) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Long) v1))); - } - @SuppressWarnings("unchecked") - default void apply$mcVF$sp(float v1) { - apply((T1) ((Float) v1)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZF$sp(float v1) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Float) v1))); - } - @SuppressWarnings("unchecked") - default int apply$mcIF$sp(float v1) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Float) v1))); - } - @SuppressWarnings("unchecked") - default float apply$mcFF$sp(float v1) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Float) v1))); - } - @SuppressWarnings("unchecked") - default long apply$mcJF$sp(float v1) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Float) v1))); - } - @SuppressWarnings("unchecked") - default double apply$mcDF$sp(float v1) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Float) v1))); - } - @SuppressWarnings("unchecked") - default void apply$mcVD$sp(double v1) { - apply((T1) ((Double) v1)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZD$sp(double v1) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Double) v1))); - } - @SuppressWarnings("unchecked") - default int apply$mcID$sp(double v1) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Double) v1))); - } - @SuppressWarnings("unchecked") - default float apply$mcFD$sp(double v1) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Double) v1))); - } - @SuppressWarnings("unchecked") - default long apply$mcJD$sp(double v1) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Double) v1))); - } - @SuppressWarnings("unchecked") - default double apply$mcDD$sp(double v1) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Double) v1))); - } - - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcVI$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcZI$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcII$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcFI$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcJI$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcDI$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcVJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcZJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcIJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcFJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcJJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcDJ$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcVF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcZF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcIF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcFF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcJF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcDF$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcVD$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcZD$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcID$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcFD$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcJD$sp(scala.Function1 g) { - return compose(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 compose$mcDD$sp(scala.Function1 g) { - return compose(g); - } - - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcVI$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcZI$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcII$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcFI$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcJI$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcDI$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcVJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcZJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcIJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcFJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcJJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcDJ$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcVF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcZF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcIF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcFF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcJF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcDF$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcVD$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcZD$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcID$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcFD$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcJD$sp(scala.Function1 g) { - return andThen(g); - } - @SuppressWarnings("unchecked") - default scala.Function1 andThen$mcDD$sp(scala.Function1 g) { - return andThen(g); - } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDD$sp.java deleted file mode 100644 index b2f2f913ca8c..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDDD$sp extends JFunction2 { - abstract double apply$mcDDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDI$sp.java deleted file mode 100644 index 61ecc1183c20..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDDI$sp extends JFunction2 { - abstract double apply$mcDDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDJ$sp.java deleted file mode 100644 index a30aed4145cc..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDDJ$sp extends JFunction2 { - abstract double apply$mcDDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDID$sp.java deleted file mode 100644 index b017624afb63..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDID$sp extends JFunction2 { - abstract double apply$mcDID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDII$sp.java deleted file mode 100644 index 7351e6118713..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDII$sp extends JFunction2 { - abstract double apply$mcDII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDIJ$sp.java deleted file mode 100644 index 9876e6d7e9df..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDIJ$sp extends JFunction2 { - abstract double apply$mcDIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJD$sp.java deleted file mode 100644 index f42d9709677d..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDJD$sp extends JFunction2 { - abstract double apply$mcDJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJI$sp.java deleted file mode 100644 index ad6e17f3e0b9..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDJI$sp extends JFunction2 { - abstract double apply$mcDJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJJ$sp.java deleted file mode 100644 index a7995872e837..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcDJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcDJJ$sp extends JFunction2 { - abstract double apply$mcDJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { return (Double) apply$mcDJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDD$sp.java deleted file mode 100644 index 86031fb47758..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFDD$sp extends JFunction2 { - abstract float apply$mcFDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDI$sp.java deleted file mode 100644 index 84d594eb36fe..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFDI$sp extends JFunction2 { - abstract float apply$mcFDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDJ$sp.java deleted file mode 100644 index 460471d09165..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFDJ$sp extends JFunction2 { - abstract float apply$mcFDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFID$sp.java deleted file mode 100644 index 4f86c35a0f71..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFID$sp extends JFunction2 { - abstract float apply$mcFID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFII$sp.java deleted file mode 100644 index cee67c3b2a46..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFII$sp extends JFunction2 { - abstract float apply$mcFII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFIJ$sp.java deleted file mode 100644 index f01230cdec22..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFIJ$sp extends JFunction2 { - abstract float apply$mcFIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJD$sp.java deleted file mode 100644 index 69e5f38e172f..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFJD$sp extends JFunction2 { - abstract float apply$mcFJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJI$sp.java deleted file mode 100644 index 8e4b1a684e3a..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFJI$sp extends JFunction2 { - abstract float apply$mcFJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJJ$sp.java deleted file mode 100644 index 2848c0c83a5d..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcFJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcFJJ$sp extends JFunction2 { - abstract float apply$mcFJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { return (Float) apply$mcFJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDD$sp.java deleted file mode 100644 index 45b4d31ed0cb..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIDD$sp extends JFunction2 { - abstract int apply$mcIDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDI$sp.java deleted file mode 100644 index ec44caa20ea5..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIDI$sp extends JFunction2 { - abstract int apply$mcIDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDJ$sp.java deleted file mode 100644 index 80eaf12d9239..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIDJ$sp extends JFunction2 { - abstract int apply$mcIDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIID$sp.java deleted file mode 100644 index dbb03eb443d6..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIID$sp extends JFunction2 { - abstract int apply$mcIID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIII$sp.java deleted file mode 100644 index f52452f35cac..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIII$sp extends JFunction2 { - abstract int apply$mcIII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIIJ$sp.java deleted file mode 100644 index 43d4084b2634..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIIJ$sp extends JFunction2 { - abstract int apply$mcIIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJD$sp.java deleted file mode 100644 index 6da251b46bb1..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIJD$sp extends JFunction2 { - abstract int apply$mcIJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJI$sp.java deleted file mode 100644 index da04de58a29e..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIJI$sp extends JFunction2 { - abstract int apply$mcIJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJJ$sp.java deleted file mode 100644 index 8cbdd296e027..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcIJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcIJJ$sp extends JFunction2 { - abstract int apply$mcIJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDD$sp.java deleted file mode 100644 index ed6f9be64f37..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJDD$sp extends JFunction2 { - abstract long apply$mcJDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDI$sp.java deleted file mode 100644 index e61307dbb303..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJDI$sp extends JFunction2 { - abstract long apply$mcJDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDJ$sp.java deleted file mode 100644 index 4815f1985112..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJDJ$sp extends JFunction2 { - abstract long apply$mcJDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJID$sp.java deleted file mode 100644 index 26762d0ef793..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJID$sp extends JFunction2 { - abstract long apply$mcJID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJII$sp.java deleted file mode 100644 index fe434b755eab..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJII$sp extends JFunction2 { - abstract long apply$mcJII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJIJ$sp.java deleted file mode 100644 index 3b3228c9744d..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJIJ$sp extends JFunction2 { - abstract long apply$mcJIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJD$sp.java deleted file mode 100644 index b600c4d54f6b..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJJD$sp extends JFunction2 { - abstract long apply$mcJJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJI$sp.java deleted file mode 100644 index 2f9282858176..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJJI$sp extends JFunction2 { - abstract long apply$mcJJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJJ$sp.java deleted file mode 100644 index 1e5148ed588d..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcJJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcJJJ$sp extends JFunction2 { - abstract long apply$mcJJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { return (Long) apply$mcJJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDD$sp.java deleted file mode 100644 index 73e7606bac63..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVDD$sp extends JFunction2 { - abstract void apply$mcVDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { apply$mcVDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDI$sp.java deleted file mode 100644 index 437c6fa56537..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVDI$sp extends JFunction2 { - abstract void apply$mcVDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { apply$mcVDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDJ$sp.java deleted file mode 100644 index d97cdef504d5..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVDJ$sp extends JFunction2 { - abstract void apply$mcVDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { apply$mcVDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVID$sp.java deleted file mode 100644 index ddbea30ee7eb..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVID$sp extends JFunction2 { - abstract void apply$mcVID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { apply$mcVID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVII$sp.java deleted file mode 100644 index e9ff33368252..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVII$sp extends JFunction2 { - abstract void apply$mcVII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { apply$mcVII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVIJ$sp.java deleted file mode 100644 index 9437f4f93862..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVIJ$sp extends JFunction2 { - abstract void apply$mcVIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { apply$mcVIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJD$sp.java deleted file mode 100644 index 6dfddd2ee072..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVJD$sp extends JFunction2 { - abstract void apply$mcVJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { apply$mcVJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJI$sp.java deleted file mode 100644 index ab8d0775ba8a..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVJI$sp extends JFunction2 { - abstract void apply$mcVJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { apply$mcVJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJJ$sp.java deleted file mode 100644 index 0e9e1eeb1f0c..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcVJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcVJJ$sp extends JFunction2 { - abstract void apply$mcVJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { apply$mcVJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); return scala.runtime.BoxedUnit.UNIT; } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDD$sp.java deleted file mode 100644 index 4577beb4edca..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZDD$sp extends JFunction2 { - abstract boolean apply$mcZDD$sp(double v1, double v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDD$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDI$sp.java deleted file mode 100644 index ebc068181cb1..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZDI$sp extends JFunction2 { - abstract boolean apply$mcZDI$sp(double v1, int v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDI$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDJ$sp.java deleted file mode 100644 index 81bbe3e3f14f..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZDJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZDJ$sp extends JFunction2 { - abstract boolean apply$mcZDJ$sp(double v1, long v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDJ$sp(scala.runtime.BoxesRunTime.unboxToDouble(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZID$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZID$sp.java deleted file mode 100644 index c2d44c04b16e..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZID$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZID$sp extends JFunction2 { - abstract boolean apply$mcZID$sp(int v1, double v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZID$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZII$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZII$sp.java deleted file mode 100644 index 7ab4be7ccc0b..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZII$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZII$sp extends JFunction2 { - abstract boolean apply$mcZII$sp(int v1, int v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZII$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZIJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZIJ$sp.java deleted file mode 100644 index 5ddcf6ae4b94..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZIJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZIJ$sp extends JFunction2 { - abstract boolean apply$mcZIJ$sp(int v1, long v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZIJ$sp(scala.runtime.BoxesRunTime.unboxToInt(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJD$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJD$sp.java deleted file mode 100644 index 57386fdbb215..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJD$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZJD$sp extends JFunction2 { - abstract boolean apply$mcZJD$sp(long v1, double v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJD$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToDouble(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJI$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJI$sp.java deleted file mode 100644 index 57944ab7d485..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJI$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZJI$sp extends JFunction2 { - abstract boolean apply$mcZJI$sp(long v1, int v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJI$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToInt(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJJ$sp.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJJ$sp.java deleted file mode 100644 index 76bfeef5c208..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2$mcZJJ$sp.java +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -@FunctionalInterface -public interface JFunction2$mcZJJ$sp extends JFunction2 { - abstract boolean apply$mcZJJ$sp(long v1, long v2); - - default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJJ$sp(scala.runtime.BoxesRunTime.unboxToLong(v1), scala.runtime.BoxesRunTime.unboxToLong(v2)); } -} diff --git a/library/src-non-bootstrapped/scala/runtime/function/JFunction2.java b/library/src-non-bootstrapped/scala/runtime/function/JFunction2.java deleted file mode 100644 index 013c77a66134..000000000000 --- a/library/src-non-bootstrapped/scala/runtime/function/JFunction2.java +++ /dev/null @@ -1,662 +0,0 @@ - -/* - * Copyright (C) 2012-2014 Typesafe Inc. - */ - -package scala.runtime.function; - -import scala.MatchError; - -@FunctionalInterface -public interface JFunction2 extends scala.Function2, java.io.Serializable { - @SuppressWarnings("unchecked") - default void apply$mcVII$sp(int v1, int v2) { - apply((T1) ((Integer) v1), (T2) ((Integer) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZII$sp(int v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Integer) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIII$sp(int v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Integer) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFII$sp(int v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Integer) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJII$sp(int v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Integer) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDII$sp(int v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Integer) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVIJ$sp(int v1, long v2) { - apply((T1) ((Integer) v1), (T2) ((Long) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZIJ$sp(int v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Integer) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIIJ$sp(int v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Integer) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFIJ$sp(int v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Integer) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJIJ$sp(int v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Integer) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDIJ$sp(int v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Integer) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVID$sp(int v1, double v2) { - apply((T1) ((Integer) v1), (T2) ((Double) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZID$sp(int v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Integer) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIID$sp(int v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Integer) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFID$sp(int v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Integer) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJID$sp(int v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Integer) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDID$sp(int v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Integer) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVJI$sp(long v1, int v2) { - apply((T1) ((Long) v1), (T2) ((Integer) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZJI$sp(long v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Long) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIJI$sp(long v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Long) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFJI$sp(long v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Long) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJJI$sp(long v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Long) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDJI$sp(long v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Long) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVJJ$sp(long v1, long v2) { - apply((T1) ((Long) v1), (T2) ((Long) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZJJ$sp(long v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Long) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIJJ$sp(long v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Long) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFJJ$sp(long v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Long) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJJJ$sp(long v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Long) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDJJ$sp(long v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Long) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVJD$sp(long v1, double v2) { - apply((T1) ((Long) v1), (T2) ((Double) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZJD$sp(long v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Long) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIJD$sp(long v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Long) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFJD$sp(long v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Long) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJJD$sp(long v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Long) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDJD$sp(long v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Long) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVDI$sp(double v1, int v2) { - apply((T1) ((Double) v1), (T2) ((Integer) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZDI$sp(double v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Double) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIDI$sp(double v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Double) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFDI$sp(double v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Double) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJDI$sp(double v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Double) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDDI$sp(double v1, int v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Double) v1), (T2) ((Integer) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVDJ$sp(double v1, long v2) { - apply((T1) ((Double) v1), (T2) ((Long) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZDJ$sp(double v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Double) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIDJ$sp(double v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Double) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFDJ$sp(double v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Double) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJDJ$sp(double v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Double) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDDJ$sp(double v1, long v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Double) v1), (T2) ((Long) v2))); - } - @SuppressWarnings("unchecked") - default void apply$mcVDD$sp(double v1, double v2) { - apply((T1) ((Double) v1), (T2) ((Double) v2)); - } - @SuppressWarnings("unchecked") - default boolean apply$mcZDD$sp(double v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToBoolean(apply((T1) ((Double) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default int apply$mcIDD$sp(double v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToInt(apply((T1) ((Double) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default float apply$mcFDD$sp(double v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToFloat(apply((T1) ((Double) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default long apply$mcJDD$sp(double v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToLong(apply((T1) ((Double) v1), (T2) ((Double) v2))); - } - @SuppressWarnings("unchecked") - default double apply$mcDDD$sp(double v1, double v2) { - return scala.runtime.BoxesRunTime.unboxToDouble(apply((T1) ((Double) v1), (T2) ((Double) v2))); - } - - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDII$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDIJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDID$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDJI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDJJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDJD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDDI$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDDJ$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcVDD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcZDD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcIDD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcFDD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcJDD$sp() { - return curried(); - } - @SuppressWarnings("unchecked") - default scala.Function1 curried$mcDDD$sp() { - return curried(); - } - - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDII$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDIJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDID$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDJI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDJJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDJD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDDI$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDDJ$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcVDD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcZDD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcIDD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcFDD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcJDD$sp() { - return tupled(); - } - @SuppressWarnings("unchecked") - default scala.Function1 tupled$mcDDD$sp() { - return tupled(); - } -} diff --git a/library/src-bootstrapped/scala/IArray.scala b/library/src/scala/IArray.scala similarity index 100% rename from library/src-bootstrapped/scala/IArray.scala rename to library/src/scala/IArray.scala diff --git a/library/src-bootstrapped/scala/Tuple.scala b/library/src/scala/Tuple.scala similarity index 100% rename from library/src-bootstrapped/scala/Tuple.scala rename to library/src/scala/Tuple.scala diff --git a/library/src-bootstrapped/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala similarity index 100% rename from library/src-bootstrapped/scala/quoted/Expr.scala rename to library/src/scala/quoted/Expr.scala diff --git a/library/src-bootstrapped/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala similarity index 100% rename from library/src-bootstrapped/scala/quoted/FromExpr.scala rename to library/src/scala/quoted/FromExpr.scala diff --git a/library/src-bootstrapped/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala similarity index 100% rename from library/src-bootstrapped/scala/quoted/Quotes.scala rename to library/src/scala/quoted/Quotes.scala diff --git a/library/src-bootstrapped/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala similarity index 100% rename from library/src-bootstrapped/scala/quoted/ToExpr.scala rename to library/src/scala/quoted/ToExpr.scala diff --git a/project/Build.scala b/project/Build.scala index 6069d49a490d..686c38bd2381 100644 --- a/project/Build.scala +++ b/project/Build.scala @@ -55,7 +55,7 @@ object MyScalaJSPlugin extends AutoPlugin { } object Build { - val referenceVersion = "3.0.0-M3" + val referenceVersion = "3.0.0-RC1-bin-20210122-6947b0f-NIGHTLY" val baseVersion = "3.0.0-RC1" val baseSbtDottyVersion = "0.5.1"