diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala index 2acfc4cf86e3..0b93f04eee21 100644 --- a/compiler/src/dotty/tools/dotc/ast/untpd.scala +++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala @@ -457,7 +457,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo { def New(tpt: Tree, argss: List[List[Tree]])(using Context): Tree = ensureApplied(argss.foldLeft(makeNew(tpt))(Apply(_, _))) - /** A new expression with constrictor and possibly type arguments. See + /** A new expression with constructor and possibly type arguments. See * `New(tpt, argss)` for details. */ def makeNew(tpt: Tree)(using Context): Tree = { diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala index 1615679a036e..6016e876f384 100644 --- a/compiler/src/dotty/tools/dotc/core/Annotations.scala +++ b/compiler/src/dotty/tools/dotc/core/Annotations.scala @@ -2,7 +2,7 @@ package dotty.tools package dotc package core -import Symbols.*, Types.*, Contexts.*, Constants.*, Phases.* +import Symbols.*, Types.*, Contexts.*, Constants.*, Decorators.*, Names.*, Phases.* import ast.tpd, tpd.* import util.Spans.Span import printing.{Showable, Printer} @@ -43,6 +43,29 @@ object Annotations { def argumentConstantString(i: Int)(using Context): Option[String] = for (case Constant(s: String) <- argumentConstant(i)) yield s + def argsForSuper(parent: Symbol)(using Context): List[Tree] = + val symbol = this.symbol + val args = arguments + if symbol == parent then args + else if symbol.asClass.superClass == parent then + val params: List[Name] = parent.primaryConstructor.paramSymss.headOrNil.map(_.name) + val subArgs: Map[Name, Tree] = symbol.primaryConstructor.paramSymss.headOrNil.map(_.name).zip(args).toMap + val superArgs: Map[Name, Tree] = + symbol.annotations.collect { + case annot if annot.matches(defn.SuperArgMetaAnnot) => + val List(Literal(Constant(param: String)), value) = annot.arguments: @unchecked + param.toTermName -> value + }.toMap + val superFwdArgs: Map[Name, Name] = + symbol.annotations.collect { + case annot if annot.matches(defn.SuperFwdArgMetaAnnot) => + val List(Literal(Constant(param: String)), Literal(Constant(subParam: String))) = annot.arguments: @unchecked + param.toTermName -> subParam.toTermName + }.toMap + val argsForSuper = params.map(p => superArgs.getOrElse(p, subArgs(superFwdArgs(p)))) + if params.lengthCompare(argsForSuper) == 0 then argsForSuper else Nil + else Nil + /** The tree evaluation is in progress. */ def isEvaluating: Boolean = false @@ -148,6 +171,11 @@ object Annotations { override def isEvaluated: Boolean = myTree.isInstanceOf[Tree @unchecked] } + class DeferredSym(sym: Symbol, treeFn: Context ?=> Tree) + extends LazyAnnotation: + protected var mySym: Symbol | (Context ?=> Symbol) | Null = sym + protected var myTree: Tree | (Context ?=> Tree) | Null = ctx ?=> treeFn(using ctx) + class DeferredSymAndTree(symFn: Context ?=> Symbol, treeFn: Context ?=> Tree) extends LazyAnnotation: protected var mySym: Symbol | (Context ?=> Symbol) | Null = ctx ?=> symFn(using ctx) @@ -214,10 +242,7 @@ object Annotations { /** Create an annotation where the tree is computed lazily. */ def deferred(sym: Symbol)(treeFn: Context ?=> Tree): Annotation = - new LazyAnnotation { - protected var myTree: Tree | (Context ?=> Tree) | Null = ctx ?=> treeFn(using ctx) - protected var mySym: Symbol | (Context ?=> Symbol) | Null = sym - } + DeferredSym(sym, treeFn) /** Create an annotation where the symbol and the tree are computed lazily. */ def deferredSymAndTree(symFn: Context ?=> Symbol)(treeFn: Context ?=> Tree): Annotation = diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala index 96a2d45db80d..c87d06e7e78f 100644 --- a/compiler/src/dotty/tools/dotc/core/Decorators.scala +++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala @@ -228,6 +228,9 @@ object Decorators { else xs.reduceLeft(op) + extension [T](xss: List[List[T]]) + def headOrNil: List[T] = if xss.isEmpty then Nil else xss.head + extension [T, U](xss: List[List[T]]) def nestedMap(f: T => U): List[List[U]] = xss match case xs :: xss1 => xs.map(f) :: xss1.nestedMap(f) diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala index f89bc8691e2d..17884cb30b2d 100644 --- a/compiler/src/dotty/tools/dotc/core/Definitions.scala +++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala @@ -1069,6 +1069,7 @@ class Definitions { @tu lazy val UntrackedCapturesAnnot: ClassSymbol = requiredClass("scala.caps.untrackedCaptures") @tu lazy val UseAnnot: ClassSymbol = requiredClass("scala.caps.use") @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile") + @tu lazy val LanguageFeatureMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.languageFeature") @tu lazy val BeanGetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanGetter") @tu lazy val BeanSetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanSetter") @@ -1078,6 +1079,10 @@ class Definitions { @tu lazy val SetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.setter") @tu lazy val CompanionClassMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.companionClass") @tu lazy val CompanionMethodMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.companionMethod") + @tu lazy val DefaultArgMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.defaultArg") + @tu lazy val SuperArgMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.superArg") + @tu lazy val SuperFwdArgMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.superFwdArg") + @tu lazy val ShowAsInfixAnnot: ClassSymbol = requiredClass("scala.annotation.showAsInfix") @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface") @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName") diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala index 2179fae8cb3f..cccfcf5ec02f 100644 --- a/compiler/src/dotty/tools/dotc/typer/Typer.scala +++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala @@ -2840,8 +2840,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer for (annot <- mdef.mods.annotations) val annot1 = typedAnnotation(annot)(using annotCtx) checkAnnotApplicable(annot1, sym) - if Annotations.annotClass(annot1) == defn.NowarnAnnot then + val annotCls = annotClass(annot1) + if annotCls == defn.NowarnAnnot then registerNowarn(annot1, mdef) + else if annotCls.derivesFrom(defn.NowarnAnnot) then + val nowarnArgs = Annotation(annot1).argsForSuper(defn.NowarnAnnot) + val annot2 = New(defn.NowarnAnnot.typeRef, nowarnArgs).withSpan(annot1.span) + registerNowarn(annot2, mdef) } def typedAnnotation(annot: untpd.Tree)(using Context): Tree = @@ -3120,6 +3125,28 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer case _ => ptrees + /* add `@superArg` / `@superFwdArg` to subclasses of concrete annotations, e.g., + * `@superArg("value", "cat=deprecation")` for `class nodep extends nowarn("cat=deprecation")` + * this is done by duplicating the untyped super arguments before type checking the super call, because the + * super call can be transformed by named/default arguments. to build the `@superArg` annotations, the super + * call is type checked using `typedAnnotation`, which uses Mode.ANNOTmode. */ + def promoteSuperArgs(parentTree: Tree, parent: Symbol, constr: DefDef) = + val supCls = cls.superClass + if !supCls.is(Abstract) + && supCls.derivesFrom(defn.AnnotationClass) + && supCls.primaryConstructor.paramSymss.sizeIs == 1 + then + val superAnnotArgs = tpd.allTermArguments(parentTree) + if superAnnotArgs.nonEmpty then + val ps = constr.termParamss.headOrNil.map(_.symbol).toSet + parent.primaryConstructor.paramSymss.headOrNil.lazyZip(superAnnotArgs).foreach: (p, arg) => + val key = Literal(Constant(p.name.toString)) + val annot = if ps(arg.symbol) then + Annotation(defn.SuperFwdArgMetaAnnot, List(key, Literal(Constant(arg.symbol.name.toString))), cls.span) + else + Annotation(defn.SuperArgMetaAnnot, List(key, arg), cls.span) + cls.addAnnotation(annot) + /** Checks if one of the decls is a type with the same name as class type member in selfType */ def classExistsOnSelf(decls: Scope, self: tpd.ValDef): Boolean = { val selfType = self.tpt.tpe @@ -3218,6 +3245,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer val firstParentTpe = parents1.head.tpe.dealias val firstParent = firstParentTpe.typeSymbol + if !ctx.isAfterTyper then promoteSuperArgs(parents1.head, firstParent, constr1) + checkEnumParent(cls, firstParent) if defn.ScalaValueClasses()(cls) && ctx.settings.YcompileScala2Library.value then diff --git a/library/src/scala/annotation/meta/defaultArg.scala b/library/src/scala/annotation/meta/defaultArg.scala new file mode 100644 index 000000000000..bc633200e57b --- /dev/null +++ b/library/src/scala/annotation/meta/defaultArg.scala @@ -0,0 +1,18 @@ +package scala.annotation +package meta + +/** + * This internal meta annotation is used by the compiler to support default annotation arguments. + * + * For an annotation definition `class ann(x: Int = defaultExpr) extends Annotation`, the compiler adds + * `@defaultArg(defaultExpr)` to the parameter `x`. This causes the syntax tree of `defaultExpr` to be + * stored in the classfile. + * + * When using a default annotation argument, the compiler can recover the syntax tree and insert it in the + * `AnnotationInfo`. + * + * For details, see `scala.reflect.internal.AnnotationInfos.AnnotationInfo`. + */ +@meta.param class defaultArg(arg: Any) extends StaticAnnotation { + def this() = this(null) +} diff --git a/library/src/scala/annotation/meta/superArg.scala b/library/src/scala/annotation/meta/superArg.scala new file mode 100644 index 000000000000..180608fa65c0 --- /dev/null +++ b/library/src/scala/annotation/meta/superArg.scala @@ -0,0 +1,22 @@ +package scala.annotation +package meta + +/** + * This internal annotation encodes arguments passed to annotation superclasses. Example: + * + * {{{ + * class a(x: Int) extends Annotation + * class b extends a(42) // the compiler adds `@superArg("x", 42)` to class b + * }}} + */ +class superArg(p: String, v: Any) extends StaticAnnotation + +/** + * This internal annotation encodes arguments passed to annotation superclasses. Example: + * + * {{{ + * class a(x: Int) extends Annotation + * class b(y: Int) extends a(y) // the compiler adds `@superFwdArg("x", "y")` to class b + * }}} + */ +class superFwdArg(p: String, n: String) extends StaticAnnotation diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala index 5db0cf96d9ef..f485290a6956 100644 --- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala +++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala @@ -21,6 +21,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: |""".stripMargin, """|superVisorStrategy: Int (commit: '') |super (commit: '') + |superArg(p: String, v: Any): superArg - scala.annotation.meta (commit: '') + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta (commit: '') |""".stripMargin, includeCommitCharacter = true ) @@ -78,6 +80,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: |""".stripMargin, """|superVisorStrategy: Int |super + |superArg(p: String, v: Any): superArg - scala.annotation.meta + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta |""".stripMargin ) @@ -98,6 +102,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: |""".stripMargin, """|superVisorStrategy: Int |super + |superArg(p: String, v: Any): superArg - scala.annotation.meta + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta |""".stripMargin ) @@ -118,6 +124,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: |""".stripMargin, """|superVisorStrategy: Int |super + |superArg(p: String, v: Any): superArg - scala.annotation.meta + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta |""".stripMargin ) @@ -135,6 +143,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: |} |""".stripMargin, """|super + |superArg(p: String, v: Any): superArg - scala.annotation.meta + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta |""".stripMargin ) @@ -392,6 +402,8 @@ class CompletionKeywordSuite extends BaseCompletionSuite: """.stripMargin, """|supervisorStrategy: Int |super + |superArg(p: String, v: Any): superArg - scala.annotation.meta + |superFwdArg(p: String, n: String): superFwdArg - scala.annotation.meta |""".stripMargin ) diff --git a/tests/warn/nowarn.check b/tests/warn/nowarn.check new file mode 100644 index 000000000000..da05507f2085 --- /dev/null +++ b/tests/warn/nowarn.check @@ -0,0 +1,103 @@ +-- [E002] Syntax Warning: tests/warn/nowarn.scala:88:25 ---------------------------------------------------------------- +88 | @nowarn("v") def f = try 1 // warn: try without catch/finally + | ^^^^^ + | A try without catch or finally is equivalent to putting + | its body in a block; no exceptions are handled. + |Matching filters for @nowarn or -Wconf: + | - id=E2 + | - name=EmptyCatchAndFinallyBlock + | + | longer explanation available when compiling with `-explain` +-- [E129] Potential Issue Warning: tests/warn/nowarn.scala:35:14 ------------------------------------------------------- +35 | val t7b = { 0; 1 } // warn: discard pure + | ^ + | A pure expression does nothing in statement position + | + | longer explanation available when compiling with `-explain` +-- [E190] Potential Issue Warning: tests/warn/nowarn.scala:41:18 ------------------------------------------------------- +41 | def f: Unit = 1 // warn: discard non-Unit + | ^ + | Discarded non-Unit value of type Int. Add `: Unit` to discard silently. + | + | longer explanation available when compiling with `-explain` +-- [E129] Potential Issue Warning: tests/warn/nowarn.scala:60:6 -------------------------------------------------------- +60 | 123 // warn: discard pure + | ^^^ + | A pure expression does nothing in statement position + | + | longer explanation available when compiling with `-explain` +-- [E190] Potential Issue Warning: tests/warn/nowarn.scala:71:4 -------------------------------------------------------- +71 | 123 // warn: discard non-Unit + | ^^^ + | Discarded non-Unit value of type Int. Add `: Unit` to discard silently. + | + | longer explanation available when compiling with `-explain` +-- [E190] Potential Issue Warning: tests/warn/nowarn.scala:79:4 -------------------------------------------------------- +79 | 123 // warn: discard non-Unit + | ^^^ + | Discarded non-Unit value of type Int. Add `: Unit` to discard silently. + | + | longer explanation available when compiling with `-explain` +-- [E129] Potential Issue Warning: tests/warn/nowarn.scala:94:14 ------------------------------------------------------- +94 | def g = { 1; 2 } // warn: discard pure + | ^ + | A pure expression does nothing in statement position + |Matching filters for @nowarn or -Wconf: + | - id=E129 + | - name=PureExpressionInStatementPosition + | + | longer explanation available when compiling with `-explain` +-- [E129] Potential Issue Warning: tests/warn/nowarn.scala:123:20 ------------------------------------------------------ +123 | @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn + | ^ + | A pure expression does nothing in statement position + | + | longer explanation available when compiling with `-explain` +-- Deprecation Warning: tests/warn/nowarn.scala:84:8 ------------------------------------------------------------------- +84 | a + dep // warn: deprecated + | ^^^ + | method dep in class C is deprecated since 1.2.3: message +-- Deprecation Warning: tests/warn/nowarn.scala:119:25 ----------------------------------------------------------------- +119 | @purr def t2 = new C().dep // warn // warn: unused @nowarn + | ^^^^^^^^^^^ + | method dep in class C is deprecated since 1.2.3: message +-- Warning: tests/warn/nowarn.scala:13:2 ------------------------------------------------------------------------------- +13 | @nowarn def t0 = { 0: @nowarn; 1 } // warn: outer @nowarn unused + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:14:28 ------------------------------------------------------------------------------ +14 | @nowarn def t1 = { 0: Int @nowarn; 1 } // warn: inner @nowarn unused, it covers the type, not the expression + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:15:2 ------------------------------------------------------------------------------- +15 | @nowarn @ann(dep) def t2 = 0 // warn: deprecation warning, @nowarn unused + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:23:2 ------------------------------------------------------------------------------- +23 | @nowarn class I1a { // warn: unused @nowarn + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:28:2 ------------------------------------------------------------------------------- +28 | @nowarn class I1b { // warn: unused @nowarn + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:45:2 ------------------------------------------------------------------------------- +45 | @nowarn object I3a { // warn: supresses nothing + | ^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:69:3 ------------------------------------------------------------------------------- +69 | @nowarn("msg=something else") // warn: unused + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:95:5 ------------------------------------------------------------------------------- +95 | @nowarn("v") def unused = 0 // warn: unused @nowarn + | ^^^^^^^^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:119:2 ------------------------------------------------------------------------------ +119 | @purr def t2 = new C().dep // warn // warn: unused @nowarn + | ^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn.scala:123:2 ------------------------------------------------------------------------------ +123 | @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn + | ^^^^^^ + | @nowarn annotation does not suppress any warnings diff --git a/tests/warn/nowarn.scala b/tests/warn/nowarn.scala new file mode 100644 index 000000000000..700b58b4d26d --- /dev/null +++ b/tests/warn/nowarn.scala @@ -0,0 +1,124 @@ +//> using options -deprecation -Wunused:nowarn + +// derived by tests/warn/nowarnRangePos.scala in scala/scala +// adding "slash slash warn" comments + +import scala.annotation._ + +class ann(a: Any) extends Annotation + +class C { + @deprecated("message", "1.2.3") def dep = 0 + + @nowarn def t0 = { 0: @nowarn; 1 } // warn: outer @nowarn unused + @nowarn def t1 = { 0: Int @nowarn; 1 } // warn: inner @nowarn unused, it covers the type, not the expression + @nowarn @ann(dep) def t2 = 0 // warn: deprecation warning, @nowarn unused +//@ann(dep: @nowarn) def t3 = 0 // silent (should be) + + @nowarn("cat=deprecation") def t4 = dep + + def t5 = (new I1a).m + + // completion forced by method above + @nowarn class I1a { // warn: unused @nowarn + @nowarn def m = { 1; 2 } + } + + // completion during type checking + @nowarn class I1b { // warn: unused @nowarn + @nowarn def m = { 1; 2 } + } + + def t6 = (new I1b).m + + @nowarn val t7a = { 0; 1 } + val t7b = { 0; 1 } // warn: discard pure + + @nowarn class I2a { + def f: Unit = 1 + } + class I2b { + def f: Unit = 1 // warn: discard non-Unit + } + + trait I3a + @nowarn object I3a { // warn: supresses nothing + def main(args: Array[String]) = () // the warning is only present in Scala 2 backend (see I3b) + } + trait I3b + object I3b { + def main(args: Array[String]) = () // main method in companion of trait triggers a warning in the backend + } + + def t8(): Unit = { + @nowarn + val a = { + 123 + () + } + val b = { + 123 // warn: discard pure + () + } + } + + @nowarn("msg=Discarded non-Unit value") + def t9a(): Unit = { + 123 + } + @nowarn("msg=something else") // warn: unused + def t9b(): Unit = { + 123 // warn: discard non-Unit + } + + @nowarn + def t10a(): Unit = { + 123 + } + def t10b(): Unit = { + 123 // warn: discard non-Unit + } + + def t11(): Unit = { + val a = dep: @nowarn + a + dep // warn: deprecated + } + + @nowarn object T12 { + @nowarn("v") def f = try 1 // warn: try without catch/finally + def g = { 1; 2 } + } + + @nowarn("verbose") object T13 { + @nowarn def f = try 1 + def g = { 1; 2 } // warn: discard pure + @nowarn("v") def unused = 0 // warn: unused @nowarn + } +} + +trait T { + @nowarn val t1 = { 0; 1 } +} + +class K extends T + +// ### unknown filter: site +//@nowarn("site=Uh.f.g") // would-be-warn: ? +//class Uh { +// def f = { +// def g(c: C) = c.dep // would-be-warn: ? +// } +//} + +object sd884 { + class nodep extends nowarn("cat=deprecation") + class purr extends nowarn("msg=pure expression does nothing") + + @nowarn("cat=deprecation") def t0 = new C().dep // no warn + @nodep def t1 = new C().dep // no warn + @purr def t2 = new C().dep // warn // warn: unused @nowarn + + @nowarn("msg=pure expression does nothing") def tZ = { 1; 2 } // no warn + @purr def t3 = { 1; 2 } // no warn + @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn +} diff --git a/tests/warn/nowarn_sd884_sep.check b/tests/warn/nowarn_sd884_sep.check new file mode 100644 index 000000000000..2c18096b4f68 --- /dev/null +++ b/tests/warn/nowarn_sd884_sep.check @@ -0,0 +1,19 @@ + +-- [E129] Potential Issue Warning: tests/warn/nowarn_sd884_sep/test_2.scala:16:20 -------------------------------------- +16 | @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn + | ^ + | A pure expression does nothing in statement position + | + | longer explanation available when compiling with `-explain` +-- Deprecation Warning: tests/warn/nowarn_sd884_sep/test_2.scala:12:25 ------------------------------------------------- +12 | @purr def t2 = new C().dep // warn // warn: unused @nowarn + | ^^^^^^^^^^^ + | method dep in class C is deprecated since 1.2.3: message +-- Warning: tests/warn/nowarn_sd884_sep/test_2.scala:12:2 -------------------------------------------------------------- +12 | @purr def t2 = new C().dep // warn // warn: unused @nowarn + | ^^^^^ + | @nowarn annotation does not suppress any warnings +-- Warning: tests/warn/nowarn_sd884_sep/test_2.scala:16:2 -------------------------------------------------------------- +16 | @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn + | ^^^^^^ + | @nowarn annotation does not suppress any warnings diff --git a/tests/warn/nowarn_sd884_sep/annots_1.scala b/tests/warn/nowarn_sd884_sep/annots_1.scala new file mode 100644 index 000000000000..6dd9dd0d5710 --- /dev/null +++ b/tests/warn/nowarn_sd884_sep/annots_1.scala @@ -0,0 +1,4 @@ +import scala.annotation._ + +class nodep extends nowarn("cat=deprecation") +class purr extends nowarn("msg=pure expression does nothing") diff --git a/tests/warn/nowarn_sd884_sep/test_2.scala b/tests/warn/nowarn_sd884_sep/test_2.scala new file mode 100644 index 000000000000..b371b36dd4f9 --- /dev/null +++ b/tests/warn/nowarn_sd884_sep/test_2.scala @@ -0,0 +1,17 @@ +//> using options -deprecation -Wunused:nowarn + +import scala.annotation._ + +class C { + @deprecated("message", "1.2.3") def dep = 0 +} + +object sd884 { + @nowarn("cat=deprecation") def t0 = new C().dep // no warn + @nodep def t1 = new C().dep // no warn + @purr def t2 = new C().dep // warn // warn: unused @nowarn + + @nowarn("msg=pure expression does nothing") def tZ = { 1; 2 } // no warn + @purr def t3 = { 1; 2 } // no warn + @nodep def t4 = { 1; 2 } // warn // warn: unused @nowarn +}