diff --git a/community-build/community-projects/scalatest b/community-build/community-projects/scalatest index 5098af41b4b8..4a6cb5fb2adb 160000 --- a/community-build/community-projects/scalatest +++ b/community-build/community-projects/scalatest @@ -1 +1 @@ -Subproject commit 5098af41b4b8dfca2b0844f83a28bbf7351eca49 +Subproject commit 4a6cb5fb2adb20644b4b1daebb933fa80434d877 diff --git a/community-build/community-projects/shapeless b/community-build/community-projects/shapeless index f891242ed245..bdf4e4470199 160000 --- a/community-build/community-projects/shapeless +++ b/community-build/community-projects/shapeless @@ -1 +1 @@ -Subproject commit f891242ed245c3b88d0b9889d64b122a5a50a4d0 +Subproject commit bdf4e4470199c049095b47f7835bffd8135d03ba diff --git a/community-build/community-projects/verify b/community-build/community-projects/verify index c6646b4d2261..cd444ea0659a 160000 --- a/community-build/community-projects/verify +++ b/community-build/community-projects/verify @@ -1 +1 @@ -Subproject commit c6646b4d2261ff33db119a84744740e4124dce1b +Subproject commit cd444ea0659a9680b49319efda1b00a8dcc09f88 diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala index 6e197f5462fc..bc5ad2a50693 100644 --- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala +++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala @@ -2462,6 +2462,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler 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 @@ -2472,14 +2473,17 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler 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 ModuleClass: Flags = dotc.core.Flags.ModuleClass + def Method: Flags = dotc.core.Flags.Method + def Module: Flags = dotc.core.Flags.Module def Mutable: Flags = dotc.core.Flags.Mutable - def Object: Flags = dotc.core.Flags.Module + 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 @@ -2495,6 +2499,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler 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 object FlagsMethodsImpl extends FlagsMethods: diff --git a/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala b/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala index 8f914b3777d9..a4f137fea4af 100644 --- a/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala +++ b/compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala @@ -26,22 +26,26 @@ object Extractors { if (flags.is(Flags.CaseAccessor)) flagList += "Flags.CaseAccessor" if (flags.is(Flags.Contravariant)) flagList += "Flags.Contravariant" if (flags.is(Flags.Covariant)) flagList += "Flags.Covariant" + if (flags.is(Flags.Deferred)) flagList += "Flags.Deferred" if (flags.is(Flags.Enum)) flagList += "Flags.Enum" if (flags.is(Flags.Erased)) flagList += "Flags.Erased" - if (flags.is(Flags.ExtensionMethod)) flagList += "Flags.ExtensionMethod" if (flags.is(Flags.Exported)) flagList += "Flags.Exported" + if (flags.is(Flags.ExtensionMethod)) flagList += "Flags.ExtensionMethod" if (flags.is(Flags.FieldAccessor)) flagList += "Flags.FieldAccessor" if (flags.is(Flags.Final)) flagList += "Flags.Final" if (flags.is(Flags.HasDefault)) flagList += "Flags.HasDefault" if (flags.is(Flags.Implicit)) flagList += "Flags.Implicit" + if (flags.is(Flags.Infix)) flagList += "Flags.Infix" if (flags.is(Flags.Inline)) flagList += "Flags.Inline" if (flags.is(Flags.JavaDefined)) flagList += "Flags.JavaDefined" + if (flags.is(Flags.JavaStatic)) flagList += "Flags.JavaStatic" if (flags.is(Flags.Lazy)) flagList += "Flags.Lazy" if (flags.is(Flags.Local)) flagList += "Flags.Local" if (flags.is(Flags.Macro)) flagList += "Flags.Macro" - if (flags.is(Flags.ModuleClass)) flagList += "Flags.ModuleClass" + if (flags.is(Flags.Method)) flagList += "Flags.Method" + if (flags.is(Flags.Module)) flagList += "Flags.Module" if (flags.is(Flags.Mutable)) flagList += "Flags.Mutable" - if (flags.is(Flags.Object)) flagList += "Flags.Object" + if (flags.is(Flags.NoInits)) flagList += "Flags.NoInits" if (flags.is(Flags.Override)) flagList += "Flags.Override" if (flags.is(Flags.Package)) flagList += "Flags.Package" if (flags.is(Flags.Param)) flagList += "Flags.Param" @@ -55,6 +59,7 @@ object Extractors { if (flags.is(Flags.Static)) flagList += "Flags.javaStatic" if (flags.is(Flags.Synthetic)) flagList += "Flags.Synthetic" if (flags.is(Flags.Trait)) flagList += "Flags.Trait" + if (flags.is(Flags.Transparent)) flagList += "Flags.Transparent" flagList.result().mkString(" | ") } diff --git a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala index daf1ad7dbdda..8522b8f268b1 100644 --- a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala +++ b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala @@ -27,22 +27,26 @@ object SourceCode { if (flags.is(Flags.CaseAccessor)) flagList += "caseAccessor" if (flags.is(Flags.Contravariant)) flagList += "contravariant" if (flags.is(Flags.Covariant)) flagList += "covariant" + if (flags.is(Flags.Deferred)) flagList += "deferred" if (flags.is(Flags.Enum)) flagList += "enum" if (flags.is(Flags.Erased)) flagList += "erased" - if (flags.is(Flags.ExtensionMethod)) flagList += "extension" if (flags.is(Flags.Exported)) flagList += "exported" + if (flags.is(Flags.ExtensionMethod)) flagList += "extension" if (flags.is(Flags.FieldAccessor)) flagList += "accessor" if (flags.is(Flags.Final)) flagList += "final" if (flags.is(Flags.HasDefault)) flagList += "hasDefault" if (flags.is(Flags.Implicit)) flagList += "implicit" + if (flags.is(Flags.Infix)) flagList += "infix" if (flags.is(Flags.Inline)) flagList += "inline" if (flags.is(Flags.JavaDefined)) flagList += "javaDefined" + if (flags.is(Flags.JavaStatic)) flagList += "static" if (flags.is(Flags.Lazy)) flagList += "lazy" if (flags.is(Flags.Local)) flagList += "local" if (flags.is(Flags.Macro)) flagList += "macro" - if (flags.is(Flags.ModuleClass)) flagList += "moduleClass" + if (flags.is(Flags.Method)) flagList += "method" + if (flags.is(Flags.Module)) flagList += "object" if (flags.is(Flags.Mutable)) flagList += "mutable" - if (flags.is(Flags.Object)) flagList += "object" + if (flags.is(Flags.NoInits)) flagList += "noInits" if (flags.is(Flags.Override)) flagList += "override" if (flags.is(Flags.Package)) flagList += "package" if (flags.is(Flags.Param)) flagList += "param" @@ -56,6 +60,7 @@ object SourceCode { if (flags.is(Flags.Static)) flagList += "javaStatic" if (flags.is(Flags.Synthetic)) flagList += "synthetic" if (flags.is(Flags.Trait)) flagList += "trait" + if (flags.is(Flags.Transparent)) flagList += "transparent" flagList.result().mkString("/*", " ", "*/") } @@ -109,7 +114,7 @@ object SourceCode { case tree @ PackageClause(name, stats) => val stats1 = stats.collect { case stat: PackageClause => stat - case stat: Definition if !(stat.symbol.flags.is(Flags.Object) && stat.symbol.flags.is(Flags.Lazy)) => stat + case stat: Definition if !(stat.symbol.flags.is(Flags.Module) && stat.symbol.flags.is(Flags.Lazy)) => stat case stat @ Import(_, _) => stat } name match { @@ -133,19 +138,19 @@ object SourceCode { val flags = cdef.symbol.flags if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ") if (flags.is(Flags.Sealed)) this += highlightKeyword("sealed ") - if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ") + if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ") if (flags.is(Flags.Case)) this += highlightKeyword("case ") if (name == "package$") { this += highlightKeyword("package object ") += highlightTypeDef(cdef.symbol.owner.name.stripSuffix("$")) } - else if (flags.is(Flags.Object)) this += highlightKeyword("object ") += highlightTypeDef(name.stripSuffix("$")) + else if (flags.is(Flags.Module)) this += highlightKeyword("object ") += highlightTypeDef(name.stripSuffix("$")) else if (flags.is(Flags.Trait)) this += highlightKeyword("trait ") += highlightTypeDef(name) else if (flags.is(Flags.Abstract)) this += highlightKeyword("abstract class ") += highlightTypeDef(name) else this += highlightKeyword("class ") += highlightTypeDef(name) val typeParams = stats.collect { case targ: TypeDef => targ }.filter(_.symbol.isTypeParam).zip(targs) - if (!flags.is(Flags.Object)) { + if (!flags.is(Flags.Module)) { printTargsDefs(typeParams) val it = argss.iterator while (it.hasNext) @@ -201,7 +206,7 @@ object SourceCode { // Currently the compiler does not allow overriding some of the methods generated for case classes d.symbol.flags.is(Flags.Synthetic) && (d match { - case DefDef("apply" | "unapply" | "writeReplace", _, _, _, _) if d.symbol.owner.flags.is(Flags.Object) => true + case DefDef("apply" | "unapply" | "writeReplace", _, _, _, _) if d.symbol.owner.flags.is(Flags.Module) => true case DefDef(n, _, _, _, _) if d.symbol.owner.flags.is(Flags.Case) => n == "copy" || n.matches("copy\\$default\\$[1-9][0-9]*") || // default parameters for the copy method @@ -210,7 +215,7 @@ object SourceCode { case _ => false }) } - def isInnerModuleObject = d.symbol.flags.is(Flags.Lazy) && d.symbol.flags.is(Flags.Object) + def isInnerModuleObject = d.symbol.flags.is(Flags.Lazy) && d.symbol.flags.is(Flags.Module) !flags.is(Flags.Param) && !flags.is(Flags.ParamAccessor) && !flags.is(Flags.FieldAccessor) && !isUndecompilableCaseClassMethod && !isInnerModuleObject } val stats1 = stats.collect { @@ -259,7 +264,7 @@ object SourceCode { val flags = vdef.symbol.flags if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ") if (flags.is(Flags.Override)) this += highlightKeyword("override ") - if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ") + if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ") printProtectedOrPrivate(vdef) @@ -299,7 +304,7 @@ object SourceCode { if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ") if (flags.is(Flags.Inline)) this += highlightKeyword("inline ") if (flags.is(Flags.Override)) this += highlightKeyword("override ") - if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ") + if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ") printProtectedOrPrivate(ddef) @@ -466,7 +471,7 @@ object SourceCode { case Block(stats0, expr) => val stats = stats0.filter { - case tree: ValDef => !tree.symbol.flags.is(Flags.Object) + case tree: ValDef => !tree.symbol.flags.is(Flags.Module) case _ => true } printFlatBlock(stats, expr) @@ -1158,7 +1163,7 @@ object SourceCode { case ThisType(tp) => tp match { - case tp: TypeRef if !tp.typeSymbol.flags.is(Flags.Object) => + case tp: TypeRef if !tp.typeSymbol.flags.is(Flags.Module) => printFullClassName(tp) this += highlightTypeDef(".this") case TypeRef(prefix, name) if name.endsWith("$") => diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala index 147e9e3b3f02..c502cbb37f11 100644 --- a/library/src/scala/quoted/Quotes.scala +++ b/library/src/scala/quoted/Quotes.scala @@ -3888,7 +3888,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Is this symbol `abstract` */ def Abstract: Flags - /** Was this symbol generated by Scala compiler */ + /** Is this generated by Scala compiler. + * Coresponds to ACC_SYNTHETIC in the JVM. + */ def Artifact: Flags /** Is this symbol `case` */ @@ -3903,6 +3905,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Is this symbol a type parameter marked as covariant `+` */ def Covariant: Flags + /** Is a declared, but not defined member */ + def Deferred: Flags + /** The empty set of flags */ def EmptyFlags: Flags @@ -3933,12 +3938,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Is this symbol `implicit` */ def Implicit: Flags + /** Is an infix method or type */ + def Infix: Flags + /** Is this symbol `inline` */ def Inline: Flags /** Is this symbol defined in a Java class */ def JavaDefined: Flags + /** Is implemented as a Java static */ + def JavaStatic: Flags + /** Is this symbol `lazy` */ def Lazy: Flags @@ -3948,14 +3959,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Is this symbol marked as a macro. An inline method containing toplevel splices */ def Macro: Flags - /** Is this symbol a module class */ - def ModuleClass: Flags + def Method: Flags + + /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */ + def Module: Flags /** Is this symbol a `var` (when used on a ValDef) */ def Mutable: Flags - /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */ - def Object: Flags + /** Trait does not have fields or initialization code. */ + def NoInits: Flags /** Is this symbol `opaque` */ def Opaque: Flags @@ -4001,6 +4014,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Is this symbol a trait */ def Trait: Flags + + /** Is a transparent inline method or trait */ + def Transparent: Flags + } /** Makes extension methods on `Flags` available without any imports */ diff --git a/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala b/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala index d1e0c4e78275..c60c1c5426aa 100644 --- a/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala +++ b/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala @@ -21,7 +21,7 @@ trait ClassLikeSupport: private val placeholderModifier = JMap(ctx.sourceSet -> KotlinModifier.Empty.INSTANCE) private def kindForClasslike(sym: Symbol): Kind = - if sym.flags.is(Flags.Object) then Kind.Object + if sym.flags.is(Flags.Module) then Kind.Object else if sym.flags.is(Flags.Trait) then Kind.Trait else if sym.flags.is(Flags.Enum) then Kind.Enum else Kind.Class @@ -125,9 +125,9 @@ trait ClassLikeSupport: .map { _ => parseMethod(dd.symbol, kind = Kind.Given(getGivenInstance(dd).map(_.asSignature), None)) } - + case dd: DefDef if !dd.symbol.isHiddenByVisibility && dd.symbol.isExported => - val exportedTarget = dd.rhs.collect { + val exportedTarget = dd.rhs.collect { case a: Apply => a.fun.asInstanceOf[Select] case s: Select => s } @@ -137,7 +137,7 @@ trait ClassLikeSupport: case Select(qualifier: Ident, _) => qualifier.tpe.typeSymbol.normalizedName }.getOrElse("instance") val dri = dd.rhs.collect { - case s: Select if s.symbol.isDefDef => s.symbol.dri + case s: Select if s.symbol.isDefDef => s.symbol.dri }.orElse(exportedTarget.map(_.qualifier.tpe.typeSymbol.dri)) Some(parseMethod(dd.symbol, kind = Kind.Exported).withOrigin(Origin.ExportedFrom(s"$instanceName.$functionName", dri))) @@ -151,7 +151,7 @@ trait ClassLikeSupport: && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum)) && vd.symbol.isGiven => val classDef = Some(vd.tpt.tpe).flatMap(_.classSymbol.map(_.tree.asInstanceOf[ClassDef])) - Some(classDef.filter(_.symbol.flags.is(Flags.ModuleClass)).fold[Member](parseValDef(vd))(parseGivenClasslike(_))) + Some(classDef.filter(_.symbol.flags.is(Flags.Module)).fold[Member](parseValDef(vd))(parseGivenClasslike(_))) case vd: ValDef if !isSyntheticField(vd.symbol) && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum)) => Some(parseValDef(vd)) @@ -261,7 +261,7 @@ trait ClassLikeSupport: ) def parseClasslike(classDef: ClassDef, signatureOnly: Boolean = false): DClass = classDef match - case c: ClassDef if classDef.symbol.flags.is(Flags.Object) => parseObject(c, signatureOnly) + case c: ClassDef if classDef.symbol.flags.is(Flags.Module) => parseObject(c, signatureOnly) case c: ClassDef if classDef.symbol.flags.is(Flags.Enum) => parseEnum(c, signatureOnly) case clazz => DClass(classDef)(signatureOnly = signatureOnly) diff --git a/scala3doc/src/dotty/dokka/tasty/NameNormalizer.scala b/scala3doc/src/dotty/dokka/tasty/NameNormalizer.scala index a5ffdf900910..5c5443345fdc 100644 --- a/scala3doc/src/dotty/dokka/tasty/NameNormalizer.scala +++ b/scala3doc/src/dotty/dokka/tasty/NameNormalizer.scala @@ -6,7 +6,7 @@ trait NameNormalizer { self: TastyParser => import qctx.reflect._ extension (s: Symbol) def normalizedName: String = { val withoutGivenPrefix = if s.isGiven then s.name.stripPrefix("given_") else s.name - val withoutObjectSuffix = if s.flags.is(Flags.Object) then withoutGivenPrefix.stripSuffix("$") else withoutGivenPrefix + val withoutObjectSuffix = if s.flags.is(Flags.Module) then withoutGivenPrefix.stripSuffix("$") else withoutGivenPrefix val constructorNormalizedName = if s.isClassConstructor then "this" else withoutObjectSuffix constructorNormalizedName } diff --git a/scala3doc/src/dotty/dokka/tasty/SymOps.scala b/scala3doc/src/dotty/dokka/tasty/SymOps.scala index a33b8c4494af..dbf025288bd6 100644 --- a/scala3doc/src/dotty/dokka/tasty/SymOps.scala +++ b/scala3doc/src/dotty/dokka/tasty/SymOps.scala @@ -78,7 +78,7 @@ class SymOps[Q <: Quotes](val q: Q): def getCompanionSymbol: Option[Symbol] = Some(sym.companionClass).filter(_.exists) - def isCompanionObject: Boolean = sym.flags.is(Flags.Object) && sym.companionClass.exists + def isCompanionObject: Boolean = sym.flags.is(Flags.Module) && sym.companionClass.exists def isGiven: Boolean = sym.flags.is(Flags.Given) diff --git a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala index 4e079931256e..a37dc87087d4 100644 --- a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala +++ b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala @@ -38,7 +38,7 @@ trait SyntheticsSupport: def getAllMembers: List[Symbol] = hackGetAllMembers(using qctx)(s) def isSyntheticField(c: Symbol) = - c.flags.is(Flags.CaseAccessor) || (c.flags.is(Flags.Object) && !c.flags.is(Flags.Given)) + c.flags.is(Flags.CaseAccessor) || (c.flags.is(Flags.Module) && !c.flags.is(Flags.Given)) def isValidPos(pos: Position) = pos.exists && pos.start != pos.end diff --git a/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala b/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala index 6b9f7123ddf6..bd9af2b0e629 100644 --- a/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala +++ b/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala @@ -101,7 +101,7 @@ trait MemberLookup { ) def hackResolveModule(s: Symbol): Symbol = - if s.flags.is(Flags.Object) then s.moduleClass else s + if s.flags.is(Flags.Module) then s.moduleClass else s val matched = syms.find(matches) diff --git a/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala b/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala index 34c3f1538af1..310ae4a04ca4 100644 --- a/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala +++ b/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala @@ -86,7 +86,7 @@ class LookupTestCases[Q <: Quotes](val q: Quotes) { case class Sym(symbol: q.reflect.Symbol) { def fld(name: String) = def hackResolveModule(s: q.reflect.Symbol): q.reflect.Symbol = - if s.flags.is(q.reflect.Flags.Object) then s.moduleClass else s + if s.flags.is(q.reflect.Flags.Module) then s.moduleClass else s Sym(hackResolveModule(symbol.field(name))) def fun(name: String) = val List(sym) = symbol.method(name) diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala index 1c5058a785e8..35271be86f67 100644 --- a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala +++ b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala @@ -71,7 +71,7 @@ class Interpreter[Q <: Quotes & Singleton](using q0: Q) extends TreeInterpreter[ // FIXME not necesarly static jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol) case _ => - if (fn.symbol.flags.is(Flags.Object)) + if (fn.symbol.flags.is(Flags.Module)) jvmReflection.loadModule(fn.symbol.moduleClass) else jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)