common/org.js.lolifamily.minecraftmcp.repl/MaskingClassLoader

MaskingClassLoader

class MaskingClassLoader : URLClassLoader

Classloader for the REPL's Kotlin scripting stack.

It hosts the entire Kotlin scripting stack (kotlin-compiler-embeddable + scripting-* + stdlib + reflect + script-runtime) plus the REPL impl's own Kotlin classes, on a self-managed URLClassLoader that lives OFF the FML/securejarhandler module path. That is mandatory on NeoForge: putting kotlin-compiler-embeddable on the module path makes securejarhandler throw "Invalid package name: 'native' is not a Java identifier" at boot (the compiler ships a package org.jetbrains.kotlin.native.interop, and native is a Java keyword).

The compiler (org.jetbrains.kotlin.*), the shaded intellij/etc. inside compiler-embeddable, and the REPL impl classes under ...repl.impl.* are ALWAYS child-first (masking-owned). The JDK, MC, and the mod's own non-impl classes are ALWAYS parent-first so they keep a single shared identity with the game loader.

The kotlin RUNTIME (`kotlin.*` stdlib/reflect) is version-regime dependent

A REPL snippet must exchange kotlin objects (lambdas = Function0, Pair, Sequence, …) with the game's mods, which use the GAME loader's kotlin. If the masking loader defines its OWN copy of those classes, a snippet value is a DIFFERENT class from the mod's parameter type → LinkageError. One shared kotlin identity is the only fully-safe unification, and it needs the versions to line up — hence Regime, overridable with mcp.kotlin.regime=auto|share|split.

A feature that would otherwise need a JVM agent

Because every masking-owned class is defined right here in findClass, this loader is the single door those classes' bytes come through — which makes java.lang.instrument unnecessary for anything scoped to them. So the preload working-set capture works on a JVM launched WITHOUT -Djdk.attach.allowAttachSelf / -XX:+EnableDynamicAgentLoading: definedClassNames answers "what did this loader define?" from its own bookkeeping.

The live-patch engine (Patches.onEnter/onExit) still needs the agent and still dies without those flags: it retransforms already-loaded net.minecraft.* classes on the GAME loader and injects a jar into the bootstrap loader — neither is something a classloader can do for itself.

Constructors

MaskingClassLoader

constructor(urls: Array<URL>, parent: ClassLoader)

Creates the masking loader over urls, delegating to parent (the game loader).

Types

Regime

enum Regime

Kotlin-identity regime, decided once from (our bundled kotlin C, the parent/game kotlin P).

SnippetLoader

class SnippetLoader : ClassLoader

The whole snippet chain in ONE hop: game-identity names to the game loader, the rest to masking, and only a miss in both retries a hybrid server's plugins (PluginBridge).

Properties

assertionLock

val assertionLock: Any

classAssertionStatus

open var classAssertionStatus: Map<String, Boolean>

classes

private val classes: ArrayList<Class<out Any>>

classLoaderValueMap

private open var classLoaderValueMap: ConcurrentHashMap<out Any, out Any>

closeables

private val closeables: WeakHashMap<Closeable, Void>

defaultAssertionStatus

private open var defaultAssertionStatus: Boolean

defaultDomain

private val defaultDomain: ProtectionDomain

defined

private val defined: Set<String>

libraries

private val libraries: NativeLibraries

name

val name: String

nameAndId

private val nameAndId: String

nocerts

private val nocerts: Array<Certificate>

ownKotlin

val ownKotlin: Int

package2certs

private val package2certs: ConcurrentHashMap<String, Array<Certificate>>

packageAssertionStatus

private open var packageAssertionStatus: Map<String, Boolean>

packages

private val packages: ConcurrentHashMap<String, NamedPackage>

parallelLockMap

private val parallelLockMap: ConcurrentHashMap<String, Any>

parent

val parent: ClassLoader

parentKotlin

private val parentKotlin: Int

pdcache

private val pdcache: Map<SecureClassLoader.CodeSourceKey, ProtectionDomain>

regime

private val regime: MaskingClassLoader.Regime

scl

private open var scl: ClassLoader

snippetLoader

private open var snippetLoader: ClassLoader

ucp

private val ucp: URLClassPath

unnamedModule

val unnamedModule: Module

V2_0

private val V2_0: Int = 131072

Packed 2.0.0 — the 2.4.

Functions

addClass

open fun addClass(c: Class<out Any>)

addURL

protected open fun addURL(url: URL)

clearAssertionStatus

open fun clearAssertionStatus()

open fun close()

createOrGetClassLoaderValueMap

open fun createOrGetClassLoaderValueMap(): ConcurrentHashMap<out Any, out Any>

decideRegime

private open fun decideRegime(ours: Int, parent: Int): MaskingClassLoader.Regime

defineClass

protected fun defineClass(name: String, b: Array<Byte>, off: Int, len: Int, cs: CodeSource): Class<out Any>

defineClass0

open fun defineClass0(p: ClassLoader, p1: Class<out Any>, p2: String, p3: Array<Byte>, p4: Int, p5: Int, p6: ProtectionDomain, p7: Boolean, p8: Int, p9: Any): Class<out Any>

defineClass1

open fun defineClass1(p: ClassLoader, p1: String, p2: Array<Byte>, p3: Int, p4: Int, p5: ProtectionDomain, p6: String): Class<out Any>

defineClass2

open fun defineClass2(p: ClassLoader, p1: String, p2: ByteBuffer, p3: Int, p4: Int, p5: ProtectionDomain, p6: String): Class<out Any>

definedClassNames

open fun definedClassNames(): Set<String>

Every binary name this loader has DEFINED (not merely delegated), for the preload working-set capture.

definePackage

protected open fun definePackage(name: String, man: Manifest, url: URL): Package

desiredAssertionStatus

open fun desiredAssertionStatus(className: String): Boolean

findBootstrapClassOrNull

open fun findBootstrapClassOrNull(name: String): Class<out Any>

findClass

protected open fun findClass(name: String): Class<out Any>

Every masking-owned class is defined HERE (see the class doc for what that buys), which is also what makes every successfully defined name recordable for definedClassNames.

findLibrary

protected open fun findLibrary(libname: String): String

findLoadedClass

protected fun findLoadedClass(name: String): Class<out Any>

findNative

open fun findNative(loader: ClassLoader, clazz: Class<out Any>, entryName: String, javaName: String): Long

findResource

open fun findResource(name: String): URL

findResources

open fun findResources(name: String): Enumeration<URL>

findSystemClass

protected fun findSystemClass(name: String): Class<out Any>

getBuiltinAppClassLoader

open fun getBuiltinAppClassLoader(): ClassLoader

getBuiltinPlatformClassLoader

open fun getBuiltinPlatformClassLoader(): ClassLoader

getClassLoader

open fun getClassLoader(caller: Class<out Any>): ClassLoader

getClassLoadingLock

protected open fun getClassLoadingLock(className: String): Any

getDefinedPackage

fun getDefinedPackage(name: String): Package

getDefinedPackages

fun getDefinedPackages(): Array<Package>

getPackage

protected open fun getPackage(name: String): Package

getPackages

protected open fun getPackages(): Array<Package>

getPermissions

protected open fun getPermissions(codesource: CodeSource): PermissionCollection

getPlatformClassLoader

open fun getPlatformClassLoader(): ClassLoader

getResource

open fun getResource(name: String): URL

Unconditionally child-first, unlike getResource's parent-first default — and unlike loadClass, which stays parent-first for whole namespaces.

getResourceAsStream

open fun getResourceAsStream(name: String): InputStream

getResources

open fun getResources(name: String): Enumeration<URL>

getSystemClassLoader

open fun getSystemClassLoader(): ClassLoader

getSystemResource

open fun getSystemResource(name: String): URL

getSystemResourceAsStream

open fun getSystemResourceAsStream(name: String): InputStream

getSystemResources

open fun getSystemResources(name: String): Enumeration<URL>

getURLs

open fun getURLs(): Array<URL>

initSystemClassLoader

open fun initSystemClassLoader(): ClassLoader

isKotlinRuntime

open fun isKotlinRuntime(n: String): Boolean

The kotlin RUNTIME namespace that SHARE_ALL delegates to the parent and SPLIT redirects to the game: the stdlib + reflect, NOT the compiler (org.jetbrains.kotlin.*, always masking-owned).

isRegisteredAsParallelCapable

fun isRegisteredAsParallelCapable(): Boolean

kotlinVersionOf

private open fun kotlinVersionOf(cl: ClassLoader): Int

KotlinVersion.CURRENT as seen through cl, packed into one int (major<<16 | minor<<8 | patch); -1 if that loader has no kotlin — reflective, so a no-kotlin game yields -1 instead of a link error.

loadClass

open fun loadClass(name: String): Class<out Any>

protected open fun loadClass(name: String, resolve: Boolean): Class<out Any>

loadLibrary

open fun loadLibrary(fromClass: Class<out Any>, file: File): NativeLibrary

mustDelegateToParent

private open fun mustDelegateToParent(n: String): Boolean

The REPL impl (script host + template) MUST come from our urls so it links the scripting API we own; everything else that needs a single shared identity with the game/JDK goes to the parent.

name

fun name(): String

nameAndId

open fun nameAndId(): String

nativeLibrariesFor

open fun nativeLibrariesFor(loader: ClassLoader): NativeLibraries

newInstance

open fun newInstance(urls: Array<URL>, parent: ClassLoader): URLClassLoader

packages

open fun packages(): Stream<Package>

parentApiVersion

open fun parentApiVersion(): String

P as "major.minor" for the snippet compiler's -api-version/-language-version in SPLIT; null in SHARE_ALL, where the two kotlins are one and no pin is needed.

probeKotlinVersion