Deprecate using Scala 3 hard keywords as identifiers

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -1277,6 +1277,8 @@ self =>
     def ident(skipIt: Boolean): Name = (
       if (isIdent) {
         val name = in.name.encode
+        if (in.token != BACKQUOTED_IDENT && scala3Keywords.contains(name))
+          deprecationWarning(in.offset, s"Wrap `$name` in backticks to use it as an identifier, it will become a keyword in Scala 3.", "2.13.7")
         in.nextToken()
         name
       }

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -1526,6 +1526,8 @@ trait Scanners extends ScannersCommon {
 
   final val softModifierNames = Set(nme.open, nme.infix)
 
+  final val scala3Keywords = Set(nme.`enum`, nme.`export`, nme.`given`)
+
 // Token representation ----------------------------------------------------
 
   /** Returns the string representation of given token. */

src/reflect/scala/reflect/internal/StdNames.scala

@@ -675,6 +675,11 @@ trait StdNames {
     // Scala 3 import syntax
     val as: NameType              = nameType("as")
 
+    // Scala 3 hard keywords
+    val `enum`: NameType          = nameType("enum")
+    val `export`: NameType        = nameType("export")
+    val `given`: NameType         = nameType("given")
+
     // Scala 3 soft keywords
     val infix: NameType           = nameType("infix")
     val open: NameType            = nameType("open")

src/reflect/scala/reflect/io/ZipArchive.scala

@@ -240,11 +240,11 @@ final class FileZipArchive(file: JFile, release: Option[String]) extends ZipArch
     val root = new DirEntry(RootEntry)
     dirs.put(RootEntry, root)
     val zipFile = openZipFile()
-    val enum    = zipFile.entries()
+    val entries = zipFile.entries()
 
     try {
-      while (enum.hasMoreElements) {
-        val zipEntry = enum.nextElement
+      while (entries.hasMoreElements) {
+        val zipEntry = entries.nextElement
         if (!zipEntry.getName.startsWith("META-INF/versions/")) {
           if (!zipEntry.isDirectory) {
             val dir = getDir(dirs, zipEntry)

src/reflect/scala/reflect/runtime/JavaMirrors.scala

@@ -195,9 +195,9 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       object AnnotationClass { def unapply(x: jClass[_]) = x.isAnnotation }
 
       object ConstantArg {
-        def enumToSymbol(enum: Enum[_]): Symbol = {
-          val staticPartOfEnum = classToScala(enum.getClass).companionSymbol
-          staticPartOfEnum.info.declaration(TermName(enum.name))
+        def enumToSymbol(`enum`: Enum[_]): Symbol = {
+          val staticPartOfEnum = classToScala(`enum`.getClass).companionSymbol
+          staticPartOfEnum.info.declaration(TermName(`enum`.name))
         }
 
         def unapply(schemaAndValue: (jClass[_], Any)): Option[Any] = schemaAndValue match {

test/files/neg/scala3-keywords.check

@@ -0,0 +1,21 @@
+scala3-keywords.scala:13: warning: Wrap `enum` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+  val enum: Int = 1 // error
+      ^
+scala3-keywords.scala:14: warning: Wrap `export` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+  val export: Int = 1 // error
+      ^
+scala3-keywords.scala:15: warning: Wrap `given` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+  val given: Int = 1 // error
+      ^
+scala3-keywords.scala:16: warning: Wrap `given` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+  def foo(given: Int) = {} // error
+          ^
+scala3-keywords.scala:17: warning: Wrap `export` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+  def bla[export <: Int] = {} // error
+          ^
+scala3-keywords.scala:19: warning: Wrap `enum` in backticks to use it as an identifier, it will become a keyword in Scala 3.
+class enum // error
+      ^
+error: No warnings can be incurred under -Werror.
+6 warnings
+1 error

test/files/neg/scala3-keywords.scala

@@ -0,0 +1,19 @@
+// scalac: -deprecation -Xfatal-warnings
+//
+class A {
+  val `enum`: Int = 1
+  val `export`: Int = 1
+  val `given`: Int = 1
+  def foo(`given`: Int) = {}
+  def bla[`export` <: Int] = {
+    class `enum`
+  }
+}
+class B {
+  val enum: Int = 1 // error
+  val export: Int = 1 // error
+  val given: Int = 1 // error
+  def foo(given: Int) = {} // error
+  def bla[export <: Int] = {} // error
+}
+class enum // error

test/files/run/reflection-java-crtp/Main_2.scala

@@ -1,8 +1,8 @@
 object Test extends App {
   import scala.reflect.runtime.universe._
-  val enum = typeOf[JavaSimpleEnumeration_1].baseClasses(1).asClass
+  val `enum` = typeOf[JavaSimpleEnumeration_1].baseClasses(1).asClass
   // make sure that the E's in Enum<E extends Enum<E>> are represented by the same symbol
-  val e1 = enum.typeParams(0).asType
+  val e1 = `enum`.typeParams(0).asType
   val TypeBounds(_, TypeRef(_, _, List(TypeRef(_, e2: TypeSymbol, _)))) = e1.info
   println(e1, e2, e1 eq e2)
 }

test/junit/scala/collection/FactoriesTest.scala

@@ -215,11 +215,11 @@ class FactoriesTest {
       im.BitSet(1, 2, 3)
     )
 
-    object enum extends Enumeration {
+    object `enum` extends Enumeration {
       val x, y, z = Value
     }
 
-    val enumValues = enum.values
+    val enumValues = `enum`.values
 
     sortedFactoryFromIterableOnceReturnsSameReference(SortedSet, im.SortedSet)(enumValues)