Closes #57. ```ruby ἍBB = 1 defined?(ἍBB) # MRI: "constant" before: nil Object.const_defined?(:ἍBB) # MRI: true before: false ``` `LookupIdent` decided constant-ness with ```go if c := s[0]; c >= 'A' && c <= 'Z' { ``` which reads a **byte**. For any multibyte character `s[0]` is a UTF-8 lead byte of 0xC2 or more, never in `'A'..'Z'`, so every non-ASCII name was classified as a local variable: the assignment created a local and no constant existed afterwards. ## The rule is not the lexer's parse.y assumes `tCONSTANT` **provisionally** and downgrades it afterwards: ```c if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER; ``` (parse.y:10453 at v4.0.9), so the decision belongs to the ID system. It is made in `rb_sym_constant_char_p` (symbol.c:508-542), and it has **five** branches, not two: | first character | verdict | |---|---| | ASCII | `ISUPPER` | | non-ASCII, `rb_enc_isupper` | constant | | non-ASCII, `rb_enc_islower` | local | | titlecase letter, Unicode encoding | **constant** | | anything else — a caseless letter | **local** | Go's `unicode.IsUpper` is that isupper and `unicode.IsTitle` that titlecase property, so `IsConstStart` is those five lines. ## ⛔ The two branches that make "not lowercase" the wrong shortcut - a **titlecase** letter is a constant although `unicode.IsUpper` reports false for it: upstream tests the Onigmo `titlecaseletter` property explicitly, after isupper and islower have both said no; - a **caseless** letter — CJK, Hebrew, Arabic — starts a **local variable**. So neither clause can be written as "not lower", which is the obvious simplification and is wrong in both directions. Measured against `/usr/bin/ruby` through `Object.const_defined?(name.to_sym)`, which raises `NameError` for a name that is not a constant name — that is `rb_is_const_name` (symbol.c:1287), the same predicate parse.y consults: ``` ASCII upper A -> CONSTANT name Lt DZ digr ǅ -> CONSTANT name ASCII lower a -> not a constant name Lt DZE digr ǈ -> CONSTANT name ASCII under _ -> not a constant name Lo CJK 日 -> not a constant name Lu GREEK Ἅ -> CONSTANT name Lo HEBREW א -> not a constant name Lu CYRILLIC Д -> CONSTANT name Lo ARABIC ب -> not a constant name Ll GREEK mu μ -> not a constant name Lu TURKISH I İ -> CONSTANT name ``` ## Measured end to end This is one of two halves. ruby/spec's `language/variables_spec.rb` has ```ruby it 'parses a non-ASCII upcased character as a constant identifier' do -> { eval("def test\n ἍBB = 1\nend") }.should.raise(SyntaxError, /dynamic constant assignment/) end ``` which needs this classification **and** a `dynamic constant assignment` refusal in the consumer's compiler (go-embedded-ruby/ruby#862). Neither half passes the example alone. With both — an rbgo built from that branch with a local `replace` onto this one — the example disappears from the failure list, and the file's only remaining failures are the two belonging to another PR there. ## Tests `token/const_start_test.go` walks the measured table character by character, asserting `IsConstStart` and `LookupIdent` agree, plus the degenerate inputs (empty, invalid UTF-8) and a control that the ASCII path and the keyword lookup still work — a version of `IsConstStart` that always answered false would otherwise pass every negative row. `nonascii_constant_test.go` checks the parse-level consequence: `ἍBB = 1` is an `*ast.ConstAssign` and `μ = 1` an `*ast.Assign`, and a non-ASCII constant works in every position an ASCII one does — read, assign, op-assign, scope, scoped name, masgn target, class and module name, superclass, pattern, singleton definee, receiver and rescue class. README: the feature list now states the rule, since "constants" alone did not say which names are ones. Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Commits

Commits on Nov 1, 2026

token: a non-ASCII uppercase letter starts a CONSTANT, not a local