A modern programming language that makes developers happier.

kotlinlang

it's possible in a compiler plugin to create a field with a name like `foo&lt;bar` even though it won't be legal in the JVM (and fail later). Java has things like `Character.isJavaIdentifierPart()`, is there anything/reference we should have for targeting other platforms like JS for ensuring names are safely escaped?

`isJavaIdentifier` is stricter than what the JVM will accept

as far as what Kotlin/JS will accept, that has changed <https://youtrack.jetbrains.com/issue/KT-31799>

that's a feature request and I was more looking for what the current allowances are as a reference for plugins generating declaration names

sure, but I am looking for a specific reference (code, list of characters, etc) of what characters are legal

<https://github.com/JetBrains/kotlin/blob/master/core/compiler.common/src/org/jetbrains/kotlin/name/Name.java#L65> the Kotlin compiler itself is very lenient

I am specifically looking for what specific targets allow, not what the `Name` class allows

I dunno then. it seems to me that the compiler allows any valid Name through, and then might blow up later

right, that's my point and why I am asking if there's docs or references. This question was more for the compiler folks at JB

JVM is a lot more lenient compared to dex/Dalvik/ART

<https://source.android.com/docs/core/runtime/dex-format#simplename> for dex

<https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.2> for the JVM

I think the best for JS is this? <https://developer.mozilla.org/en-US/docs/Glossary/Identifier>

(letter codepoints, 0-9 digits, `$` or `_`; cannot start with a digit)

pretty similar to Java source identifiers, but Kotlin/JS will handle identifiers outside of that range too (with `-XXLanguage:+JsAllowInvalidCharsIdentifiersEscaping` or by default in newer versions), so JS's own identifier restrictions don't necessarily apply

I'm not aware of any restrictions on native or wasm identifiers, unless you are trying to export those symbols for interop…

looks like the JS ones are a subset of what java allows so that's convenient

For JVM we have <https://github.com/JetBrains/kotlin/blob/c6f9120e56d438202b75e8d289cbfabfbab14a14/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInvalidAndDangerousCharactersChecker.kt#L4|FirJvmInvalidAndDangerousCharactersChecker> which uses <https://github.com/JetBrains/kotlin/blob/c6f9120e56d438202b75e8d289cbfabfbab14a14/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmNamesChecker.kt#L4|FirJvmNamesChecker>. This is driven by the JVM spec and a few additional characters that we have found to be dangerous.

In the JS space, it's a little more complicated. The entry point is <https://github.com/JetBrains/kotlin/blob/c6f9120e56d438202b75e8d289cbfabfbab14a14/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt#L4|FirJsExportDeclarationChecker> which uses `validateDeclarationOnConsumableName` to check against a couple special and reserved keywords and makes sure the sanitized name is the same as the original name. Sanitization is driven by the ES 5.1 spec: <https://262.ecma-international.org/5.1/#sec-7.6>.

Native has <https://github.com/JetBrains/kotlin/blob/c6f9120e56d438202b75e8d289cbfabfbab14a14/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeIdentifierChecker.kt#L4|FirNativeIdentifierChecker>.

Sadly, I haven't found anything which unifies all of these that compiler plugin could use.