Warn if empty template name has trailing colon

This is to guard the edge case `object X_:` where the user
may or may not have intended colon syntax. The next line does
not tell us, since it may be indented yet not nested. Therefore,
any empty template with a suspicious name will warn. Non-empty
templates are given a pass even if written `object X_: :`.

Author: som-snytt

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -44,6 +44,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     extends MemberDef {
     type ThisTree[+T <: Untyped] <: Trees.NameTree[T] & Trees.MemberDef[T] & ModuleDef
     def withName(name: Name)(using Context): ModuleDef = cpy.ModuleDef(this)(name.toTermName, impl)
+    def isBackquoted: Boolean = hasAttachment(Backquoted)
   }
 
   /** An untyped template with a derives clause. Derived parents are added to the end

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

@@ -89,7 +89,7 @@ object NameOps {
           // Ends with operator characters
           while i >= 0 && isOperatorPart(name(i)) do i -= 1
           if i == -1 then return true
-          // Optionnally prefixed with alpha-numeric characters followed by `_`
+          // Optionally prefixed with alpha-numeric characters followed by `_`
           if name(i) != '_' then return false
           while i >= 0 && isIdentifierPart(name(i)) do i -= 1
           i == -1

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3784,6 +3784,18 @@ object Parsers {
 /* -------- DEFS ------------------------------------------- */
 
     def finalizeDef(md: MemberDef, mods: Modifiers, start: Int): md.ThisTree[Untyped] =
+      def checkName(): Unit =
+        def checkName(name: Name): Unit =
+          if !name.isEmpty
+          && !Chars.isOperatorPart(name.firstCodePoint) // warn a_: not ::
+          && name.endsWith(":")
+          then
+            report.warning(AmbiguousTemplateName(md), md.namePos)
+        md match
+        case md @ TypeDef(name, impl: Template) if impl.body.isEmpty && !md.isBackquoted => checkName(name)
+        case md @ ModuleDef(name, impl) if impl.body.isEmpty && !md.isBackquoted => checkName(name)
+        case _ =>
+      checkName()
       md.withMods(mods).setComment(in.getDocComment(start))
 
     type ImportConstr = (Tree, List[ImportSelector]) => Tree
@@ -4233,14 +4245,15 @@ object Parsers {
 
     /** ClassDef ::= id ClassConstr TemplateOpt
      */
-    def classDef(start: Offset, mods: Modifiers): TypeDef = atSpan(start, nameStart) {
-      classDefRest(start, mods, ident().toTypeName)
-    }
+    def classDef(start: Offset, mods: Modifiers): TypeDef =
+      val td = atSpan(start, nameStart):
+        classDefRest(mods, ident().toTypeName)
+      finalizeDef(td, mods, start)
 
-    def classDefRest(start: Offset, mods: Modifiers, name: TypeName): TypeDef =
+    def classDefRest(mods: Modifiers, name: TypeName): TypeDef =
       val constr = classConstr(if mods.is(Case) then ParamOwner.CaseClass else ParamOwner.Class)
       val templ = templateOpt(constr)
-      finalizeDef(TypeDef(name, templ), mods, start)
+      TypeDef(name, templ)
 
     /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses
      */
@@ -4258,11 +4271,15 @@ object Parsers {
 
     /** ObjectDef       ::= id TemplateOpt
      */
-    def objectDef(start: Offset, mods: Modifiers): ModuleDef = atSpan(start, nameStart) {
-      val name = ident()
-      val templ = templateOpt(emptyConstructor)
-      finalizeDef(ModuleDef(name, templ), mods, start)
-    }
+    def objectDef(start: Offset, mods: Modifiers): ModuleDef =
+      val md = atSpan(start, nameStart):
+        val nameIdent = termIdent()
+        val templ = templateOpt(emptyConstructor)
+        ModuleDef(nameIdent.name.asTermName, templ)
+          .tap: md =>
+            if nameIdent.isBackquoted then
+              md.pushAttachment(Backquoted, ())
+      finalizeDef(md, mods, start)
 
     private def checkAccessOnly(mods: Modifiers, caseStr: String): Modifiers =
       // We allow `infix` and `into` on `enum` definitions.
@@ -4494,7 +4511,7 @@ object Parsers {
               Template(constr, parents, Nil, EmptyValDef, Nil)
             else if !newSyntaxAllowed
                 || in.token == WITH && tparams.isEmpty && vparamss.isEmpty
-                // if new syntax is still allowed and there are parameters, they mist be new style conditions,
+                // if new syntax is still allowed and there are parameters, they must be new style conditions,
                 // so old with-style syntax would not be allowed.
             then
               withTemplate(constr, parents)

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -235,6 +235,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case CannotInstantiateQuotedTypeVarID // errorNumber: 219
   case DefaultShadowsGivenID // errorNumber: 220
   case RecurseWithDefaultID // errorNumber: 221
+  case AmbiguousTemplateNameID // errorNumber: 222
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -13,8 +13,10 @@ import parsing.Tokens
 import printing.Highlighting.*
 import printing.Formatting
 import ErrorMessageID.*
-import ast.Trees
+import ast.Trees.*
 import ast.desugar
+import ast.tpd
+import ast.untpd
 import config.{Feature, MigrationVersion, ScalaVersion}
 import transform.patmat.Space
 import transform.patmat.SpaceEngine
@@ -25,9 +27,6 @@ import typer.Inferencing
 import scala.util.control.NonFatal
 import StdNames.nme
 import Formatting.{hl, delay}
-import ast.Trees.*
-import ast.untpd
-import ast.tpd
 import scala.util.matching.Regex
 import java.util.regex.Matcher.quoteReplacement
 import cc.CaptureSet.IdentityCaptRefMap
@@ -3109,7 +3108,7 @@ class MissingImplicitArgument(
   def msg(using Context): String =
 
     def formatMsg(shortForm: String)(headline: String = shortForm) = arg match
-      case arg: Trees.SearchFailureIdent[?] =>
+      case arg: SearchFailureIdent[?] =>
         arg.tpe match
           case _: NoMatchingImplicits => headline
           case tpe: SearchFailureType =>
@@ -3741,3 +3740,8 @@ final class RecurseWithDefault(name: Name)(using Context) extends TypeMsg(Recurs
     i"Recursive call used a default argument for parameter $name."
   override protected def explain(using Context): String =
     "It's more explicit to pass current or modified arguments in a recursion."
+
+class AmbiguousTemplateName(tree: NamedDefTree[?])(using Context) extends SyntaxMsg(AmbiguousTemplateNameID):
+  override protected def msg(using Context) = i"name `${tree.name}` should be enclosed in backticks"
+  override protected def explain(using Context): String =
+    "Names with trailing operator characters may fuse with a subsequent colon if not set off by backquotes or spaces."

tests/neg/i16072.scala

@@ -0,0 +1,3 @@
+
+enum Oops_:
+  case Z // error // error expected { and }

tests/warn/i16072.check

@@ -0,0 +1,24 @@
+-- Warning: tests/warn/i16072.scala:4:2 --------------------------------------------------------------------------------
+4 |  def x = 1 // warn too far right
+  |  ^
+  |  Line is indented too far to the right, or a `{` or `:` is missing
+-- [E222] Syntax Warning: tests/warn/i16072.scala:3:7 ------------------------------------------------------------------
+3 |object Hello_: // warn colon in name without backticks because the body is empty
+  |       ^^^^^^^
+  |       name `Hello_:` should be enclosed in backticks
+  |
+  | longer explanation available when compiling with `-explain`
+-- Deprecation Warning: tests/warn/i16072.scala:12:10 ------------------------------------------------------------------
+12 |object :: : // warn deprecated colon without backticks for operator name
+   |          ^
+   |          `:` after symbolic operator is deprecated; use backticks around operator instead
+-- Warning: tests/warn/i16072.scala:21:2 -------------------------------------------------------------------------------
+21 |  def y = 1 // warn
+   |  ^
+   |  Line is indented too far to the right, or a `{` or `:` is missing
+-- [E222] Syntax Warning: tests/warn/i16072.scala:20:6 -----------------------------------------------------------------
+20 |class Uhoh_: // warn
+   |      ^^^^^^
+   |      name `Uhoh_:` should be enclosed in backticks
+   |
+   | longer explanation available when compiling with `-explain`

tests/warn/i16072.scala

@@ -0,0 +1,26 @@
+//> using options -deprecation
+
+object Hello_: // warn colon in name without backticks because the body is empty
+  def x = 1 // warn too far right
+
+object Goodbye_: : // nowarn if non-empty body without nit-picking about backticks
+  def x = 2
+
+object `Byte_`:
+  def x = 3
+
+object :: : // warn deprecated colon without backticks for operator name
+  def x = 42
+
+object ::: // nowarn
+
+object Braces_: { // nowarn because body is non-empty with an EmptyTree
+}
+
+class Uhoh_: // warn
+  def y = 1 // warn
+
+@main def hello =
+  println(Byte_)
+  println(Hello_:) // apparently user did forget a colon, see https://youforgotapercentagesignoracolon.com/
+  println(x)