Tweak macro name representation (#572)

The current representation for macro names is a bit peculiar. When
the parser encounters `@a`, it treats `@` as notation for the
macrocall and then `reset_node!`'s (which itself may be considered
a bit of a code smell) the `a` to a special MacroName
token kind that (when translated back to julia Expr) implicitly
adds back the `@`. Things get even more peculiar with `@var"a"`
where only the token inside the string macro gets reset.

One particular consequence of this is JuliaLang/julia#58885,
because our translation back to Expr does not check the RAW_STRING_FLAG
(whereas the translation for K"Identifier" does).

A second issue is that we currently parse `@A.b.c` and `A.b.@c` to the
same SyntaxTree (of course the green tree is different). We aren't
currently being super precise about the required invariants for syntax
trees, but in general it would be desirable for non-trivia notation
(like `@`) to be precisely recoverable from the tree, which is not
the case here. This is especially annoying because there are syntax
cases that are errors for one of these, but not the other (e.g.
`@A.b.$` is an error, but `A.B.@$` is allowed). Now, I think the wisdom
of some of those syntax choices can be debated, but that is the situation
we face.

So this PR tries to clean that all up a bit by:
- Replacing the terminal K"MacroName" by a non-terminal K"macro_name".
  With this form, `@A.c` parses as `(macro_name (. A c))` while
  `A.@c` parses as `(. A (macro_name c))`.
- (In particular the `@` notation is now always associated with the
   macro_name).
- Emitting the dots in `@..` and `@...` as direct identifier tokens
  rather than having to reset them back.
- Adjusting everything else accordingly.

Partially written by Claude Code, though it had some trouble with
the actual code changes.

Author: Keno

src/integration/expr.jl

@@ -246,8 +246,6 @@ function node_to_expr(cursor, source, txtbuf::Vector{UInt8}, txtbuf_offset::UInt
                         val isa UInt128 ? Symbol("@uint128_str") :
                         Symbol("@big_str")
                 return Expr(:macrocall, GlobalRef(Core, macname), nothing, str)
-            elseif k == K"MacroName" && val === Symbol("@.")
-                return Symbol("@__dot__")
             else
                 return val
             end
@@ -296,7 +294,31 @@ function node_to_expr(cursor, source, txtbuf::Vector{UInt8}, txtbuf_offset::UInt
                          nodehead, source)
 end
 
-# Split out from the above for codesize reasons, to avoid specialization on multiple
+function adjust_macro_name!(retexpr::Union{Expr, Symbol}, k::Kind)
+    if !(retexpr isa Symbol)
+        retexpr::Expr
+        # can happen for incomplete or errors
+        (length(retexpr.args) < 2 || retexpr.head != :(.)) && return retexpr
+        arg2 = retexpr.args[2]
+        isa(arg2, QuoteNode) || return retexpr
+        retexpr.args[2] = QuoteNode(adjust_macro_name!(arg2.value, k))
+        return retexpr
+    end
+    if k == K"macro_name"
+        if retexpr === Symbol(".")
+            return Symbol("@__dot__")
+        else
+            return Symbol("@$retexpr")
+        end
+    elseif k == K"macro_name_cmd"
+        return Symbol("@$(retexpr)_cmd")
+    else
+        @assert k == K"macro_name_str"
+        return Symbol("@$(retexpr)_str")
+    end
+end
+
+# Split out from `node_to_expr` for codesize reasons, to avoid specialization on multiple
 # tree types.
 @noinline function _node_to_expr(retexpr::Expr, loc::LineNumberNode,
                                  srcrange::UnitRange{UInt32},
@@ -312,6 +334,8 @@ end
         # However, errors can add additional errors tokens which we represent
         # as e.g. `Expr(:var, ..., Expr(:error))`.
         return retexpr.args[1]
+    elseif k in KSet"macro_name macro_name_cmd macro_name_str"
+        return adjust_macro_name!(retexpr.args[1], k)
     elseif k == K"?"
         retexpr.head = :if
     elseif k == K"op=" && length(args) == 3
@@ -331,7 +355,7 @@ end
     elseif k == K"macrocall"
         if length(args) >= 2
             a2 = args[2]
-            if @isexpr(a2, :macrocall) && kind(firstchildhead) == K"CmdMacroName"
+            if @isexpr(a2, :macrocall) && kind(firstchildhead) == K"macro_name_cmd"
                 # Fix up for custom cmd macros like foo`x`
                 args[2] = a2.args[3]
             end

src/julia/kinds.jl

@@ -194,15 +194,6 @@ register_kinds!(JuliaSyntax, 0, [
     "BEGIN_IDENTIFIERS"
         "Identifier"
         "Placeholder" # Used for empty catch variables, and all-underscore identifiers in lowering
-        # Macro names are modelled as special kinds of identifiers because the full
-        # macro name may not appear as characters in the source: The `@` may be
-        # detached from the macro name as in `@A.x` (ugh!!), or have a _str or _cmd
-        # suffix appended.
-        "BEGIN_MACRO_NAMES"
-            "MacroName"
-            "StringMacroName"
-            "CmdMacroName"
-        "END_MACRO_NAMES"
     "END_IDENTIFIERS"
 
     "BEGIN_KEYWORDS"
@@ -1048,6 +1039,10 @@ register_kinds!(JuliaSyntax, 0, [
         "iteration"
         "comprehension"
         "typed_comprehension"
+        # Macro names
+        "macro_name"
+        "macro_name_cmd"
+        "macro_name_str"
         # Container for a single statement/atom plus any trivia and errors
         "wrapper"
     "END_SYNTAX_KINDS"
@@ -1111,10 +1106,6 @@ const _nonunique_kind_names = Set([
     K"String"
     K"Char"
     K"CmdString"
-
-    K"MacroName"
-    K"StringMacroName"
-    K"CmdMacroName"
 ])
 
 """
@@ -1201,7 +1192,6 @@ is_prec_unicode_ops(x) = K"BEGIN_UNICODE_OPS" <= kind(x) <= K"END_UNICODE_OPS"
 is_prec_pipe_lt(x)     = kind(x) == K"<|"
 is_prec_pipe_gt(x)     = kind(x) == K"|>"
 is_syntax_kind(x)      = K"BEGIN_SYNTAX_KINDS"<= kind(x) <= K"END_SYNTAX_KINDS"
-is_macro_name(x)       = K"BEGIN_MACRO_NAMES" <= kind(x) <= K"END_MACRO_NAMES"
 is_syntactic_assignment(x) = K"BEGIN_SYNTACTIC_ASSIGNMENTS" <= kind(x) <= K"END_SYNTACTIC_ASSIGNMENTS"
 
 function is_string_delim(x)

src/julia/literal_parsing.jl

@@ -430,12 +430,6 @@ function parse_julia_literal(txtbuf::Vector{UInt8}, head::SyntaxHead, srcrange)
             Symbol(normalize_identifier(val_str))
     elseif k == K"error"
         ErrorVal()
-    elseif k == K"MacroName"
-        Symbol("@$(normalize_identifier(val_str))")
-    elseif k == K"StringMacroName"
-        Symbol("@$(normalize_identifier(val_str))_str")
-    elseif k == K"CmdMacroName"
-        Symbol("@$(normalize_identifier(val_str))_cmd")
     elseif is_syntax_kind(head)
         nothing
     elseif is_keyword(k)