dotty.tools.backend.sjs.JSExportsGen.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of scala3-compiler_3 Show documentation
Show all versions of scala3-compiler_3 Show documentation
scala3-compiler-bootstrapped
package dotty.tools.backend.sjs
import scala.language.unsafeNulls
import scala.annotation.tailrec
import scala.collection.mutable
import dotty.tools.dotc.core.*
import Contexts.*
import Decorators.*
import Denotations.*
import Flags.*
import Names.*
import NameKinds.DefaultGetterName
import NameOps.*
import Phases.*
import Symbols.*
import Types.*
import TypeErasure.ErasedValueType
import dotty.tools.dotc.util.{SourcePosition, SrcPos}
import dotty.tools.dotc.report
import dotty.tools.sjs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
import dotty.tools.sjs.ir.Names.DefaultModuleID
import dotty.tools.sjs.ir.OriginalName.NoOriginalName
import dotty.tools.sjs.ir.Position.NoPosition
import dotty.tools.sjs.ir.Trees.OptimizerHints
import dotty.tools.sjs.ir.Version.Unversioned
import dotty.tools.dotc.transform.sjs.JSExportUtils.*
import dotty.tools.dotc.transform.sjs.JSSymUtils.*
import JSEncoding.*
final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
import jsCodeGen.*
import positionConversions.*
/** Info for a non-member export. */
sealed trait ExportInfo {
val pos: SourcePosition
}
final case class TopLevelExportInfo(moduleID: String, jsName: String)(val pos: SourcePosition) extends ExportInfo
final case class StaticExportInfo(jsName: String)(val pos: SourcePosition) extends ExportInfo
private sealed trait ExportKind
private object ExportKind {
case object Module extends ExportKind
case object JSClass extends ExportKind
case object Constructor extends ExportKind
case object Method extends ExportKind
case object Property extends ExportKind
case object Field extends ExportKind
def apply(sym: Symbol): ExportKind = {
if (sym.is(Flags.Module) && sym.isStatic) Module
else if (sym.isClass) JSClass
else if (sym.isConstructor) Constructor
else if (!sym.is(Flags.Method)) Field
else if (sym.isJSProperty) Property
else Method
}
}
private def topLevelExportsOf(sym: Symbol): List[TopLevelExportInfo] = {
def isScalaClass(sym: Symbol): Boolean =
sym.isClass && !sym.isOneOf(Module | Trait) && !sym.isJSType
if (isScalaClass(sym)) {
// Scala classes are never exported; their constructors are
Nil
} else if (sym.is(Accessor) || sym.is(Module, butNot = ModuleClass)) {
/* - Accessors receive the `@JSExportTopLevel` annotation of their associated field,
* but only the field is really exported.
* - Module values are not exported; their module class takes care of the export.
*/
Nil
} else {
val symForAnnot =
if (sym.isConstructor && isScalaClass(sym.owner)) sym.owner
else sym
symForAnnot.annotations.collect {
case annot if annot.symbol == jsdefn.JSExportTopLevelAnnot =>
val jsName = annot.argumentConstantString(0).get
val moduleID = annot.argumentConstantString(1).getOrElse(DefaultModuleID)
TopLevelExportInfo(moduleID, jsName)(annot.tree.sourcePos)
}
}
}
private def staticExportsOf(sym: Symbol): List[StaticExportInfo] = {
if (sym.is(Accessor)) {
Nil
} else {
sym.annotations.collect {
case annot if annot.symbol == jsdefn.JSExportStaticAnnot =>
val jsName = annot.argumentConstantString(0).getOrElse {
sym.defaultJSName
}
StaticExportInfo(jsName)(annot.tree.sourcePos)
}
}
}
private def checkSameKind(tups: List[(ExportInfo, Symbol)]): Option[ExportKind] = {
assert(tups.nonEmpty, "must have at least one export")
val firstSym = tups.head._2
val overallKind = ExportKind(firstSym)
var bad = false
for ((info, sym) <- tups.tail) {
val kind = ExportKind(sym)
if (kind != overallKind) {
bad = true
report.error(
em"export overload conflicts with export of $firstSym: they are of different types (${kind.tryToShow} / ${overallKind.tryToShow})",
info.pos)
}
}
if (bad) None
else Some(overallKind)
}
private def checkSingleField(tups: List[(ExportInfo, Symbol)]): Symbol = {
assert(tups.nonEmpty, "must have at least one export")
val firstSym = tups.head._2
for ((info, _) <- tups.tail) {
report.error(
em"export overload conflicts with export of $firstSym: a field may not share its exported name with another export",
info.pos)
}
firstSym
}
def genTopLevelExports(classSym: ClassSymbol): List[js.TopLevelExportDef] = {
val exports = for {
sym <- classSym :: classSym.info.decls.toList
info <- topLevelExportsOf(sym)
} yield {
(info, sym)
}
(for {
(info, tups) <- exports.groupBy(_._1)
kind <- checkSameKind(tups)
} yield {
import ExportKind.*
implicit val pos = info.pos
kind match {
case Module =>
js.TopLevelModuleExportDef(info.moduleID, info.jsName)
case JSClass =>
assert(classSym.isNonNativeJSClass, "found export on non-JS class")
js.TopLevelJSClassExportDef(info.moduleID, info.jsName)
case Constructor | Method =>
val exported = tups.map(_._2)
val methodDef = withNewLocalNameScope {
genExportMethod(exported, JSName.Literal(info.jsName), static = true)
}
js.TopLevelMethodExportDef(info.moduleID, methodDef)
case Property =>
throw new AssertionError("found top-level exported property")
case Field =>
val sym = checkSingleField(tups)
js.TopLevelFieldExportDef(info.moduleID, info.jsName, encodeFieldSym(sym))
}
}).toList
}
def genStaticExports(classSym: Symbol): (List[js.JSFieldDef], List[js.JSMethodPropDef]) = {
val exports = for {
sym <- classSym.info.decls.toList
info <- staticExportsOf(sym)
} yield {
(info, sym)
}
val fields = List.newBuilder[js.JSFieldDef]
val methodProps = List.newBuilder[js.JSMethodPropDef]
for {
(info, tups) <- exports.groupBy(_._1)
kind <- checkSameKind(tups)
} {
def alts = tups.map(_._2)
implicit val pos = info.pos
import ExportKind.*
kind match {
case Method =>
methodProps +=
genMemberExportOrDispatcher(JSName.Literal(info.jsName), isProp = false, alts, static = true)
case Property =>
methodProps +=
genMemberExportOrDispatcher(JSName.Literal(info.jsName), isProp = true, alts, static = true)
case Field =>
val sym = checkSingleField(tups)
// static fields must always be mutable
val flags = js.MemberFlags.empty
.withNamespace(js.MemberNamespace.PublicStatic)
.withMutable(true)
val name = js.StringLiteral(info.jsName)
val irTpe = genExposedFieldIRType(sym)
fields += js.JSFieldDef(flags, name, irTpe)
case kind =>
throw new AssertionError(s"unexpected static export kind: $kind")
}
}
(fields.result(), methodProps.result())
}
/** Generates exported methods and properties for a class.
*
* @param classSym symbol of the class we export for
*/
def genMemberExports(classSym: ClassSymbol): List[js.JSMethodPropDef] = {
val classInfo = classSym.info
val allExports = classInfo.memberDenots(takeAllFilter, { (name, buf) =>
if (isExportName(name))
buf ++= classInfo.member(name).alternatives
})
val newlyDeclaredExports = if (classSym.superClass == NoSymbol) {
allExports
} else {
allExports.filterNot { denot =>
classSym.superClass.info.member(denot.name).hasAltWith(_.info =:= denot.info)
}
}
val newlyDeclaredExportNames = newlyDeclaredExports.map(_.name.toTermName).toList.distinct
newlyDeclaredExportNames.map(genMemberExport(classSym, _))
}
private def genMemberExport(classSym: ClassSymbol, name: TermName): js.JSMethodPropDef = {
/* This used to be `.member(name)`, but it caused #3538, since we were
* sometimes selecting mixin forwarders, whose type history does not go
* far enough back in time to see varargs. We now explicitly exclude
* mixed-in members in addition to bridge methods (the latter are always
* excluded by `.member(name)`).
*/
val alts = classSym
.findMemberNoShadowingBasedOnFlags(name, classSym.appliedRef, required = Method, excluded = Bridge | MixedIn)
.alternatives
assert(!alts.isEmpty,
em"""Ended up with no alternatives for ${classSym.fullName}::$name.
|Original set was ${alts} with types ${alts.map(_.info)}""")
val (jsName, isProp) = exportNameInfo(name)
// Check if we have a conflicting export of the other kind
val conflicting = classSym.info.member(makeExportName(jsName, !isProp))
if (conflicting.exists) {
val kind = if (isProp) "property" else "method"
val conflictingMember = conflicting.alternatives.head.symbol.fullName
val errorPos: SrcPos = alts.map(_.symbol).filter(_.owner == classSym) match {
case Nil => classSym
case altsInClass => altsInClass.minBy(_.span.point)
}
report.error(em"Exported $kind $jsName conflicts with $conflictingMember", errorPos)
}
genMemberExportOrDispatcher(JSName.Literal(jsName), isProp, alts.map(_.symbol), static = false)
}
def genJSClassDispatchers(classSym: Symbol, dispatchMethodsNames: List[JSName]): List[js.JSMethodPropDef] = {
dispatchMethodsNames.map(genJSClassDispatcher(classSym, _))
}
private def genJSClassDispatcher(classSym: Symbol, name: JSName): js.JSMethodPropDef = {
val alts = classSym.info.membersBasedOnFlags(required = Method, excluded = Bridge)
.map(_.symbol)
.filter { sym =>
/* scala-js#3939: Object is not a "real" superclass of JS types.
* as such, its methods do not participate in overload resolution.
* An exception is toString, which is handled specially in genExportMethod.
*/
sym.owner != defn.ObjectClass && sym.jsName == name
}
.toList
assert(!alts.isEmpty, s"Ended up with no alternatives for ${classSym.fullName}::$name.")
val (propSyms, methodSyms) = alts.partition(_.isJSProperty)
val isProp = propSyms.nonEmpty
if (isProp && methodSyms.nonEmpty) {
val firstAlt = alts.head
report.error(
em"Conflicting properties and methods for ${classSym.fullName}::$name.",
firstAlt.srcPos)
implicit val pos = firstAlt.span
js.JSPropertyDef(js.MemberFlags.empty, genExpr(name)(firstAlt.sourcePos), None, None)(Unversioned)
} else {
genMemberExportOrDispatcher(name, isProp, alts, static = false)
}
}
private def genMemberExportOrDispatcher(jsName: JSName, isProp: Boolean,
alts: List[Symbol], static: Boolean): js.JSMethodPropDef = {
withNewLocalNameScope {
if (isProp)
genExportProperty(alts, jsName, static)
else
genExportMethod(alts, jsName, static)
}
}
private def genExportProperty(alts: List[Symbol], jsName: JSName, static: Boolean): js.JSPropertyDef = {
assert(!alts.isEmpty, s"genExportProperty with empty alternatives for $jsName")
implicit val pos: Position = alts.head.span
val namespace =
if (static) js.MemberNamespace.PublicStatic
else js.MemberNamespace.Public
val flags = js.MemberFlags.empty.withNamespace(namespace)
/* Separate getters and setters. Since we only have getters and setters, we
* simply test the param list size, which is faster than using the full isJSGetter.
*/
val (getter, setters) = alts.partition(_.info.paramInfoss.head.isEmpty)
// We can have at most one getter
if (getter.sizeIs > 1)
reportCannotDisambiguateError(jsName, alts)
val getterBody = getter.headOption.map { getterSym =>
genApplyForSingleExported(new FormalArgsRegistry(0, false), new ExportedSymbol(getterSym, static), static)
}
val setterArgAndBody = {
if (setters.isEmpty) {
None
} else {
val formalArgsRegistry = new FormalArgsRegistry(1, false)
val (List(arg), None) = formalArgsRegistry.genFormalArgs(): @unchecked
val body = genOverloadDispatchSameArgc(jsName, formalArgsRegistry,
setters.map(new ExportedSymbol(_, static)), jstpe.AnyType, None)
Some((arg, body))
}
}
js.JSPropertyDef(flags, genExpr(jsName)(alts.head.sourcePos), getterBody, setterArgAndBody)(Unversioned)
}
private def genExportMethod(alts0: List[Symbol], jsName: JSName, static: Boolean)(using Context): js.JSMethodDef = {
assert(alts0.nonEmpty, "need at least one alternative to generate exporter method")
implicit val pos: SourcePosition = alts0.head.sourcePos
val namespace =
if (static) js.MemberNamespace.PublicStatic
else js.MemberNamespace.Public
val flags = js.MemberFlags.empty.withNamespace(namespace)
// toString() is always exported. We might need to add it here to get correct overloading.
val alts = jsName match {
case JSName.Literal("toString") if alts0.forall(_.info.paramInfoss.exists(_.nonEmpty)) =>
defn.Any_toString :: alts0
case _ =>
alts0
}
val overloads = alts.map(new ExportedSymbol(_, static))
val (formalArgs, restParam, body) =
genOverloadDispatch(jsName, overloads, jstpe.AnyType)
js.JSMethodDef(flags, genExpr(jsName), formalArgs, restParam, body)(
OptimizerHints.empty, Unversioned)
}
def genOverloadDispatch(jsName: JSName, alts: List[Exported], tpe: jstpe.Type)(
using pos: SourcePosition): (List[js.ParamDef], Option[js.ParamDef], js.Tree) = {
// Create the formal args registry
val hasVarArg = alts.exists(_.hasRepeatedParam)
val minArgc = alts.map(_.minArgc).min
val maxNonRepeatedArgc = alts.map(_.maxNonRepeatedArgc).max
val needsRestParam = maxNonRepeatedArgc != minArgc || hasVarArg
val formalArgsRegistry = new FormalArgsRegistry(minArgc, needsRestParam)
// Generate the list of formal parameters
val (formalArgs, restParam) = formalArgsRegistry.genFormalArgs()
/* Generate the body
* We have a fast-path for methods that are not overloaded. In addition to
* being a fast path, it does a better job than `genExportMethodMultiAlts`
* when the only alternative has default parameters, because it avoids a
* spurious dispatch.
* In scalac, the spurious dispatch was avoided by a more elaborate case
* generation in `genExportMethod`, which was very convoluted and was not
* ported to dotc.
*/
val body =
if (alts.tail.isEmpty) alts.head.genBody(formalArgsRegistry)
else genExportMethodMultiAlts(formalArgsRegistry, maxNonRepeatedArgc, alts, tpe, jsName)
(formalArgs, restParam, body)
}
private def genExportMethodMultiAlts(formalArgsRegistry: FormalArgsRegistry,
maxNonRepeatedArgc: Int, alts: List[Exported], tpe: jstpe.Type, jsName: JSName)(
implicit pos: SourcePosition): js.Tree = {
// Generate tuples (argc, method)
val methodArgCounts = for {
alt <- alts
argc <- alt.minArgc to (if (alt.hasRepeatedParam) maxNonRepeatedArgc else alt.maxNonRepeatedArgc)
} yield {
(argc, alt)
}
// Create a list of (argCount -> methods), sorted by argCount (methods may appear multiple times)
val methodsByArgCount: List[(Int, List[Exported])] =
methodArgCounts.groupMap(_._1)(_._2).toList.sortBy(_._1) // sort for determinism
val altsWithVarArgs = alts.filter(_.hasRepeatedParam)
// Generate a case block for each (argCount, methods) tuple
// TODO? We could optimize this a bit by putting together all the `argCount`s that have the same methods
// (Scala.js for scalac does that, but the code is very convoluted and it's not clear that it is worth it).
val cases = for {
(argc, methods) <- methodsByArgCount
if methods != altsWithVarArgs // exclude default case we're generating anyways for varargs
} yield {
// body of case to disambiguates methods with current count
val caseBody = genOverloadDispatchSameArgc(jsName, formalArgsRegistry, methods, tpe, Some(argc))
List(js.IntLiteral(argc - formalArgsRegistry.minArgc)) -> caseBody
}
def defaultCase = {
if (altsWithVarArgs.isEmpty)
genThrowTypeError()
else
genOverloadDispatchSameArgc(jsName, formalArgsRegistry, altsWithVarArgs, tpe, None)
}
val body = {
if (cases.isEmpty) {
defaultCase
} else if (cases.tail.isEmpty && altsWithVarArgs.isEmpty) {
cases.head._2
} else {
val restArgRef = formalArgsRegistry.genRestArgRef()
js.Match(
js.AsInstanceOf(js.JSSelect(restArgRef, js.StringLiteral("length")), jstpe.IntType),
cases,
defaultCase)(
tpe)
}
}
body
}
/** Resolves method calls to [[alts]] while assuming they have the same parameter count.
*
* @param jsName
* The JS name of the method, for error reporting
* @param formalArgsRegistry
* The registry of all the formal arguments
* @param alts
* Alternative methods
* @param tpe
* Result type
* @param maxArgc
* Maximum number of arguments to use for disambiguation
*/
private def genOverloadDispatchSameArgc(jsName: JSName, formalArgsRegistry: FormalArgsRegistry,
alts: List[Exported], tpe: jstpe.Type, maxArgc: Option[Int]): js.Tree = {
genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry, alts, tpe, paramIndex = 0, maxArgc)
}
/** Resolves method calls to [[alts]] while assuming they have the same parameter count.
*
* @param jsName
* The JS name of the method, for error reporting
* @param formalArgsRegistry
* The registry of all the formal arguments
* @param alts
* Alternative methods
* @param tpe
* Result type
* @param paramIndex
* Index where to start disambiguation (starts at 0, increases through recursion)
* @param maxArgc
* Maximum number of arguments to use for disambiguation
*/
private def genOverloadDispatchSameArgcRec(jsName: JSName, formalArgsRegistry: FormalArgsRegistry,
alts: List[Exported], tpe: jstpe.Type, paramIndex: Int, maxArgc: Option[Int]): js.Tree = {
implicit val pos = alts.head.pos
if (alts.sizeIs == 1) {
alts.head.genBody(formalArgsRegistry)
} else if (maxArgc.exists(_ <= paramIndex) || !alts.exists(_.params.size > paramIndex)) {
// We reach here in three cases:
// 1. The parameter list has been exhausted
// 2. The optional argument count restriction has triggered
// 3. We only have (more than once) repeated parameters left
// Therefore, we should fail
reportCannotDisambiguateError(jsName, alts.map(_.sym))
js.Undefined()
} else {
val altsByTypeTest = groupByWithoutHashCode(alts) { exported =>
typeTestForTpe(exported.exportArgTypeAt(paramIndex))
}
if (altsByTypeTest.size == 1) {
// Testing this parameter is not doing any us good
genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry, alts, tpe, paramIndex + 1, maxArgc)
} else {
// Sort them so that, e.g., isInstanceOf[String] comes before isInstanceOf[Object]
val sortedAltsByTypeTest = topoSortDistinctsWith(altsByTypeTest) { (lhs, rhs) =>
(lhs._1, rhs._1) match {
// NoTypeTest is always last
case (_, NoTypeTest) => true
case (NoTypeTest, _) => false
case (PrimitiveTypeTest(_, rank1), PrimitiveTypeTest(_, rank2)) =>
rank1 <= rank2
case (InstanceOfTypeTest(t1), InstanceOfTypeTest(t2)) =>
t1 <:< t2
case (_: PrimitiveTypeTest, _: InstanceOfTypeTest) => true
case (_: InstanceOfTypeTest, _: PrimitiveTypeTest) => false
}
}
val defaultCase = genThrowTypeError()
sortedAltsByTypeTest.foldRight[js.Tree](defaultCase) { (elem, elsep) =>
val (typeTest, subAlts) = elem
implicit val pos = subAlts.head.pos
val paramRef = formalArgsRegistry.genArgRef(paramIndex)
val genSubAlts = genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry,
subAlts, tpe, paramIndex + 1, maxArgc)
def hasDefaultParam = subAlts.exists(_.hasDefaultAt(paramIndex))
val optCond = typeTest match {
case PrimitiveTypeTest(tpe, _) => Some(js.IsInstanceOf(paramRef, tpe))
case InstanceOfTypeTest(tpe) => Some(genIsInstanceOf(paramRef, tpe))
case NoTypeTest => None
}
optCond.fold[js.Tree] {
genSubAlts // note: elsep is discarded, obviously
} { cond =>
val condOrUndef = if (!hasDefaultParam) cond else {
js.If(cond, js.BooleanLiteral(true),
js.BinaryOp(js.BinaryOp.===, paramRef, js.Undefined()))(
jstpe.BooleanType)
}
js.If(condOrUndef, genSubAlts, elsep)(tpe)
}
}
}
}
}
private def reportCannotDisambiguateError(jsName: JSName, alts: List[Symbol]): Unit = {
val currentClass = currentClassSym.get
/* Find a position that is in the current class for decent error reporting.
* If there are more than one, always use the "highest" one (i.e., the
* one coming last in the source text) so that we reliably display the
* same error in all compilers.
*/
val validPositions = alts.collect {
case alt if alt.owner == currentClass => alt.sourcePos
}
val pos: SourcePosition =
if (validPositions.isEmpty) currentClass.sourcePos
else validPositions.maxBy(_.point)
val kind =
if (alts.head.isJSGetter) "getter"
else if (alts.head.isJSSetter) "setter"
else "method"
val fullKind =
if (currentClass.isJSType) kind
else "exported " + kind
val displayName = jsName.displayName
val altsTypesInfo = alts.map(_.info.show).sorted.mkString("\n ")
report.error(
em"Cannot disambiguate overloads for $fullKind $displayName with types\n $altsTypesInfo",
pos)
}
/** Generates a call to the method represented by the given `exported` while using the formalArguments
* and potentially the argument array.
*
* Also inserts default parameters if required.
*/
private def genApplyForSingleExported(formalArgsRegistry: FormalArgsRegistry,
exported: Exported, static: Boolean): js.Tree = {
if (currentClassSym.isJSType && exported.sym.owner != currentClassSym.get) {
assert(!static, s"nonsensical JS super call in static export of ${exported.sym}")
genApplyForSingleExportedJSSuperCall(formalArgsRegistry, exported)
} else {
genApplyForSingleExportedNonJSSuperCall(formalArgsRegistry, exported, static)
}
}
private def genApplyForSingleExportedJSSuperCall(
formalArgsRegistry: FormalArgsRegistry, exported: Exported): js.Tree = {
implicit val pos = exported.pos
val sym = exported.sym
assert(!sym.isClassConstructor,
s"Trying to genApplyForSingleExportedJSSuperCall for the constructor ${sym.fullName}")
val allArgs = formalArgsRegistry.genAllArgsRefsForForwarder()
val superClass = {
val superClassSym = currentClassSym.asClass.superClass
if (superClassSym.isNestedJSClass)
js.VarRef(js.LocalIdent(JSSuperClassParamName))(jstpe.AnyType)
else
js.LoadJSConstructor(encodeClassName(superClassSym))
}
val receiver = js.This()(currentThisType)
val nameTree = genExpr(sym.jsName)
if (sym.isJSGetter) {
assert(allArgs.isEmpty,
s"getter symbol $sym does not have a getter signature")
js.JSSuperSelect(superClass, receiver, nameTree)
} else if (sym.isJSSetter) {
assert(allArgs.size == 1 && allArgs.head.isInstanceOf[js.Tree],
s"setter symbol $sym does not have a setter signature")
js.Assign(js.JSSuperSelect(superClass, receiver, nameTree),
allArgs.head.asInstanceOf[js.Tree])
} else {
js.JSSuperMethodCall(superClass, receiver, nameTree, allArgs)
}
}
private def genApplyForSingleExportedNonJSSuperCall(
formalArgsRegistry: FormalArgsRegistry, exported: Exported, static: Boolean): js.Tree = {
implicit val pos = exported.pos
val varDefs = new mutable.ListBuffer[js.VarDef]
for ((param, i) <- exported.params.zipWithIndex) {
val rhs = genScalaArg(exported, i, formalArgsRegistry, param, static, captures = Nil)(
prevArgsCount => varDefs.take(prevArgsCount).toList.map(_.ref))
varDefs += js.VarDef(freshLocalIdent("prep" + i), NoOriginalName, rhs.tpe, mutable = false, rhs)
}
val builtVarDefs = varDefs.result()
val jsResult = genResult(exported, builtVarDefs.map(_.ref), static)
js.Block(builtVarDefs :+ jsResult)
}
/** Generates a Scala argument from dispatched JavaScript arguments
* (unboxing and default parameter handling).
*/
def genScalaArg(exported: Exported, paramIndex: Int, formalArgsRegistry: FormalArgsRegistry,
param: JSParamInfo, static: Boolean, captures: List[js.Tree])(
previousArgsValues: Int => List[js.Tree])(
implicit pos: SourcePosition): js.Tree = {
if (param.repeated) {
genJSArrayToVarArgs(formalArgsRegistry.genVarargRef(paramIndex))
} else {
val jsArg = formalArgsRegistry.genArgRef(paramIndex)
// Unboxed argument (if it is defined)
val unboxedArg = unbox(jsArg, param.info)
if (exported.hasDefaultAt(paramIndex)) {
// If argument is undefined and there is a default getter, call it
js.If(js.BinaryOp(js.BinaryOp.===, jsArg, js.Undefined()), {
genCallDefaultGetter(exported.sym, paramIndex, static, captures)(previousArgsValues)
}, {
unboxedArg
})(unboxedArg.tpe)
} else {
// Otherwise, it is always the unboxed argument
unboxedArg
}
}
}
def genCallDefaultGetter(sym: Symbol, paramIndex: Int,
static: Boolean, captures: List[js.Tree])(
previousArgsValues: Int => List[js.Tree])(
implicit pos: SourcePosition): js.Tree = {
val targetSym = targetSymForDefaultGetter(sym)
val defaultGetterDenot = this.defaultGetterDenot(targetSym, sym, paramIndex)
assert(defaultGetterDenot.exists, s"need default getter for method ${sym.fullName}")
assert(!defaultGetterDenot.isOverloaded, i"found overloaded default getter $defaultGetterDenot")
val defaultGetter = defaultGetterDenot.symbol
val targetTree = {
if (sym.isClassConstructor || static) {
if (targetSym.isStatic) {
assert(captures.isEmpty, i"expected empty captures for ${targetSym.fullName} at $pos")
genLoadModule(targetSym)
} else {
assert(captures.sizeIs == 1, "expected exactly one capture")
// Find the module accessor. We cannot use memberBasedOnFlags because of scala-js/scala-js#4526.
val outer = targetSym.originalOwner
val name = atPhase(typerPhase)(targetSym.name.unexpandedName).sourceModuleName
val modAccessor = outer.info.allMembers.find { denot =>
denot.symbol.is(Module) && denot.name.unexpandedName == name
}.getOrElse {
throw new AssertionError(i"could not find module accessor for ${targetSym.fullName} at $pos")
}.symbol
val receiver = captures.head
if (outer.isJSType)
genApplyJSClassMethod(receiver, modAccessor, Nil)
else
genApplyMethodMaybeStatically(receiver, modAccessor, Nil)
}
} else {
js.This()(currentThisType)
}
}
// Pass previous arguments to defaultGetter
val defaultGetterArgs = previousArgsValues(defaultGetter.info.paramInfoss.head.size)
val callGetter = if (targetSym.isJSType) {
if (defaultGetter.owner.isNonNativeJSClass) {
if (defaultGetter.hasAnnotation(jsdefn.JSOptionalAnnot))
js.Undefined()
else
genApplyJSClassMethod(targetTree, defaultGetter, defaultGetterArgs)
} else if (defaultGetter.owner == targetSym) {
/* We get here if a non-native constructor has a native companion.
* This is reported on a per-class level.
*/
assert(sym.isClassConstructor,
s"got non-constructor method $sym with default method in JS native companion")
js.Undefined()
} else {
report.error(
"When overriding a native method with default arguments, " +
"the overriding method must explicitly repeat the default arguments.",
sym.srcPos)
js.Undefined()
}
} else {
genApplyMethod(targetTree, defaultGetter, defaultGetterArgs)
}
// #15419 If the getter returns void, we must "box" it by returning undefined
if (callGetter.tpe == jstpe.NoType)
js.Block(callGetter, js.Undefined())
else
callGetter
}
private def targetSymForDefaultGetter(sym: Symbol): Symbol =
if (sym.isClassConstructor) sym.owner.companionModule.moduleClass
else sym.owner
private def defaultGetterDenot(targetSym: Symbol, sym: Symbol, paramIndex: Int): Denotation =
targetSym.info.memberBasedOnFlags(DefaultGetterName(sym.name.asTermName, paramIndex), excluded = Bridge)
private def defaultGetterDenot(sym: Symbol, paramIndex: Int): Denotation =
defaultGetterDenot(targetSymForDefaultGetter(sym), sym, paramIndex)
/** Generate the final forwarding call to the exported method. */
private def genResult(exported: Exported, args: List[js.Tree], static: Boolean)(
implicit pos: SourcePosition): js.Tree = {
val sym = exported.sym
val currentClass = currentClassSym.get
def receiver =
if (static) genLoadModule(sym.owner)
else js.This()(currentThisType)
def boxIfNeeded(call: js.Tree): js.Tree =
box(call, atPhase(elimErasedValueTypePhase)(sym.info.resultType))
if (currentClass.isNonNativeJSClass) {
assert(sym.owner == currentClass, sym.fullName)
boxIfNeeded(genApplyJSClassMethod(receiver, sym, args))
} else {
if (sym.isClassConstructor)
js.New(encodeClassName(currentClass), encodeMethodSym(sym), args)
else if (sym.isPrivate)
boxIfNeeded(genApplyMethodStatically(receiver, sym, args))
else
boxIfNeeded(genApplyMethod(receiver, sym, args))
}
}
private def genThrowTypeError(msg: String = "No matching overload")(implicit pos: Position): js.Tree =
js.Throw(js.JSNew(js.JSGlobalRef("TypeError"), js.StringLiteral(msg) :: Nil))
abstract class Exported(
val sym: Symbol,
// Parameters participating in overload resolution.
val params: scala.collection.immutable.IndexedSeq[JSParamInfo]
) {
assert(!params.exists(_.capture), "illegal capture params in Exported")
private val paramsHasDefault = {
if (!atPhase(elimRepeatedPhase)(sym.hasDefaultParams)) {
Vector.empty
} else {
val targetSym = targetSymForDefaultGetter(sym)
params.indices.map(i => defaultGetterDenot(targetSym, sym, i).exists)
}
}
def hasDefaultAt(paramIndex: Int): Boolean =
paramIndex < paramsHasDefault.size && paramsHasDefault(paramIndex)
val hasRepeatedParam = params.nonEmpty && params.last.repeated
val minArgc = {
// Find the first default param or repeated param
params
.indices
.find(i => hasDefaultAt(i) || params(i).repeated)
.getOrElse(params.size)
}
val maxNonRepeatedArgc = if (hasRepeatedParam) params.size - 1 else params.size
def pos: SourcePosition = sym.sourcePos
def exportArgTypeAt(paramIndex: Int): Type = {
if (paramIndex < params.length) {
params(paramIndex).info
} else {
assert(hasRepeatedParam, i"$sym does not have varargs nor enough params for $paramIndex")
params.last.info
}
}
def typeInfo: String = sym.info.toString
def genBody(formalArgsRegistry: FormalArgsRegistry): js.Tree
}
private class ExportedSymbol(sym: Symbol, static: Boolean)
extends Exported(sym, sym.jsParamInfos.toIndexedSeq) {
def genBody(formalArgsRegistry: FormalArgsRegistry): js.Tree =
genApplyForSingleExported(formalArgsRegistry, this, static)
}
// !!! Hash codes of RTTypeTest are meaningless because of InstanceOfTypeTest
private sealed abstract class RTTypeTest
private case class PrimitiveTypeTest(tpe: jstpe.Type, rank: Int) extends RTTypeTest
// !!! This class does not have a meaningful hash code
private case class InstanceOfTypeTest(tpe: Type) extends RTTypeTest {
override def equals(that: Any): Boolean = {
that match {
case InstanceOfTypeTest(thatTpe) => tpe =:= thatTpe
case _ => false
}
}
}
private case object NoTypeTest extends RTTypeTest
/** Very simple O(n²) topological sort for elements assumed to be distinct. */
private def topoSortDistinctsWith[A <: AnyRef](coll: List[A])(lteq: (A, A) => Boolean): List[A] = {
@tailrec
def loop(coll: List[A], acc: List[A]): List[A] = {
if (coll.isEmpty) acc
else if (coll.tail.isEmpty) coll.head :: acc
else {
val (lhs, rhs) = coll.span(x => !coll.forall(y => (x eq y) || !lteq(x, y)))
assert(!rhs.isEmpty, s"cycle while ordering $coll")
loop(lhs ::: rhs.tail, rhs.head :: acc)
}
}
loop(coll, Nil)
}
private def typeTestForTpe(tpe: Type): RTTypeTest = {
tpe match {
case tpe: ErasedValueType =>
InstanceOfTypeTest(tpe.tycon.typeSymbol.typeRef)
case _ =>
import dotty.tools.sjs.ir.Names
(toIRType(tpe): @unchecked) match {
case jstpe.AnyType => NoTypeTest
case jstpe.NoType => PrimitiveTypeTest(jstpe.UndefType, 0)
case jstpe.BooleanType => PrimitiveTypeTest(jstpe.BooleanType, 1)
case jstpe.CharType => PrimitiveTypeTest(jstpe.CharType, 2)
case jstpe.ByteType => PrimitiveTypeTest(jstpe.ByteType, 3)
case jstpe.ShortType => PrimitiveTypeTest(jstpe.ShortType, 4)
case jstpe.IntType => PrimitiveTypeTest(jstpe.IntType, 5)
case jstpe.LongType => PrimitiveTypeTest(jstpe.LongType, 6)
case jstpe.FloatType => PrimitiveTypeTest(jstpe.FloatType, 7)
case jstpe.DoubleType => PrimitiveTypeTest(jstpe.DoubleType, 8)
case jstpe.ClassType(Names.BoxedUnitClass) => PrimitiveTypeTest(jstpe.UndefType, 0)
case jstpe.ClassType(Names.BoxedStringClass) => PrimitiveTypeTest(jstpe.StringType, 9)
case jstpe.ClassType(_) => InstanceOfTypeTest(tpe)
case jstpe.ArrayType(_) => InstanceOfTypeTest(tpe)
}
}
}
// Group-by that does not rely on hashCode(), only equals() - O(n²)
private def groupByWithoutHashCode[A, B](coll: List[A])(f: A => B): List[(B, List[A])] = {
val m = new mutable.ArrayBuffer[(B, List[A])]
m.sizeHint(coll.length)
for (elem <- coll) {
val key = f(elem)
val index = m.indexWhere(_._1 == key)
if (index < 0)
m += ((key, List(elem)))
else
m(index) = (key, elem :: m(index)._2)
}
m.toList
}
class FormalArgsRegistry(val minArgc: Int, needsRestParam: Boolean) {
private val fixedParamNames: scala.collection.immutable.IndexedSeq[jsNames.LocalName] =
(0 until minArgc).toIndexedSeq.map(_ => freshLocalIdent("arg")(NoPosition).name)
private val restParamName: jsNames.LocalName =
if (needsRestParam) freshLocalIdent("rest")(NoPosition).name
else null
def genFormalArgs()(implicit pos: Position): (List[js.ParamDef], Option[js.ParamDef]) = {
val fixedParamDefs = fixedParamNames.toList.map { paramName =>
js.ParamDef(js.LocalIdent(paramName), NoOriginalName, jstpe.AnyType, mutable = false)
}
val restParam = {
if (needsRestParam)
Some(js.ParamDef(js.LocalIdent(restParamName), NoOriginalName, jstpe.AnyType, mutable = false))
else
None
}
(fixedParamDefs, restParam)
}
def genArgRef(index: Int)(implicit pos: Position): js.Tree = {
if (index < minArgc)
js.VarRef(js.LocalIdent(fixedParamNames(index)))(jstpe.AnyType)
else
js.JSSelect(genRestArgRef(), js.IntLiteral(index - minArgc))
}
def genVarargRef(fixedParamCount: Int)(implicit pos: Position): js.Tree = {
assert(fixedParamCount >= minArgc, s"genVarargRef($fixedParamCount) with minArgc = $minArgc at $pos")
val restParam = genRestArgRef()
if (fixedParamCount == minArgc)
restParam
else
js.JSMethodApply(restParam, js.StringLiteral("slice"), List(js.IntLiteral(fixedParamCount - minArgc)))
}
def genRestArgRef()(implicit pos: Position): js.Tree = {
assert(needsRestParam, s"trying to generate a reference to non-existent rest param at $pos")
js.VarRef(js.LocalIdent(restParamName))(jstpe.AnyType)
}
def genAllArgsRefsForForwarder()(implicit pos: Position): List[js.TreeOrJSSpread] = {
val fixedArgRefs = fixedParamNames.toList.map { paramName =>
js.VarRef(js.LocalIdent(paramName))(jstpe.AnyType)
}
if (needsRestParam) {
val restArgRef = js.VarRef(js.LocalIdent(restParamName))(jstpe.AnyType)
fixedArgRefs :+ js.JSSpread(restArgRef)
} else {
fixedArgRefs
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy