Skip to content

Commit 136b673

Browse files
nicolasstuckinicolasstucki
committed
Fix modifiers
1 parent 2ee319a commit 136b673

File tree

12 files changed

+207
-171
lines changed

12 files changed

+207
-171
lines changed

‎compiler/src/dotty/tools/dotc/tasty/Toolbox.scala

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,7 @@ object Toolbox {
127127

128128
// Modifiers
129129

130+
override def unapplyFlags(arg: Modifier) = unapplied(arg, internal.FlagsModifier.unapplyFlags)
130131
override def unapplyQualifiedPrivate(arg: Modifier) = unapplied(arg, internal.QualifiedModifier.unapplyQualifiedPrivate)
131132
override def unapplyQualifiedProtected(arg: Modifier) = unapplied(arg, internal.QualifiedModifier.unapplyQualifiedProtected)
132133
override def unapplyAnnotation(arg: Modifier) = unapplied(arg, internal.AnnotationModifier.unapplyAnnotation)

‎compiler/src/dotty/tools/dotc/tasty/internal/FlagsModifier.scala

Lines changed: 90 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,90 @@
1+
package dotty.tools.dotc.tasty
2+
package internal
3+
4+
import dotty.tools.dotc.core.Contexts.Context
5+
import dotty.tools.dotc.core.Decorators._
6+
import dotty.tools.dotc.core.Symbols.Symbol
7+
import dotty.tools.dotc.core.Flags._
8+
9+
import scala.tasty.modifiers
10+
11+
object FlagsModifier {
12+
13+
// TODO make sure all flags are tested
14+
15+
def apply(sym: Symbol)(implicit ctx: Context): modifiers.Modifier = new Impl(sym)
16+
17+
def unapplyFlags(arg: Impl): Option[modifiers.Flags.Data] = {
18+
implicit val ctx: Context = arg.ctx
19+
val sym = arg.sym
20+
Some(new modifiers.FlagSet {
21+
override def isProtected: Boolean = sym.is(Protected)
22+
override def isAbstract: Boolean = sym.is(Abstract)
23+
override def isFinal: Boolean = sym.is(Final)
24+
override def isSealed: Boolean = sym.is(Sealed)
25+
override def isCase: Boolean = sym.is(Case)
26+
override def isImplicit: Boolean = sym.is(Implicit)
27+
override def isErased: Boolean = sym.is(Erased)
28+
override def isLazy: Boolean = sym.is(Lazy)
29+
override def isOverride: Boolean = sym.is(Override)
30+
override def isInline: Boolean = sym.is(Inline)
31+
override def isMacro: Boolean = sym.is(Macro)
32+
override def isStatic: Boolean = sym.is(JavaStatic)
33+
override def isObject: Boolean = sym.is(Module)
34+
override def isTrait: Boolean = sym.is(Trait)
35+
override def isLocal: Boolean = sym.is(Local)
36+
override def isSynthetic: Boolean = sym.is(Synthetic)
37+
override def isArtifact: Boolean = sym.is(Artifact)
38+
override def isMutable: Boolean = sym.is(Mutable)
39+
override def isLabel: Boolean = sym.is(Label)
40+
override def isFieldAccessor: Boolean = sym.is(Accessor)
41+
override def isCaseAcessor: Boolean = sym.is(CaseAccessor)
42+
override def isCovariant: Boolean = sym.is(Covariant)
43+
override def isContravariant: Boolean = sym.is(Contravariant)
44+
override def isScala2X: Boolean = sym.is(Scala2x)
45+
override def isDefaultParameterized: Boolean = sym.is(DefaultParameterized)
46+
override def isStable: Boolean = sym.is(Stable)
47+
48+
override def toString: String = {
49+
val flags = List.newBuilder[String]
50+
if (isProtected) flags += "protected "
51+
if (isAbstract) flags += "abstract"
52+
if (isFinal) flags += "final"
53+
if (isSealed) flags += "sealed"
54+
if (isCase) flags += "case"
55+
if (isImplicit) flags += "implicit"
56+
if (isErased) flags += "erased"
57+
if (isLazy) flags += "lazy"
58+
if (isOverride) flags += "override"
59+
if (isInline) flags += "inline"
60+
if (isMacro) flags += "macro"
61+
if (isStatic) flags += "javaStatic"
62+
if (isObject) flags += "module"
63+
if (isTrait) flags += "trait"
64+
if (isLocal) flags += "local"
65+
if (isSynthetic) flags += "synthetic"
66+
if (isArtifact) flags += "artifact"
67+
if (isMutable) flags += "mutable"
68+
if (isLabel) flags += "label"
69+
if (isFieldAccessor) flags += "accessor"
70+
if (isCaseAcessor) flags += "caseAccessor"
71+
if (isCovariant) flags += "covariant"
72+
if (isContravariant) flags += "contravariant"
73+
if (isScala2X) flags += "scala2x"
74+
if (isDefaultParameterized) flags += "defaultParameterized"
75+
if (isStable) flags += "stable"
76+
flags.result().mkString("<", ",", ">")
77+
}
78+
})
79+
}
80+
81+
private[tasty] class Impl(val sym: Symbol)(implicit val ctx: Context) extends modifiers.Modifier {
82+
83+
override def toString: String = {
84+
import Toolbox.extractor
85+
this match {
86+
case modifiers.Flags(flags) => s"Flags($flags)"
87+
}
88+
}
89+
}
90+
}

‎compiler/src/dotty/tools/dotc/tasty/internal/Modifier.scala

Lines changed: 0 additions & 75 deletions
This file was deleted.

‎compiler/src/dotty/tools/dotc/tasty/internal/Modifiers.scala

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,9 @@ import scala.tasty.modifiers
88
object Modifiers {
99

1010
def apply(tree: tpd.MemberDef)(implicit ctx: Context): List[modifiers.Modifier] = {
11+
FlagsModifier(tree.symbol) ::
1112
QualifiedModifier(tree).toList :::
12-
tree.symbol.annotations.map(AnnotationModifier(_)) :::
13-
tree.rawMods.mods.map(Modifier(_))
13+
tree.symbol.annotations.map(AnnotationModifier(_))
1414
}
1515

1616
}

‎library/src/scala/runtime/tasty/Toolbox.scala

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,7 @@ trait Toolbox {
127127

128128
// Modifiers
129129

130+
def unapplyFlags(arg: Modifier): Option[modifiers.Flags.Data]
130131
def unapplyQualifiedPrivate(arg: Modifier): Option[modifiers.QualifiedPrivate.Data]
131132
def unapplyQualifiedProtected(arg: Modifier): Option[modifiers.QualifiedProtected.Data]
132133
def unapplyAnnotation(arg: Modifier): Option[modifiers.Annotation.Data]

‎library/src/scala/tasty/modifiers/FlagSet.scala

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package scala.tasty.modifiers
2+
3+
trait FlagSet {
4+
def isProtected: Boolean
5+
def isAbstract: Boolean
6+
def isFinal: Boolean
7+
def isSealed: Boolean
8+
def isCase: Boolean
9+
def isImplicit: Boolean
10+
def isErased: Boolean
11+
def isLazy: Boolean
12+
def isOverride: Boolean
13+
def isInline: Boolean
14+
def isMacro: Boolean // inline method containing toplevel splices
15+
def isStatic: Boolean // mapped to static Java member
16+
def isObject: Boolean // an object or its class (used for a ValDef or a ClassDef extends Modifier respectively)
17+
def isTrait: Boolean // a trait (used for a ClassDef)
18+
def isLocal: Boolean // used in conjunction with Private/private[Type] to mean private[this] extends Modifier proctected[this]
19+
def isSynthetic: Boolean // generated by Scala compiler
20+
def isArtifact: Boolean // to be tagged Java Synthetic
21+
def isMutable: Boolean // when used on a ValDef: a var
22+
def isLabel: Boolean // method generated as a label
23+
def isFieldAccessor: Boolean // a getter or setter
24+
def isCaseAcessor: Boolean // getter for class parameter
25+
def isCovariant: Boolean // type parameter marked “+”
26+
def isContravariant: Boolean // type parameter marked “-”
27+
def isScala2X: Boolean // Imported from Scala2.x
28+
def isDefaultParameterized: Boolean // Method with default parameters
29+
def isStable: Boolean // Method that is assumed to be stable
30+
}

‎library/src/scala/tasty/modifiers/Modifier.scala

Lines changed: 4 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -4,35 +4,11 @@ package modifiers
44
import scala.runtime.tasty.Toolbox
55
import scala.tasty.trees.Term
66

7-
trait Modifier {
8-
9-
def isProtected: Boolean = false
10-
def isAbstract: Boolean = false
11-
def isFinal: Boolean = false
12-
def isSealed: Boolean = false
13-
def isCase: Boolean = false
14-
def isImplicit: Boolean = false
15-
def isErased: Boolean = false
16-
def isLazy: Boolean = false
17-
def isOverride: Boolean = false
18-
def isInline: Boolean = false
19-
def isMacro: Boolean = false // inline method containing toplevel splices
20-
def isStatic: Boolean = false // mapped to static Java member
21-
def isObject: Boolean = false // an object or its class (used for a ValDef or a ClassDef extends Modifier respectively)
22-
def isTrait: Boolean = false // a trait (used for a ClassDef)
23-
def isLocal: Boolean = false // used in conjunction with Private/private[Type] to mean private[this] extends Modifier proctected[this]
24-
def isSynthetic: Boolean = false // generated by Scala compiler
25-
def isArtifact: Boolean = false // to be tagged Java Synthetic
26-
def isMutable: Boolean = false // when used on a ValDef: a var
27-
def isLabel: Boolean = false // method generated as a label
28-
def isFieldAccessor: Boolean = false // a getter or setter
29-
def isCaseAcessor: Boolean = false // getter for class parameter
30-
def isCovariant: Boolean = false // type parameter marked “+”
31-
def isContravariant: Boolean = false // type parameter marked “-”
32-
def isScala2X: Boolean = false // Imported from Scala2.x
33-
def isDefaultParameterized: Boolean = false // Method with default parameters
34-
def isStable: Boolean = false // Method that is assumed to be stable
7+
trait Modifier
358

9+
object Flags {
10+
type Data = FlagSet
11+
def unapply(arg: Modifier)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyFlags(arg)
3612
}
3713

3814
object QualifiedPrivate {

‎tests/pos/tasty/definitions.scala

Lines changed: 31 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -218,30 +218,43 @@ object definitions {
218218

219219
// ====== Modifiers ==================================
220220

221-
enum Modifier {
222-
case Private, Protected, Abstract, Final, Sealed, Case, Implicit, Erased, Lazy, Override, Inline,
223-
Macro, // inline method containing toplevel splices
224-
Static, // mapped to static Java member
225-
Object, // an object or its class (used for a ValDef or a ClassDef, respectively)
226-
Trait, // a trait (used for a ClassDef)
227-
Local, // used in conjunction with Private/private[Type] to mean private[this], proctected[this]
228-
Synthetic, // generated by Scala compiler
229-
Artifact, // to be tagged Java Synthetic
230-
Mutable, // when used on a ValDef: a var
231-
Label, // method generated as a label
232-
FieldAccessor, // a getter or setter
233-
CaseAcessor, // getter for case class parameter
234-
Covariant, // type parameter marked “+”
235-
Contravariant, // type parameter marked “-”
236-
Scala2X, // Imported from Scala2.x
237-
DefaultParameterized, // Method with default parameters
238-
Stable // Method that is assumed to be stable
239221

222+
enum Modifier {
223+
case Flags(flags: FlagSet)
240224
case QualifiedPrivate(boundary: Type)
241225
case QualifiedProtected(boundary: Type)
242226
case Annotation(tree: Term)
243227
}
244228

229+
trait FlagSet {
230+
def isProtected: Boolean
231+
def isAbstract: Boolean
232+
def isFinal: Boolean
233+
def isSealed: Boolean
234+
def isCase: Boolean
235+
def isImplicit: Boolean
236+
def isErased: Boolean
237+
def isLazy: Boolean
238+
def isOverride: Boolean
239+
def isInline: Boolean
240+
def isMacro: Boolean // inline method containing toplevel splices
241+
def isStatic: Boolean // mapped to static Java member
242+
def isObject: Boolean // an object or its class (used for a ValDef or a ClassDef extends Modifier respectively)
243+
def isTrait: Boolean // a trait (used for a ClassDef)
244+
def isLocal: Boolean // used in conjunction with Private/private[Type] to mean private[this] extends Modifier proctected[this]
245+
def isSynthetic: Boolean // generated by Scala compiler
246+
def isArtifact: Boolean // to be tagged Java Synthetic
247+
def isMutable: Boolean // when used on a ValDef: a var
248+
def isLabel: Boolean // method generated as a label
249+
def isFieldAccessor: Boolean // a getter or setter
250+
def isCaseAcessor: Boolean // getter for class parameter
251+
def isCovariant: Boolean // type parameter marked “+”
252+
def isContravariant: Boolean // type parameter marked “-”
253+
def isScala2X: Boolean // Imported from Scala2.x
254+
def isDefaultParameterized: Boolean // Method with default parameters
255+
def isStable: Boolean // Method that is assumed to be stable
256+
}
257+
245258
// ====== Constants ==================================
246259

247260
enum Constant(val value: Any) {

0 commit comments

Comments
 (0)