Fix #2334: Require at least one digit after '.' in floating point literals

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -634,7 +634,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         toDenot(sym)(shiftedContext).isStatic(shiftedContext)
       }
 
-    def isStaticConstructor: Boolean = (isStaticMember && isClassConstructor) || (sym.name eq core.Names.STATIC_CONSTRUCTOR)
+    def isStaticConstructor: Boolean = (isStaticMember && isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
 
 
     // navigation

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -137,7 +137,7 @@ class Definitions {
   }
 
   private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
-    newSymbol(cls, name.encode, flags | Method, info).asTerm
+    newSymbol(cls, name, flags | Method, info).asTerm
 
   private def enterMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
     newMethod(cls, name, info, flags).entered
@@ -301,7 +301,7 @@ class Definitions {
   lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context) = ScalaPredefModuleRef.symbol
 
-    lazy val Predef_ConformsR = ScalaPredefModule.requiredClass("$less$colon$less").typeRef
+    lazy val Predef_ConformsR = ScalaPredefModule.requiredClass("<:<").typeRef
     def Predef_Conforms(implicit ctx: Context) = Predef_ConformsR.symbol
     lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef("$conforms")
     def Predef_conforms(implicit ctx: Context) = Predef_conformsR.symbol

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1194,7 +1194,7 @@ object Denotations {
           select(recur(prefix), wrap(selector))
         case qn @ AnyQualifiedName(prefix, _) =>
           recur(prefix, n => wrap(qn.info.mkString(n).toTermName))
-        case path: SimpleTermName =>
+        case path: SimpleName =>
           def recurSimple(len: Int, wrap: TermName => Name): Denotation = {
             val point = path.lastIndexOf('.', len - 1)
             val selector = wrap(path.slice(point + 1, len).asTermName)

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -52,8 +52,8 @@ object NameOps {
   implicit class NameDecorator[N <: Name](val name: N) extends AnyVal {
     import nme._
 
-    def testSimple(f: SimpleTermName => Boolean): Boolean = name match {
-      case name: SimpleTermName => f(name)
+    def testSimple(f: SimpleName => Boolean): Boolean = name match {
+      case name: SimpleName => f(name)
       case name: TypeName => name.toTermName.testSimple(f)
       case _ => false
     }
@@ -83,7 +83,7 @@ object NameOps {
     def isOpAssignmentName: Boolean = name match {
       case raw.NE | raw.LE | raw.GE | EMPTY =>
         false
-      case name: SimpleTermName =>
+      case name: SimpleName =>
         name.length > 0 && name.last == '=' && name.head != '=' && isOperatorPart(name.head)
       case _ =>
         false
@@ -100,8 +100,10 @@ object NameOps {
      *  it is also called from the backend.
      */
     def stripModuleClassSuffix: N = likeSpaced {
-      val semName =
-        if (name.isSimple && name.endsWith("$")) name.unmangleClassName else name
+      val semName = name.toTermName match {
+        case name: SimpleName if name.endsWith("$") => name.unmangleClassName
+        case _ => name
+      }
       semName.exclude(ModuleClassName)
     }
 
@@ -126,15 +128,24 @@ object NameOps {
 
     def errorName: N = likeSpaced(name ++ nme.ERROR)
 
+    /** Map variance value -1, +1 to 0, 1 */
+    private def varianceToNat(v: Int) = (v + 1) / 2
+
+    /** Map 0, 1 to variance value -1, +1 */
+    private def natToVariance(n: Int) = n * 2 - 1
 
     /** Name with variance prefix: `+` for covariant, `-` for contravariant */
-    def withVariance(v: Int): N =
-      likeSpaced { VariantName(name.exclude(VariantName).toTermName, v) }
+    def withVariance(v: Int): N = {
+      val underlying = name.exclude(VariantName)
+      likeSpaced(
+          if (v == 0) underlying
+          else VariantName(underlying.toTermName, varianceToNat(v)))
+    }
 
     /** The variance as implied by the variance prefix, or 0 if there is
      *  no variance prefix.
      */
-    def variance = name.collect { case VariantName(_, n) => n }.getOrElse(0)
+    def variance = name.collect { case VariantName(_, n) => natToVariance(n) }.getOrElse(0)
 
     def freshened(implicit ctx: Context): N = likeSpaced {
       name.toTermName match {
@@ -227,19 +238,19 @@ object NameOps {
     def compactified(implicit ctx: Context): TermName = termName(compactify(name.toString))
 
     def unmangleClassName: N = name.toTermName match {
-      case name: SimpleTermName
+      case name: SimpleName
       if name.endsWith(str.MODULE_SUFFIX) && !nme.falseModuleClassNames.contains(name) =>
         likeSpaced(name.dropRight(str.MODULE_SUFFIX.length).moduleClassName)
       case _ => name
     }
 
     def unmangle(kind: NameKind): N = likeSpaced {
       name rewrite {
-        case unmangled: SimpleTermName =>
+        case unmangled: SimpleName =>
           kind.unmangle(unmangled)
         case ExpandedName(prefix, last) =>
           kind.unmangle(last) rewrite {
-            case kernel: SimpleTermName =>
+            case kernel: SimpleName =>
               ExpandedName(prefix, kernel)
           }
       }