# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
Accessor: Defines an accessor method in a mixin, the method can be a getter (must return the field type and take no arguments) or a setter (must take an argument of the field type and return void).
AccessorGenerator: Base class for accessor generators
AccessorGeneratorField: Accessor generator for field accessors
AccessorGeneratorFieldGetter: Generator for instance field getters
AccessorGeneratorFieldSetter: Generator for field setters
AccessorGeneratorMethodProxy: Generator for proxy methods
AccessorGeneratorObjectFactory: Generator for factory methods (constructor invokers)
AccessorInfo: Information about an accessor
AccessorInfo.AccessorName: Accessor Name struct
AccessorInfo.AccessorType: Accessor types
ActivityStack: Tracker for processors which want to express their activity stack on crash in a user-readable way.
AfterInvoke: This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns after the matching instructions, with special handling for methods invocations which return a value and immediately assign it to a local variable.
AfterStoreLocal: This injection point is a companion for the `ModifyVariable` injector which searches for STORE operations which match the local variables described by the injector's defined discriminators.
AnnotatedMethodInfo: Data bundle for an annotated method in a mixin
Annotations: Utility class for working with ASM annotations
Annotations.Handle: Wrapper for `AnnotationNode` to support access via common interface
ArgOffsets: Decoration which stores a linear offset of arguments when a node replacement results in a call to a method with the same arguments as the original (replaced) call but offset by some fixed amount.
Args: Argument bundle class used in `ModifyArgs` callbacks.
ArgsClassGenerator: Class generator which creates subclasses of `Args` to be used by the `ModifyArgs` injector.
ArgumentCountException: Exception thrown when varargs array passed into `Args.setAll(java.lang.Object...)` is of a different length than the args
ArgumentIndexOutOfBoundsException: Exception thrown when attempting to set an argument (via) `Args` which is out of bounds
ASM: Utility methods for determining ASM version and other version-specific shenanigans
At: Annotation for specifying the type of `InjectionPoint` to use to perform an `Inject` process.
At.Shift: Shift is used to shift resulting opcodes
BeforeConstant: Special injection point which can be defined by an `Constant` annotation or using the at code `CONSTANT`.
BeforeFieldAccess: This injection point searches for GETFIELD and PUTFIELD (and static equivalent) opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeFinalReturn: This injection point searches for the last RETURN opcode in the target method and returns it.
BeforeInvoke: This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeInvoke.SearchType: Member search type, the `PERMISSIVE` search is only used when refmap remapping is enabled.
BeforeLoadLocal: This injection point is a companion for the `ModifyVariable` injector which searches for LOAD operations which match the local variables described by the injector's defined discriminators.
BeforeNew: This injection point searches for NEW opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
BeforeReturn: This injection point searches for RETURN opcodes in the target method and returns a list of insns immediately prior to matching instructions.
BeforeStringInvoke: Like `BeforeInvoke`, this injection point searches for INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments and returns a list of insns immediately prior to matching instructions.
Bytecode: Utility methods for working with bytecode via ASM
Bytecode.DelegateInitialiser: Information bundle returned from `Bytecode.findDelegateInit(org.objectweb.asm.tree.MethodNode, java.lang.String, java.lang.String)`
Bytecode.Visibility: Ordinal member visibility level.
CallbackInfo: CallbackInfo instances are passed to callbacks in order to provide information and handling opportunities to the callback to interact with the callback itself.
CallbackInfoReturnable<R>: For callbacks with a non-void return type, a CallbackInfoReturnable is passed to the callback instead to allow the callback to interact with the method return value.
CallbackInjectionInfo: Information about a callback to inject, usually specified by `Inject`
CallbackInjector: This class is responsible for generating the bytecode for injected callbacks, for details of usage see `@Inject`.
Cancellable: Interface for things which can be cancelled
CancellationException: Exception thrown when a consumer attemtps to call `cancel()` on a callback not marked as `cancellable`.
ClassInfo: Information about a class, used as a way of keeping track of class hierarchy information needed to support more complex mixin behaviour such as detached superclass and mixin inheritance.
ClassInfo.FrameData: Information about frames in a method
ClassInfo.SearchType: Search type for the findInHierarchy methods, replaces a boolean flag which made calling code difficult to read
ClassInfo.Traversal: To all intents and purposes, the "real" class hierarchy and the mixin class hierarchy exist in parallel, this means that for some hierarchy validation operations we need to walk across to the other hierarchy in order to allow meaningful validation to occur.
ClassInfo.TypeLookup: When using `ClassInfo.forType`, determines whether an array type should be returned as declared (eg.
ClassNodeAdapter: Adapter for ClassNode to access members added after ASM 5
ClassSignature: Represents an object-oriented view of a generic class signature.
Clinit
Coerce: Usage with callback injectors (`@Inject`)
CommandLineOptions: Options passed in to Mixin via the command line
Config: Handle for marshalling mixin configs outside of the transformer package
Constant: Annotation for specifying the injection point for an `ModifyConstant` injector.
Constant.Condition: Available options for the `Constant.expandZeroConditions()` setting.
Constants: Miscellaneous shared constants
Constants.ManifestAttributes: Shared Jar Manifest Attributes
ConstraintParser: Parser for constraints
ConstraintParser.Constraint: A constraint.
Constructor: A `Target` which is a constructor
ConstructorHead: Like `HEAD`, this injection point can be used to specify the first instruction in a method, but provides special handling for constructors.
ContainerHandleURI: Container handle which directly replaces the use of classpath location URIs from previous mixin versions
ContainerHandleVirtual: A virtual container, used to marshal other containers around
Counter: Mutable integer for use in collections
Debug: Anotation used to decorate items you might wish to examine after mixin application.
Desc: A descriptor for matching a target element, for details of usage see `DynamicSelectorDesc`.
DescriptorResolver: Utility class which contains the logic for resolving descriptors (`Desc` annotations) starting from an element and recursing up the tree of parent elements looking for a matching descriptor
Descriptors: Collection type for `Desc` to allow `Repeatable` to work.
Dynamic: Decorator annotation for mixin elements whose targets are not available in the original class and are either fabricated or transformed at runtime.
DynamicSelectorDesc: A `Target Selector` which matches candidates using descriptors contained in `@Desc` annotations.
ElementNode<TNode>: Wrapper for all node types supported by `target selectors` (`FieldNode`, `MethodNode`, `FieldInsnNode`, `MethodInsnNode` and `InvokeDynamicInsnNode`) which allows access to common properties of things which are basically "arbitrary node with owner, name and descriptor"
ElementNode.NodeType: Element node type, returned by `getType` so consumers don't need to do instanceof checks, and allows switching on element type in a more expressive way
ExtensionCheckClass: Mixin transformer module which runs CheckClassAdapter on the post-mixin bytecode
ExtensionCheckClass.ValidationFailedException: Exception thrown when checkclass fails
ExtensionCheckInterfaces: Checks whether interfaces declared on mixin target classes are actually fully implemented and generates reports to the console and to files on disk
ExtensionClassExporter: Debug exporter
ExtensionLVTCleaner: Strips synthetic local variables from the LVT after exporting to avoid debuggers becoming confused by them.
Extensions: Mixin transformer extensions and common modules such as class generators
FabricUtil
Files: Utility class for file operations
Final: This annotation has two uses: On an `Shadow` field, it can be used to raise an error-level log message if any write occurrences appear in the mixin bytecode.
GlobalProperties: Access to underlying global property service provided by the current environment
GlobalProperties.Keys: Global property keys
Group: This annotation can be used on any injector callback to define a value for total required injections across multiple callbacks.
Handles: Utility class for working with method and field handles
IActivityContext
IActivityContext.IActivity
IAdviceProvider: Advice providers are responsible for providing suggestions to solve service-specific problems.
IAnnotatedElement: Interface for objects which can be annotated since main classes may need to read info from mirror annotations in the AP
IAnnotationHandle: Interface for annotation handle since some classes may need to read info from both ASM `AnnotationNode`s at runtime and mirror annotations in the AP at compile time.
IChainedDecoration<T>: An InjectionNode decoration which can chain to a previously registered decoration with the same type and key.
IClassBytecodeProvider: Interface for object which can provide class bytecode
IClassGenerator: Base interface for class generators
IClassProvider: Interface for marshal object which can retrieve classes from the environment
IClassReferenceMapper
IClassTracker: Class trackers are responsible for interacting with the class loading process to for the purposes of tracking class load activity and class load restrictions.
IConsumer<TItem>: No Java 8 here but I need this interface
IContainerHandle: Interface for container handles.
IDecompiler: Interface to allow the actual decompiler to be loaded on-demand
IEnvironmentTokenProvider: Provides a token value into the attached environment
IExtension: Mixin Transformer extension interface for pre- and post-processors
IExtensionRegistry: Interface for the mixin Extensions registry
IFeatureValidator: Feature validators are responsible for deciding if certain features are allowed in given contexts.
IGlobalPropertyService: Global property service
IHotSwap: Interface to allow the hot-swap agent to be loaded on-demand
IInjectionPointContext: Context for an injection point, used to access the mixin as well as the owner method and annotation for the injection point
IInsnListEx: Interface for extensions for InsnList which provide additional context for the InsnList.
IInsnListEx.SpecialNodeType: Type of special nodes supported by `IInsnListEx.getSpecialNode(org.spongepowered.asm.mixin.injection.code.IInsnListEx.SpecialNodeType)`
ILegacyClassTransformer: Adapter interface for legacy class transformers.
ILogger: Interface extracted from Log4j2's Logger (`org.apache.logging.log4j.Logger` ) with only the main methods used by Mixin included.
IMapping<TMapping>: Base class for member mapping entries
IMapping.Type: Type of mapping
IMessageSink: Interface for generic message consumers
IMixinAuditTrail: Audit trail is responsible for logging activities during mixin application to target classes for use as debugging information later on.
IMixinConfig: Interface for loaded mixin configurations
IMixinConfigPlugin: A companion plugin for a mixin configuration object.
IMixinConfigSource: Interface for loaded mixin configurations
IMixinConnector: A connector class is a bootstrap agent for a mixin consumer.
IMixinContext: Context for performing reference mapping
IMixinErrorHandler: Interface for objects which want to perform custom behaviour when fatal mixin errors occur.
IMixinErrorHandler.ErrorAction: Action to take when handling an error.
IMixinInfo: Interface for MixinInfo, used in extensibility API
IMixinInternal: A mixin internal part, offered to services.
IMixinPlatformAgent: Base interface for platform agents.
IMixinPlatformAgent.AcceptResult: Result type returned from `IMixinPlatformAgent.accept(org.spongepowered.asm.launch.platform.MixinPlatformManager, org.spongepowered.asm.launch.platform.container.IContainerHandle)`
IMixinPlatformServiceAgent: Service agents provide additional platform-specific extensions leveraged by mixin services.
IMixinService: Mixin Service interface.
IMixinServiceBootstrap: Bootstrap interface for Mixin services.
IMixinTransformer: Transformation engine
IMixinTransformerFactory: Factory for the mixin transformer, concrete instances of this class are only provided to services since only the service should be able to decide when the mixin transformer is initialised.
Implements: Pseudo-implements decorator for Mixins with conflicting methods in a superclass to soft-implement an interface.
Initialiser
Initialiser.InjectionMode: Strategy for injecting initialiser insns
Inject: Specifies that this mixin method should inject a callback (or callbacks) to itself in the target method(s) identified by `Inject.method()`.
InjectionInfo: Contructs information about an injection from an `Inject` annotation and allows the injection to be processed.
InjectionInfo.AnnotationType: Decoration for subclasses which indicates the injector annotation that the subclass handles
InjectionInfo.HandlerPrefix: Decoration for subclasses which specifies the prefix to use when conforming annotated handler methods
InjectionInfo.InjectorOrder: Decoration for subclasses which specifies the order (phase) in which the injector should be applied relative to other injectors.
InjectionNodes: Used to keep track of instruction nodes in a `Target` method which are targetted by various types of injector.
InjectionNodes.InjectionNode: A node targetted by one or more injectors.
InjectionPoint: Base class for injection point discovery classes.
InjectionPoint.AtCode: Injection point code for `At` annotations to use
InjectionPoint.Flags: Boolean extensions for the At parser, mainly to avoid having to add many booleans in the future
InjectionPoint.RestrictTargetLevel: Target restriction level for different injection point types when used by restricted injectors (eg.
InjectionPoint.Specifier: Additional specifier for injection points.
InjectionPointAnnotationContext: Specialised SelectorAnnotationContext for injection points
InjectionPointData: Data read from an `At` annotation and passed into an InjectionPoint ctor
Injector: Base class for bytecode injectors
Injector.InjectorData: Redirection data bundle base.
Injector.TargetNode: A nominated target node
InjectorGroupInfo: Information store for injector groups
InjectorGroupInfo.Map: Storage for injector groups
InjectorTarget: Couples `method slices` to a `Target` for injection purposes.
InsnFinder: Utility class for finding instructions using static analysis
InsnListEx: InsnList with extensions, see `IInsnListEx`
InsnListReadOnly: Read-only wrapper for InsnList, defensively passed to InjectionPoint instances so that custom InjectionPoint implementations cannot modify the insn list whilst inspecting it.
InsnRange: Struct for representing a range of instructions
Interface: This annotation is used to define information for a soft-implemented interface.
Interface.Remap: Describes the remapping strategy applied to methods matching this interface.
Intrinsic: This annotation allows fine-tuning of the overwrite policy for a soft-implemented interface member method.
InvalidImplicitDiscriminatorException: Thrown when an implicit discriminator (no args) fails to identify a unique candidate.
InvalidMemberDescriptorException: Thrown when a `MemberInfo` fails basic syntax validation
InvalidSelector: Since the contract of `TargetSelector.parse(java.lang.Iterable<?>, org.spongepowered.asm.mixin.injection.selectors.ISelectorContext)` prohibits returing `null`, instances of this selector are returned when supplied arguments are unparseable in order to throw exceptions only during validation.
InvalidSelectorException: Exception to be thrown from `ITargetSelector.validate()` when a target selector fails verification
InvokeInjector: Base class for injectors which inject at method invokes
Invoker: Defines an invoker method (also known as a proxy method in a mixin, the method.
IPropertyKey: Marker interface for property keys
IReferenceMapper: Interface for reference mapper objects
IRemapper: Interface for remap chain participants
IResolvedDescriptor: A resolved descriptor, or rather the result of resolving a descriptor.
ISelectorContext: Context passed to a `Target Selector` in order to support context-sensitive behaviour for the selector.
ISliceContext: Context for a slice declaration
ISyntheticClassInfo: Interface for information bundle about a synthetic class provided by Mixin.
ISyntheticClassRegistry: Registry for synthetic classes, used internally to track which classes need to be generated at runtime by the mixin pipeline.
ITargetClassContext: Interface for target classes passed into transformer modules via `IExtension`
ITargetSelector: Target Selectors are used to identify target members in a class, with the criteria for selection being specified in a single string, effectively defining the query parameters.
ITargetSelector.Configure: Available selector reconfigurations
ITargetSelectorByName: A target selector which selects elements directly by name.
ITargetSelectorConstructor: A target selector which can identify constructor types
ITargetSelectorDynamic: Decoration interface for dynamic target selectors
ITargetSelectorDynamic.SelectorAnnotation: Decoration for subclasses which indicates an annotation type from which the selector can be parsed.
ITargetSelectorDynamic.SelectorId: Decoration for subclasses which indicates id used for a specific selector when specified, for example `@MyNamespace:MySelector(argshere)` would specify "MySelector"
ITargetSelectorRemappable: A target selector which can be remapped at compile time via an obfuscation service
ITokenProvider: Agent which can supply token values to a `ConstraintParser.Constraint`.
ITransformer: Base interface for transformer types
ITransformerProvider: Interface for interacting with transforming classloaders.
ITreeClassTransformer: Adapter interface for tree class transformers.
JavaVersion: Small helper to resolve the current java version
JumpInsnPoint: This injection point searches for JUMP opcodes (if, try/catch, continue, break, conditional assignment, etc.) with either a particular opcode or at a particular ordinal in the method body (eg.
LanguageFeatures: Bitmask values for language features supported.
Level
LocalCapture: Specifies the behaviour for capturing local variables at an injection point.
Locals: Utility methods for working with local variables using ASM
Locals.Settings: Settings for `getLocalsAt` containing the tunable options for the algorithm.
Locals.SyntheticLocalVariableNode: A local variable entry added by mixin itself, eg.
LocalVariableDiscriminator: Encapsulates logic for identifying a local variable in a target method using 3 criteria: ordinal, index and name.
LocalVariableDiscriminator.Context: Discriminator context information, wraps all relevant information about a target location for use when performing discrimination
LoggerAdapterAbstract: Abstract base adapter which contains a convenience class for formatting log4j2-style messages and also routes all level-specific overloads to calls to `log`, which can simplify some implementations.
LoggerAdapterAbstract.FormattedMessage: This is a very naive implementation of log4j2's `ParameterizedMessage` which is less efficient and less defensive because it doesn't need to handle all the cases that the log4j2 formatter does.
LoggerAdapterConsole: A very basic logger adapter which does not log anything to file and simply emits formatted log messages to the console printstreams
LoggerAdapterDefault: Default logger adapter which sinks log messages but doesn't emit them anywhere, used only in cases where no logging framework is available and no logging is desired.
LoggerAdapterJava: Logger adapter which uses the built-in Java logging functionality to emit logging messages.
MainAttributes: "Main" attribute cache for a URI container, mainly to avoid constantly opening jar files just to read odd values out of the manifest.
MappingField: Stores information about a field mapping during AP runs
MappingFieldSrg: An SRG field mapping
MappingMethod: Stores information about a method mapping during AP runs
MarkerNode: A label node used as a marker in the bytecode.
MatchResult: Result of a `target selector` match operation which describes the type of match.
MemberInfo: Struct which defines an Explcit Target selector, See `ITargetSelector` for other supported selector types.
MemberMatcher: A `Target Selector` which matches an element of candidate members using a regular expression.
MemberRef: Reference to a field or method that also includes invocation instructions.
MemberRef.Field: A static reference to a field backed by field get/put instruction
MemberRef.Handle: A reference to a field or method backed by a method handle
MemberRef.Method: A static reference to a method backed by an invoke instruction
MessageRouter: Logging router for objects which may need to log messages during standard runtime or during Annotation Processor sessions.
MethodHead: This injection point simply returns the first instruction in the target method body, allowing the injection to be placed at the "head" of the target method.
MethodNodeEx: MethodNode with some extra convenience functionality
MethodSlice: Stores information about a defined method slice for a particular injector.
MethodSlices: Represents a collection of `MethodSlice`s, mapped by ID.
MethodVisitorEx: MethodVisitor with some extra convenience functionality
Mixin: The main decorator for mixin classes, this annotation denotes a class as a mixin and specifies two key attributes: The target classes Every mixin requires at least one target class in order to be valid.
MixinBootstrap: Bootstraps the mixin subsystem.
MixinClassGenerator: Handles delegation of class generation tasks to the extensions
MixinClassReader: A ClassReader which returns a more verbose exception message when the incoming class major version is higher than the version supported by the active ASM.
MixinClassWriter: ClassWriter which resolves common superclasses using Mixin's metadata instead of calling Class.forName
MixinConnectorManager: Manager for Mixin containers bootstrapping via `IMixinConnector`
MixinContainer: A collection of `IMixinPlatformAgent` platform agents) for a particular container
MixinEnvironment: The mixin environment manages global state information for the mixin subsystem.
MixinEnvironment.CompatibilityLevel: Operational compatibility level for the mixin subsystem
MixinEnvironment.Feature: Mixin features which can be specified in mixin configs as required for the config to be valid.
MixinEnvironment.Option: Mixin options
MixinEnvironment.Phase: Environment phase, deliberately not implemented as an enum
MixinEnvironment.Side: Represents a "side", client or dedicated server
MixinHooks
MixinInheritanceTracker
MixinInitialisationError: Error raised when mixin subsystem initialisation fails
MixinInner: Decoration annotation used by the mixin inner class generator to mark inner classes which have been generated from an existing inner class in a mixin
MixinIntrinsics: Intrinsics for use in @Mixin classes.
MixinMerged: For internal use only! Contains small parts.
MixinPlatformAgentAbstract: Platform agent base class
MixinPlatformAgentDefault: Default platform agent, handles the mixin manifest keys such as `MixinConfigs` and `MixinTokenProviders`.
MixinPlatformManager: Handler for platform-specific behaviour required in different mixin environments.
MixinProxy: Decoration annotation used by postprocessor to mark methods which have had their contents replaced with a proxy.
MixinRenamed: Internal use only.
Mixins: Entry point for registering global mixin resources.
MixinService: Provides access to the service layer which connects the mixin transformer to a particular host environment.
MixinServiceAbstract: Mixin Service base class
MixinTargetContext: This object keeps track of data for applying a mixin to a specific target class during a mixin application.
MixinVerifier: Verifier which handles class info lookups via `ClassInfo`
ModifyArg: Specifies that this mixin method should inject an argument modifier to itself in the target method(s) identified by `ModifyArg.method()`.
ModifyArgInjectionInfo: Information about a `ModifyArg` injector
ModifyArgInjector: A bytecode injector which allows a single argument of a chosen method call to be altered.
ModifyArgs: Specifies that this mixin method should inject an multi-argument modifier callback to itself in the target method(s) identified by `ModifyArgs.method()`.
ModifyArgsInjectionInfo: Information about a `ModifyArgs` injector
ModifyArgsInjector: A bytecode injector which allows a single argument of a chosen method call to be altered.
ModifyConstant: Specifies that this mixin method should inject a constant modifier callback to itself in the target method(s) identified by `ModifyConstant.method()` at the specified LDC (or specialised const opcode) instruction in order to adjust the constant value returned.
ModifyConstantInjectionInfo: Information about a constant modifier injector
ModifyConstantInjector: A bytecode injector which allows a specific constant value to be identified and replaced with a callback.
ModifyVariable: Specifies that this mixin method should inject a variable modifier callback to itself in the target method(s) identified by `ModifyVariable.method()`.
ModifyVariableInjectionInfo: Information about a `ModifyVariable` injector
ModifyVariableInjector: A bytecode injector which allows a single local variable in the target method to be captured and altered.
Mutable: Use in conjunction with `Final` or `Accessor` to indicate that whilst a target field is final in the target class, mutation within the mixin is intentional.
Next: See `@Desc.next`
ObfuscationUtil: Utility methods for obfuscation tasks
ObfuscationUtil.IClassRemapper: Interface for remapper proxies
Overwrite: Annotation used to indicate a mixin class member which must overwrite a method in the target class.
PrettyPrinter: Prints information in a pretty box
PrettyPrinter.Alignment: Table column alignment
PrettyPrinter.IPrettyPrintable: Interface for object which supports printing to pretty printer
Profiler: Performance profiler for Mixin.
Profiler.Section: Base abstract profiler section.
Pseudo: A Mixin marked as `@Pseudo` is allowed to target classes which are not available at compile time and may not be available at runtime.
Quantifier: A regex-style quantifier, specified as a number or pair of numbers in braces.
Redirect: Specifies that this mixin method should redirect the specified method call, field access or object construction (via the `new` keyword) to the method decorated with this annotation.
RedirectInjectionInfo: Information about a redirector injector
RedirectInjector: A bytecode injector which allows a method call, field access or `new` object creation to be redirected to the annotated handler method.
ReEntranceLock: Re-entrance semaphore used to share re-entrance data with the metadata service
ReferenceMapper: Stores runtime information allowing field, method and type references which cannot be hard remapped by the reobfuscation process to be remapped in a "soft" manner at runtime.
RemapperChain: Mixin environment remapper chain.
RemappingReferenceMapper: This adapter is designed to apply the same remapping used elsewhere in the development chain (RemapperChain) to reference maps.
SelectorAnnotationContext: Narrowed context for selectors in annotations which are themselves inside a parent annotation, for example @At annotations within a parent @Inject annotation.
ServiceInitialisationException: Exception thrown when a service fails during initialisation, expected if the service is missing a dependency or is attempting to boot in an incompatible environment
ServiceNotAvailableError: Error to throw when no service is available in the current environment
ServiceVersionError: Error to throw when loaded service is out of date or mismatched
Shadow: Used to indicate a Mixin class member which is acting as a placeholder for a method or field in the target class
SignaturePrinter: Generates callback signature for callback pretty-print
Slice: A `Slice` identifies a section of a method to search for injection points.
SoftOverride: Decorator for methods which override a method in a supermixin which the containing mixin does not directly extend
SourceMap: Structure which contains information about a SourceDebugExtension SMAP
SourceMap.File: Defines a source code file within a source map stratum
SpecialMethodInfo: Information about a special mixin method such as an injector or accessor
Surrogate: Annotation used to decorate surrogate injector methods.
SyntheticClassInfo: Information bundle about a synthetic class provided by Mixin
Target: Information about the current injection target (method) which bundles common injection context with the target method in order to allow injectors to interoperate.
TargetNotSupportedException: Exception thrown when target selector is not valid for the supplied target context during `ITargetSelector.attach(org.spongepowered.asm.mixin.injection.selectors.ISelectorContext)`
TargetSelector: Utility class for parsing selectors
TargetSelector.Result<TNode>: Query result struct
TargetSelectors
TargetSelectors.SelectedMethod: Selected target method, paired with the selector which identified it
TreeTransformer: Base class for transformers which work with ASM tree model
Unique: This annotation, when applied to a member method or field in a mixin, indicates that the member should never overwrite a matching member in the target class.
VersionNumber: Represents a software version number in `major.minor.revision.build` format as a sequence of four shorts packed into a long.