Skip to content

Commit

Permalink
Refactoring: Factor out the creation of typed anonymous classes.
Browse files Browse the repository at this point in the history 
There are several places where we create typed anonymous classes.
All followed the same pattern, which we now factored out in a new
`tpe.AnonClass` overload.
  • Loading branch information
@sjrd
sjrd committed Jul 23, 2022
1 parent 6449e96 commit ffd2e97
Show file tree
Hide file tree
Showing 4 changed files with 96 additions and 94 deletions.
34 changes: 21 additions & 13 deletions compiler/src/dotty/tools/dotc/ast/tpd.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -340,27 +340,35 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
* Its position is the union of all functions in `fns`.
*/
def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(using Context): Block = {
val owner = fns.head.owner
AnonClass(fns.head.owner, parents, fns.map(_.span).reduceLeft(_ union _)) { cls =>
def forwarder(fn: TermSymbol, name: TermName) = {
val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
for overridden <- fwdMeth.allOverriddenSymbols do
if overridden.is(Extension) then fwdMeth.setFlag(Extension)
if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
DefDef(fwdMeth, ref(fn).appliedToArgss(_))
}
fns.lazyZip(methNames).map(forwarder)
}
}

/** An anonymous class
*
* new parents { body }
*
* with the specified owner and position.
*/
def AnonClass(owner: Symbol, parents: List[Type], coord: Coord)(body: ClassSymbol => List[Tree])(using Context): Block =
val parents1 =
if (parents.head.classSymbol.is(Trait)) {
val head = parents.head.parents.head
if (head.isRef(defn.AnyClass)) defn.AnyRefType :: parents else head :: parents
}
else parents
val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1,
coord = fns.map(_.span).reduceLeft(_ union _))
val cls = newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1, coord = coord)
val constr = newConstructor(cls, Synthetic, Nil, Nil).entered
def forwarder(fn: TermSymbol, name: TermName) = {
val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
for overridden <- fwdMeth.allOverriddenSymbols do
if overridden.is(Extension) then fwdMeth.setFlag(Extension)
if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
DefDef(fwdMeth, ref(fn).appliedToArgss(_))
}
val forwarders = fns.lazyZip(methNames).map(forwarder)
val cdef = ClassDef(cls, DefDef(constr), forwarders)
val cdef = ClassDef(cls, DefDef(constr), body(cls))
Block(cdef :: Nil, New(cls.typeRef, Nil))
}

def Import(expr: Tree, selectors: List[untpd.ImportSelector])(using Context): Import =
ta.assignType(untpd.Import(expr, selectors), newImportSymbol(ctx.owner, expr))
Expand Down
39 changes: 21 additions & 18 deletions compiler/src/dotty/tools/dotc/inlines/Inlines.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -195,23 +195,26 @@ object Inlines:
report.error("inline unapply methods with given parameters before the scrutinee are not supported", fun)

val sym = unapp.symbol
val cls = newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = sym.coord)
val constr = newConstructor(cls, Synthetic, Nil, Nil, coord = sym.coord).entered

val targs = fun match
case TypeApply(_, targs) => targs
case _ => Nil
val unapplyInfo = sym.info match
case info: PolyType => info.instantiate(targs.map(_.tpe))
case info => info

val unappplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
val unapply = DefDef(unappplySym, argss =>
inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unappplySym))
)
val cdef = ClassDef(cls, DefDef(constr), List(unapply))
val newUnapply = Block(cdef :: Nil, New(cls.typeRef, Nil))
val newFun = newUnapply.select(unappplySym).withSpan(unapp.span)

var unapplySym1: Symbol = NoSymbol // created from within AnonClass() and used afterwards

val newUnapply = AnonClass(ctx.owner, List(defn.ObjectType), sym.coord) { cls =>
val targs = fun match
case TypeApply(_, targs) => targs
case _ => Nil
val unapplyInfo = sym.info match
case info: PolyType => info.instantiate(targs.map(_.tpe))
case info => info

val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
val unapply = DefDef(unapplySym.asTerm, argss =>
inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unapplySym))
)
unapplySym1 = unapplySym
List(unapply)
}

val newFun = newUnapply.select(unapplySym1).withSpan(unapp.span)
cpy.UnApply(unapp)(newFun, trailingImplicits, patterns)
end inlinedUnapply

Expand Down Expand Up @@ -463,4 +466,4 @@ object Inlines:
// the opaque type itself. An example is in pos/opaque-inline1.scala.
end expand
end InlineCall
end Inlines
end Inlines
92 changes: 45 additions & 47 deletions compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -124,55 +124,54 @@ class ExpandSAMs extends MiniPhase:
val parents = List(
defn.AbstractPartialFunctionClass.typeRef.appliedTo(anonTpe.firstParamTypes.head, anonTpe.resultType),
defn.SerializableType)
val pfSym = newNormalizedClassSymbol(anonSym.owner, tpnme.ANON_CLASS, Synthetic | Final, parents, coord = tree.span)

def overrideSym(sym: Symbol) = sym.copy(
owner = pfSym,
flags = Synthetic | Method | Final | Override,
info = tpe.memberInfo(sym),
coord = tree.span).asTerm.entered
val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)

def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(using Context) = {
val selector = tree.selector
val selectorTpe = selector.tpe.widen
val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
val defaultCase =
CaseDef(
Bind(defaultSym, Underscore(selectorTpe)),
EmptyTree,
defaultValue)
val unchecked = selector.annotated(New(ref(defn.UncheckedAnnot.typeRef)))
cpy.Match(tree)(unchecked, cases :+ defaultCase)
.subst(param.symbol :: Nil, pfParam :: Nil)
// Needed because a partial function can be written as:
// param => param match { case "foo" if foo(param) => param }
// And we need to update all references to 'param'
}

def isDefinedAtRhs(paramRefss: List[List[Tree]])(using Context) = {
val tru = Literal(Constant(true))
def translateCase(cdef: CaseDef) =
cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
val paramRef = paramRefss.head.head
val defaultValue = Literal(Constant(false))
translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
}
AnonClass(anonSym.owner, parents, tree.span) { pfSym =>
def overrideSym(sym: Symbol) = sym.copy(
owner = pfSym,
flags = Synthetic | Method | Final | Override,
info = tpe.memberInfo(sym),
coord = tree.span).asTerm.entered
val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)

def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree)(using Context) = {
val selector = tree.selector
val selectorTpe = selector.tpe.widen
val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
val defaultCase =
CaseDef(
Bind(defaultSym, Underscore(selectorTpe)),
EmptyTree,
defaultValue)
val unchecked = selector.annotated(New(ref(defn.UncheckedAnnot.typeRef)))
cpy.Match(tree)(unchecked, cases :+ defaultCase)
.subst(param.symbol :: Nil, pfParam :: Nil)
// Needed because a partial function can be written as:
// param => param match { case "foo" if foo(param) => param }
// And we need to update all references to 'param'
}

def applyOrElseRhs(paramRefss: List[List[Tree]])(using Context) = {
val List(paramRef, defaultRef) = paramRefss(1)
def translateCase(cdef: CaseDef) =
cdef.changeOwner(anonSym, applyOrElseFn)
val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
}
def isDefinedAtRhs(paramRefss: List[List[Tree]])(using Context) = {
val tru = Literal(Constant(true))
def translateCase(cdef: CaseDef) =
cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
val paramRef = paramRefss.head.head
val defaultValue = Literal(Constant(false))
translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
}

val constr = newConstructor(pfSym, Synthetic, Nil, Nil).entered
val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(using ctx.withOwner(isDefinedAtFn))))
val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(using ctx.withOwner(applyOrElseFn))))
val pfDef = ClassDef(pfSym, DefDef(constr), List(isDefinedAtDef, applyOrElseDef))
cpy.Block(tree)(pfDef :: Nil, New(pfSym.typeRef, Nil))
def applyOrElseRhs(paramRefss: List[List[Tree]])(using Context) = {
val List(paramRef, defaultRef) = paramRefss(1)
def translateCase(cdef: CaseDef) =
cdef.changeOwner(anonSym, applyOrElseFn)
val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
translateMatch(pfRHS, paramRef.symbol, pfRHS.cases.map(translateCase), defaultValue)
}

val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)(using ctx.withOwner(isDefinedAtFn))))
val applyOrElseDef = transformFollowingDeep(DefDef(applyOrElseFn, applyOrElseRhs(_)(using ctx.withOwner(applyOrElseFn))))
List(isDefinedAtDef, applyOrElseDef)
}
}

private def checkRefinements(tpe: Type, tree: Tree)(using Context): Type = tpe.dealias match {
Expand All @@ -184,4 +183,3 @@ class ExpandSAMs extends MiniPhase:
tpe
}
end ExpandSAMs

25 changes: 9 additions & 16 deletions compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -292,25 +292,18 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP

assert(currentOwner.isTerm, s"unexpected owner: $currentOwner at ${tree.sourcePos}")

val cls = newNormalizedClassSymbol(currentOwner, tpnme.ANON_CLASS, Synthetic | Final,
List(jsdefn.DynamicImportThunkType), coord = span)
val constr = newConstructor(cls, Synthetic, Nil, Nil).entered

val applySym = newSymbol(cls, nme.apply, Method, MethodType(Nil, Nil, defn.AnyType), coord = span).entered
val newBody = transform(body).changeOwnerAfter(currentOwner, applySym, thisPhase)
val applyDefDef = DefDef(applySym, newBody)

// class $anon extends DynamicImportThunk
val cdef = ClassDef(cls, DefDef(constr), List(applyDefDef)).withSpan(span)
// new DynamicImportThunk { def apply(): Any = body }
val dynamicImportThunkAnonClass = AnonClass(currentOwner, List(jsdefn.DynamicImportThunkType), span) { cls =>
val applySym = newSymbol(cls, nme.apply, Method, MethodType(Nil, Nil, defn.AnyType), coord = span).entered
val newBody = transform(body).changeOwnerAfter(currentOwner, applySym, thisPhase)
val applyDefDef = DefDef(applySym, newBody)
List(applyDefDef)
}

/* runtime.DynamicImport[A]({
* class $anon ...
* new $anon
* })
*/
// runtime.DynamicImport[A](new ...)
ref(jsdefn.Runtime_dynamicImport)
.appliedToTypeTree(tpeArg)
.appliedTo(Block(cdef :: Nil, New(cls.typeRef, Nil)))
.appliedTo(dynamicImportThunkAnonClass)

// Compile-time errors and warnings for js.Dynamic.literal
case Apply(Apply(fun, nameArgs), args)
Expand Down

0 comments on commit ffd2e97

Please sign in to comment.