Merge pull request #6764 from dotty-staging/remove-symlits

smarter · web-flow · commit 1bfd25b9a219 · 2019-06-29T15:58:15.000+02:00
Remove support for symbol literal singleton types
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1461,7 +1461,9 @@ object desugar {
       case PolyFunction(targs, body) =>
         makePolyFunction(targs, body) orElse tree
       case SymbolLit(str) =>
-        Literal(Constant(scala.Symbol(str)))
+        Apply(
+          ref(defn.ScalaSymbolClass.companionModule.termRef),
+          Literal(Constant(str)) :: Nil)
       case InterpolatedString(id, segments) =>
         val strs = segments map {
           case ts: Thicket => ts.trees.head
diff --git a/compiler/src/dotty/tools/dotc/core/Constants.scala b/compiler/src/dotty/tools/dotc/core/Constants.scala
@@ -22,7 +22,6 @@ object Constants {
   final val ClazzTag   = 12
   // For supporting java enumerations inside java annotations (see ClassfileParser)
   final val EnumTag    = 13
-  final val ScalaSymbolTag = 14
 
   class Constant(val value: Any, val tag: Int) extends printing.Showable with Product1[Any] {
     import java.lang.Double.doubleToRawLongBits
@@ -52,7 +51,6 @@ object Constants {
       case NullTag        => defn.NullType
       case ClazzTag       => defn.ClassType(typeValue)
       case EnumTag        => defn.EnumType(symbolValue)
-      case ScalaSymbolTag => defn.ScalaSymbolType
     }
 
     /** We need the equals method to take account of tags as well as values.
@@ -193,7 +191,6 @@ object Constants {
 
     def typeValue: Type     = value.asInstanceOf[Type]
     def symbolValue: Symbol = value.asInstanceOf[Symbol]
-    def scalaSymbolValue: scala.Symbol = value.asInstanceOf[scala.Symbol]
 
     /**
      * Consider two `NaN`s to be identical, despite non-equality
@@ -241,7 +238,6 @@ object Constants {
     def apply(x: Char): Constant         = new Constant(x, CharTag)
     def apply(x: Type): Constant         = new Constant(x, ClazzTag)
     def apply(x: Symbol): Constant       = new Constant(x, EnumTag)
-    def apply(x: scala.Symbol): Constant = new Constant(x, ScalaSymbolTag)
     def apply(value: Any): Constant      =
       new Constant(value,
         value match {
@@ -258,7 +254,6 @@ object Constants {
           case x: Char         => CharTag
           case x: Type         => ClazzTag
           case x: Symbol       => EnumTag
-          case x: scala.Symbol => ScalaSymbolTag
         }
       )
 
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -694,9 +694,6 @@ class Definitions {
 
   @threadUnsafe lazy val ScalaSymbolType: TypeRef                    = ctx.requiredClassRef("scala.Symbol")
   def ScalaSymbolClass(implicit ctx: Context): ClassSymbol          = ScalaSymbolType.symbol.asClass
-  def ScalaSymbolModule(implicit ctx: Context): Symbol         = ScalaSymbolClass.companionModule
-    @threadUnsafe lazy val ScalaSymbolModule_applyR: TermRef                  = ScalaSymbolModule.requiredMethodRef(nme.apply, List(StringType))
-    def ScalaSymbolModule_apply(implicit ctx: Context): Symbol = ScalaSymbolModule_applyR.symbol
 
   @threadUnsafe lazy val DynamicType: TypeRef                 = ctx.requiredClassRef("scala.Dynamic")
   def DynamicClass(implicit ctx: Context): ClassSymbol = DynamicType.symbol.asClass
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -140,7 +140,6 @@ Standard-Section: "ASTs" TopLevelStat*
                   NULLconst                                                        -- null
                   CLASSconst            Type                                       -- classOf[Type]
                   ENUMconst             Path                                       -- An enum constant
-                  SYMBOLconst           NameRef                                    -- A symbol literal (todo: drop?)
 
   Type          = Path                                                             -- Paths represent both types and terms
                   TYPEREFdirect         sym_ASTRef                                 -- A reference to a local symbol (without a prefix). Reference is to definition node of symbol.
@@ -250,7 +249,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 14
+  val MajorVersion: Int = 15
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
@@ -352,7 +351,6 @@ object TastyFormat {
   final val STRINGconst = 64
   final val IMPORTED = 65
   final val RENAMED = 66
-  final val SYMBOLconst = 67
 
   // Cat. 3:    tag AST
 
@@ -462,7 +460,7 @@ object TastyFormat {
   /** Useful for debugging */
   def isLegalTag(tag: Int): Boolean =
     firstSimpleTreeTag <= tag && tag <= EXPORTED ||
-    firstNatTreeTag <= tag && tag <= SYMBOLconst ||
+    firstNatTreeTag <= tag && tag <= RENAMED ||
     firstASTTreeTag <= tag && tag <= BOUNDED ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
     firstLengthTreeTag <= tag && tag <= MATCHtpt ||
@@ -636,7 +634,6 @@ object TastyFormat {
     case SUPER => "SUPER"
     case CLASSconst => "CLASSconst"
     case ENUMconst => "ENUMconst"
-    case SYMBOLconst => "SYMBOLconst"
     case SINGLETONtpt => "SINGLETONtpt"
     case SUPERtype => "SUPERtype"
     case TERMREFin => "TERMREFin"
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -130,9 +130,6 @@ class TreePickler(pickler: TastyPickler) {
     case EnumTag =>
       writeByte(ENUMconst)
       pickleType(c.symbolValue.termRef)
-    case ScalaSymbolTag =>
-      writeByte(SYMBOLconst)
-      pickleName(c.scalaSymbolValue.name.toTermName)
   }
 
   def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -266,8 +266,6 @@ class TreeUnpickler(reader: TastyReader,
         Constant(readType())
       case ENUMconst =>
         Constant(readTermRef().termSymbol)
-      case SYMBOLconst =>
-        Constant(scala.Symbol(readName().toString))
     }
 
     /** Read a type */
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -209,8 +209,8 @@ object Tokens extends TokensCommon {
   final val allTokens: TokenSet = tokenRange(minToken, maxToken)
 
   final val simpleLiteralTokens: TokenSet =
-    tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, QUOTEID) // TODO: drop QUOTEID when symbol literals are gone
-  final val literalTokens: TokenSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
+    tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE)
+  final val literalTokens: TokenSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, QUOTEID, NULL)  // TODO: drop QUOTEID when symbol literals are gone
 
   final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -490,7 +490,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
     case CharTag => literalText(s"'${escapedChar(const.charValue)}'")
     case LongTag => literalText(const.longValue.toString + "L")
     case EnumTag => literalText(const.symbolValue.name.toString)
-    case ScalaSymbolTag => literalText("'" + const.scalaSymbolValue.name.toString)
     case _ => literalText(String.valueOf(const.value))
   }
 
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala
@@ -1444,8 +1444,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
     if (x.tag == Constants.StringTag) Some(x.stringValue) else None
   def matchConstant_ClassTag(x: Constant): Option[Type] =
     if (x.tag == Constants.ClazzTag) Some(x.typeValue) else None
-  def matchConstant_Symbol(x: Constant): Option[scala.Symbol] =
-    if (x.tag == Constants.ScalaSymbolTag) Some(x.scalaSymbolValue) else None
 
   def Constant_Unit_apply(): Constant = Constants.Constant(())
   def Constant_Null_apply(): Constant = Constants.Constant(null)
@@ -1459,7 +1457,6 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Constant_Double_apply(x: Double): Constant = Constants.Constant(x)
   def Constant_String_apply(x: String): Constant = Constants.Constant(x)
   def Constant_ClassTag_apply(x: scala.reflect.ClassTag[_]): Constant = Constants.Constant(x)
-  def Constant_Symbol_apply(x: scala.Symbol): Constant = Constants.Constant(x)
 
   //
   // SYMBOLS
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -386,10 +386,6 @@ object Erasure {
         tree.withType(tree.typeOpt)
       else if (tree.const.tag == Constants.ClazzTag)
         Literal(Constant(erasure(tree.const.typeValue)))
-      else if (tree.const.tag == Constants.ScalaSymbolTag)
-        ref(defn.ScalaSymbolModule)
-          .select(defn.ScalaSymbolModule_apply)
-          .appliedTo(Literal(Constant(tree.const.scalaSymbolValue.name)))
       else
         super.typedLiteral(tree)
 
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
@@ -121,9 +121,9 @@ SimpleLiteral     ::=  [‘-’] integerLiteral
                     |  booleanLiteral
                     |  characterLiteral
                     |  stringLiteral
-                    |  symbolLiteral
 Literal           ::=  SimpleLiteral
                     |  processedStringLiteral
+                    |  symbolLiteral
                     |  ‘null’
 
 QualId            ::=  id {‘.’ id}
diff --git a/library/src/scala/tasty/reflect/ConstantOps.scala b/library/src/scala/tasty/reflect/ConstantOps.scala
@@ -141,16 +141,5 @@ trait ConstantOps extends Core {
       def unapply(constant: Constant): Option[Type] =
         kernel.matchConstant_ClassTag(constant)
     }
-
-    /** Module of scala.Symbol literals */
-    object Symbol {
-      /** scala.Symbol literal */
-      def apply(x: scala.Symbol): Constant =
-        kernel.Constant_Symbol_apply(x)
-
-      /** Extractor for scala.Symbol literals */
-      def unapply(constant: Constant): Option[scala.Symbol] =
-        kernel.matchConstant_Symbol(constant)
-    }
   }
 }
diff --git a/library/src/scala/tasty/reflect/Kernel.scala b/library/src/scala/tasty/reflect/Kernel.scala
@@ -1184,7 +1184,6 @@ trait Kernel {
   def matchConstant_Double(constant: Constant): Option[Double]
   def matchConstant_String(constant: Constant): Option[String]
   def matchConstant_ClassTag(constant: Constant): Option[Type]
-  def matchConstant_Symbol(constant: Constant): Option[scala.Symbol]
 
   def Constant_Unit_apply(): Constant
   def Constant_Null_apply(): Constant
@@ -1198,7 +1197,6 @@ trait Kernel {
   def Constant_Double_apply(x: Double): Constant
   def Constant_String_apply(x: String): Constant
   def Constant_ClassTag_apply(x: scala.reflect.ClassTag[_]): Constant
-  def Constant_Symbol_apply(x: scala.Symbol): Constant
 
   //
   // SYMBOLS
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
@@ -301,7 +301,6 @@ trait Printers
         case Constant.Double(value) => this += "Constant.Double(" += value += ")"
         case Constant.String(value) => this += "Constant.String(\"" += value += "\")"
         case Constant.ClassTag(value) => this += "Constant.ClassTag(" += value += ")"
-        case Constant.Symbol(value) => this += "Constant.Symbol('" += value.name += ")"
       }
 
       def visitType(x: TypeOrBounds): Buffer = x match {
@@ -1390,8 +1389,6 @@ trait Printers
         case Constant.ClassTag(v) =>
           this += "classOf"
           inSquare(printType(v))
-        case Constant.Symbol(v) =>
-          this += highlightLiteral("'" + v.name)
       }
 
       def printTypeOrBoundsTree(tpt: Tree)(implicit elideThis: Option[Symbol] = None): Buffer = tpt match {
diff --git a/tests/neg/singletons.scala b/tests/neg/singletons.scala
@@ -5,5 +5,7 @@ object Test {
 
   val n: null = null // error: Null is not a legal singleton type
 
+  val sym: 'sym = 'sym // error: an identifier expected, but quoted identifier found
+
   val foo: s"abc" = "abc"  // error: not a legal singleton type
 }
diff --git a/tests/neg/sip23-symbols.scala b/tests/neg/sip23-symbols.scala

Original file line number	Diff line number	Diff line change
`@@ -130,9 +130,6 @@ class TreePickler(pickler: TastyPickler) {`
`130`	`130`	`case EnumTag =>`
`131`	`131`	`writeByte(ENUMconst)`
`132`	`132`	`pickleType(c.symbolValue.termRef)`
`133`		`- case ScalaSymbolTag =>`
`134`		`- writeByte(SYMBOLconst)`
`135`		`- pickleName(c.scalaSymbolValue.name.toTermName)`
`136`	`133`	`}`
`137`	`134`
`138`	`135`	`def pickleType(tpe0: Type, richTypes: Boolean = false)(implicit ctx: Context): Unit = {`
Original file line number	Diff line number	Diff line change
`@@ -266,8 +266,6 @@ class TreeUnpickler(reader: TastyReader,`
`266`	`266`	`Constant(readType())`
`267`	`267`	`case ENUMconst =>`
`268`	`268`	`Constant(readTermRef().termSymbol)`
`269`		`- case SYMBOLconst =>`
`270`		`- Constant(scala.Symbol(readName().toString))`
`271`	`269`	`}`
`272`	`270`
`273`	`271`	`/** Read a type */`
Original file line number	Diff line number	Diff line change
`@@ -490,7 +490,6 @@ class PlainPrinter(_ctx: Context) extends Printer {`
`490`	`490`	`case CharTag => literalText(s"'${escapedChar(const.charValue)}'")`
`491`	`491`	`case LongTag => literalText(const.longValue.toString + "L")`
`492`	`492`	`case EnumTag => literalText(const.symbolValue.name.toString)`
`493`		`- case ScalaSymbolTag => literalText("'" + const.scalaSymbolValue.name.toString)`
`494`	`493`	`case _ => literalText(String.valueOf(const.value))`
`495`	`494`	`}`
`496`	`495`