Meta
[jvm]
abstract class Meta : CompilerPluginRegistrar, MetaPluginSyntax, InternalRegistry
Meta is the core entry point and impl of Arrow Meta in terms of its registration system and interface with the Kotlin Compiler
Plugin authors are encouraged to define CliPlugin extensions by making them part of the Meta receiver:
val Meta.helloWorld: CliPlugin get() =
"Hello World" {
meta(
...
)
}
The Meta receiver provides automatic syntax for everything the user needs to build plugins through delegation to MetaPluginSyntax and providing the internal implementation to the compiler subscriptions via InternalRegistry
Constructors
| Meta | [jvm] constructor() |
Functions
| Name | Summary |
|---|---|
| additionalSources | [jvm] open fun additionalSources(collectAdditionalSourcesAndUpdateConfiguration: CompilerContext.(knownSources: Collection<KtFile>, configuration: CompilerConfiguration, project: Project) -> Collection<KtFile>): CollectAdditionalSources additionalSources is a function that is invoked before resolution and allows us to provide an additional set of KtFile files. These files will be considered part of the compilation unit alongside the user sources. |
| analysis | [jvm] open fun analysis(doAnalysis: CompilerContext.(project: Project, module: ModuleDescriptor, projectContext: ProjectContext, files: Collection<KtFile>, bindingTrace: BindingTrace, componentProvider: ComponentProvider) -> AnalysisResult?, analysisCompleted: CompilerContext.(project: Project, module: ModuleDescriptor, bindingTrace: BindingTrace, files: Collection<KtFile>) -> AnalysisResult? = Noop.nullable5()): AnalysisHandler The analysis function allows us to intercept analysis before and after it happens, altering the analysis inputs and outputs. Altering the inputs on @doAnalysis allows us to modify the compiler trees in the AST before they are considered for resolution. This allows us to build the Quote in this phase, which is Arrow Meta’s higher level API. Altering the output with analysisCompleted allows us to modify the binding trace and all elements resulting from analysis. |
| callChecker | [jvm] open fun callChecker(check: CompilerContext.(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) -> Unit): StorageComponentContainer |
| codegen | [jvm] open fun codegen(applyFunction: CompilerContext.(receiver: StackValue, resolvedCall: ResolvedCall<>, c: ExpressionCodegenExtension.Context) -> StackValue?, applyProperty: CompilerContext.(receiver: StackValue, resolvedCall: ResolvedCall<>, c: ExpressionCodegenExtension.Context) -> StackValue?, generateClassSyntheticParts: CompilerContext.(codegen: ImplementationBodyCodegen) -> Unit): Codegen The codegen function allows us to interact with applyFunction, applyProperty, and generateClassSyntheticParts. Each one of these functions are invoked as the compiled and type checked tree of KtElement and DeclarationDescriptor is processed for codegen. Here, we can alter the bytecode emitted using the Meta ASM DSL. This DSL mirrors the IR DSL offering a match + transform function that allows us to alter the codegen tree. |
| compilerContextService | [jvm] open fun compilerContextService(): StorageComponentContainer |
| declarationAttributeAlterer | [jvm] open fun declarationAttributeAlterer(refineDeclarationModality: CompilerContext.(modifierListOwner: KtModifierListOwner, declaration: DeclarationDescriptor?, containingDeclaration: DeclarationDescriptor?, currentModality: Modality, bindingContext: BindingContext, isImplicitModality: Boolean) -> Modality?): DeclarationAttributeAlterer |
| declarationChecker | [jvm] open fun declarationChecker(check: CompilerContext.(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) -> Unit): StorageComponentContainer |
| enableIr | [jvm] open fun enableIr(): ExtensionPhase The enableIr function enables the Intermediate Representation Backend. The IR Backend is a part of the code generation phase and emits code in the IR format. The IR Format is a tree structure with significant indentation that contains all the information needed to generate bytecode for all platforms the Kotlin programming language targets. When the IR backend is disabled, which is the current default in the Kotlin Compiler, the JVM ASM Backend is used instead. |
| extraImports | [jvm] open fun extraImports(extraImports: CompilerContext.(ktFile: KtFile) -> Collection<KtImportInfo>): ExtraImports The extraImports function allows the user to provide an additional set of org.jetbrains.kotlin.psi.KtImportInfo imports for each individual KtFile considered as sources. This additional set of imports are taken into account when resolving symbols in the resolution phase of a KtFile. |
| intercept | [jvm] abstract override fun intercept(ctx: CompilerContext): List<CliPlugin> The Meta plugin supports N numbers of local and remote sub CliPlugin that provide a List of ExtensionPhase subscriptions. registerProjectComponents implementation calls intercept to deliver subscriptions to the Kotlin Compiler in the right order. |
| irAnonymousInitializer | [jvm] open fun Meta.irAnonymousInitializer(f: IrUtils.(IrAnonymousInitializer) -> IrStatement?): IRGeneration |
| irBlock | [jvm] open fun Meta.irBlock(f: IrUtils.(IrBlock) -> IrExpression?): IRGeneration |
| irBlockBody | [jvm] open fun Meta.irBlockBody(f: IrUtils.(IrBlockBody) -> IrBody?): IRGeneration |
| irBody | [jvm] open fun Meta.irBody(f: IrUtils.(IrBody) -> IrBody?): IRGeneration |
| irBranch | [jvm] open fun Meta.irBranch(f: IrUtils.(IrBranch) -> IrBranch?): IRGeneration |
| irBreak | [jvm] open fun Meta.irBreak(f: IrUtils.(IrBreak) -> IrExpression?): IRGeneration |
| irBreakContinue | [jvm] open fun Meta.irBreakContinue(f: IrUtils.(IrBreakContinue) -> IrExpression?): IRGeneration |
| irCall | [jvm] open fun Meta.irCall(f: IrUtils.(IrCall) -> IrElement?): IRGeneration |
| irCallableReference | [jvm] open fun Meta.irCallableReference(f: IrUtils.(IrCallableReference<*>) -> IrElement?): IRGeneration |
| irCatch | [jvm] open fun Meta.irCatch(f: IrUtils.(IrCatch) -> IrCatch?): IRGeneration |
| irClass | [jvm] open fun Meta.irClass(f: IrUtils.(IrClass) -> IrStatement?): IRGeneration |
| irClassReference | [jvm] open fun Meta.irClassReference(f: IrUtils.(IrClassReference) -> IrExpression?): IRGeneration |
| irComposite | [jvm] open fun Meta.irComposite(f: IrUtils.(IrComposite) -> IrExpression?): IRGeneration |
| irConst | [jvm] open fun Meta.irConst(f: IrUtils.(IrConst<*>) -> IrExpression?): IRGeneration |
| irConstructor | [jvm] open fun Meta.irConstructor(f: IrUtils.(IrConstructor) -> IrStatement?): IRGeneration |
| irConstructorCall | [jvm] open fun Meta.irConstructorCall(f: IrUtils.(IrConstructorCall) -> IrElement?): IRGeneration |
| irContainerExpression | [jvm] open fun Meta.irContainerExpression(f: IrUtils.(IrContainerExpression) -> IrExpression?): IRGeneration |
| irContinue | [jvm] open fun Meta.irContinue(f: IrUtils.(IrContinue) -> IrExpression?): IRGeneration |
| irDeclaration | [jvm] open fun Meta.irDeclaration(f: IrUtils.(IrDeclaration) -> IrStatement?): IRGeneration |
| irDeclarationReference | [jvm] open fun Meta.irDeclarationReference(f: IrUtils.(IrDeclarationReference) -> IrExpression?): IRGeneration |
| irDelegatingConstructorCall | [jvm] open fun Meta.irDelegatingConstructorCall(f: IrUtils.(IrDelegatingConstructorCall) -> IrElement?): IRGeneration |
| irDoWhileLoop | [jvm] open fun Meta.irDoWhileLoop(f: IrUtils.(IrDoWhileLoop) -> IrExpression?): IRGeneration |
| irDump | [jvm] open fun Meta.irDump(): IRGeneration |
| irDumpKotlinLike | [jvm] open fun Meta.irDumpKotlinLike(options: KotlinLikeDumpOptions = KotlinLikeDumpOptions()): IRGeneration |
| irDynamicExpression | [jvm] open fun Meta.irDynamicExpression(f: IrUtils.(IrDynamicExpression) -> IrExpression?): IRGeneration |
| irDynamicMemberExpression | [jvm] open fun Meta.irDynamicMemberExpression(f: IrUtils.(IrDynamicMemberExpression) -> IrExpression?): IRGeneration |
| irDynamicOperatorExpression | [jvm] open fun Meta.irDynamicOperatorExpression(f: IrUtils.(IrDynamicOperatorExpression) -> IrExpression?): IRGeneration |
| irElseBranch | [jvm] open fun Meta.irElseBranch(f: IrUtils.(IrElseBranch) -> IrElseBranch?): IRGeneration |
| irEnumConstructorCall | [jvm] open fun Meta.irEnumConstructorCall(f: IrUtils.(IrEnumConstructorCall) -> IrElement?): IRGeneration |
| irEnumEntry | [jvm] open fun Meta.irEnumEntry(f: IrUtils.(IrEnumEntry) -> IrStatement?): IRGeneration |
| irErrorCallExpression | [jvm] open fun Meta.irErrorCallExpression(f: IrUtils.(IrErrorCallExpression) -> IrExpression?): IRGeneration |
| irErrorDeclaration | [jvm] open fun Meta.irErrorDeclaration(f: IrUtils.(IrErrorDeclaration) -> IrStatement?): IRGeneration |
| irErrorExpression | [jvm] open fun Meta.irErrorExpression(f: IrUtils.(IrErrorExpression) -> IrExpression?): IRGeneration |
| irExpression | [jvm] open fun Meta.irExpression(f: IrUtils.(IrExpression) -> IrExpression?): IRGeneration |
| irExpressionBody | [jvm] open fun Meta.irExpressionBody(f: IrUtils.(IrExpressionBody) -> IrBody?): IRGeneration |
| irField | [jvm] open fun Meta.irField(f: IrUtils.(IrField) -> IrStatement?): IRGeneration |
| irFieldAccess | [jvm] open fun Meta.irFieldAccess(f: IrUtils.(IrFieldAccessExpression) -> IrExpression?): IRGeneration |
| irFile | [jvm] open fun Meta.irFile(f: IrUtils.(IrFile) -> IrFile?): IRGeneration |
| irFunction | [jvm] open fun Meta.irFunction(f: IrUtils.(IrFunction) -> IrStatement?): IRGeneration |
| irFunctionAccess | [jvm] open fun Meta.irFunctionAccess(f: IrUtils.(IrFunctionAccessExpression) -> IrElement?): IRGeneration |
| irFunctionReference | [jvm] open fun Meta.irFunctionReference(f: IrUtils.(IrFunctionReference) -> IrElement?): IRGeneration |
| IrGeneration | [jvm] open fun IrSyntax.IrGeneration(generate: (compilerContext: CompilerContext, moduleFragment: IrModuleFragment, pluginContext: IrPluginContext) -> Unit): IRGeneration IR, The intermediate representation format, is a structured text format with significant indentation that contains all the information the compiler knows about a program. At this point, the compiler knows the structure of a program based on its sources, what the typed expressions are, and how each of the generic type arguments gets applied. The compiler emits information in this phase that is processed by interpreters and compilers targeting any platform. IR Example |
| irGetClass | [jvm] open fun Meta.irGetClass(f: IrUtils.(IrGetClass) -> IrExpression?): IRGeneration |
| irGetEnumValue | [jvm] open fun Meta.irGetEnumValue(f: IrUtils.(IrGetEnumValue) -> IrExpression?): IRGeneration |
| irGetField | [jvm] open fun Meta.irGetField(f: IrUtils.(IrGetField) -> IrExpression?): IRGeneration |
| irGetObjectValue | [jvm] open fun Meta.irGetObjectValue(f: IrUtils.(IrGetObjectValue) -> IrExpression?): IRGeneration |
| irGetValue | [jvm] open fun Meta.irGetValue(f: IrUtils.(IrGetValue) -> IrExpression?): IRGeneration |
| irInstanceInitializerCall | [jvm] open fun Meta.irInstanceInitializerCall(f: IrUtils.(IrInstanceInitializerCall) -> IrExpression?): IRGeneration |
| irLocalDelegatedProperty | [jvm] open fun Meta.irLocalDelegatedProperty(f: IrUtils.(IrLocalDelegatedProperty) -> IrStatement?): IRGeneration |
| irLocalDelegatedPropertyReference | [jvm] open fun Meta.irLocalDelegatedPropertyReference(f: IrUtils.(IrLocalDelegatedPropertyReference) -> IrElement?): IRGeneration |
| irLoop | [jvm] open fun Meta.irLoop(f: IrUtils.(IrLoop) -> IrExpression?): IRGeneration |
| irMemberAccess | [jvm] open fun Meta.irMemberAccess(f: IrUtils.(IrMemberAccessExpression<*>) -> IrElement?): IRGeneration |
| irModuleFragment | [jvm] open fun Meta.irModuleFragment(f: IrUtils.(IrModuleFragment) -> IrModuleFragment?): IRGeneration |
| irProperty | [jvm] open fun Meta.irProperty(f: IrUtils.(IrProperty) -> IrStatement?): IRGeneration |
| irPropertyReference | [jvm] open fun Meta.irPropertyReference(f: IrUtils.(IrPropertyReference) -> IrElement?): IRGeneration |
| irReturn | [jvm] open fun Meta.irReturn(f: IrUtils.(IrReturn) -> IrExpression?): IRGeneration |
| irSetField | [jvm] open fun Meta.irSetField(f: IrUtils.(IrSetField) -> IrExpression?): IRGeneration |
| irSetValue | [jvm] open fun Meta.irSetValue(f: IrUtils.(IrSetValue) -> IrExpression?): IRGeneration |
| irSimpleFunction | [jvm] open fun Meta.irSimpleFunction(f: IrUtils.(IrSimpleFunction) -> IrStatement?): IRGeneration |
| irSingletonReference | [jvm] open fun Meta.irSingletonReference(f: IrUtils.(IrGetSingletonValue) -> IrExpression?): IRGeneration |
| irSpreadElement | [jvm] open fun Meta.irSpreadElement(f: IrUtils.(IrSpreadElement) -> IrSpreadElement?): IRGeneration |
| irStringConcatenation | [jvm] open fun Meta.irStringConcatenation(f: IrUtils.(IrStringConcatenation) -> IrExpression?): IRGeneration |
| irSuspendableExpression | [jvm] open fun Meta.irSuspendableExpression(f: IrUtils.(IrSuspendableExpression) -> IrExpression?): IRGeneration |
| irSuspensionPoint | [jvm] open fun Meta.irSuspensionPoint(f: IrUtils.(IrSuspensionPoint) -> IrExpression?): IRGeneration |
| irSyntheticBody | [jvm] open fun Meta.irSyntheticBody(f: IrUtils.(IrSyntheticBody) -> IrBody?): IRGeneration |
| irThrow | [jvm] open fun Meta.irThrow(f: IrUtils.(IrThrow) -> IrExpression?): IRGeneration |
| irTry | [jvm] open fun Meta.irTry(f: IrUtils.(IrTry) -> IrExpression?): IRGeneration |
| irTypeAlias | [jvm] open fun Meta.irTypeAlias(f: IrUtils.(IrTypeAlias) -> IrTypeAlias?): IRGeneration |
| irTypeOperator | [jvm] open fun Meta.irTypeOperator(f: IrUtils.(IrTypeOperatorCall) -> IrExpression?): IRGeneration |
| irTypeParameter | [jvm] open fun Meta.irTypeParameter(f: IrUtils.(IrTypeParameter) -> IrStatement?): IRGeneration |
| irValueAccess | [jvm] open fun Meta.irValueAccess(f: IrUtils.(IrValueAccessExpression) -> IrExpression?): IRGeneration |
| irValueParameter | [jvm] open fun Meta.irValueParameter(f: IrUtils.(IrValueParameter) -> IrStatement?): IRGeneration |
| irVararg | [jvm] open fun Meta.irVararg(f: IrUtils.(IrVararg) -> IrExpression?): IRGeneration |
| irVariable | [jvm] open fun Meta.irVariable(f: IrUtils.(IrVariable) -> IrStatement?): IRGeneration |
| irWhen | [jvm] open fun Meta.irWhen(f: IrUtils.(IrWhen) -> IrExpression?): IRGeneration |
| irWhileLoop | [jvm] open fun Meta.irWhileLoop(f: IrUtils.(IrWhileLoop) -> IrExpression?): IRGeneration |
| meta | [jvm] open fun meta(vararg phases: ExtensionPhase): List<ExtensionPhase> |
| packageFragmentProvider | [jvm] open fun packageFragmentProvider(getPackageFragmentProvider: CompilerContext.(project: Project, module: ModuleDescriptor, storageManager: StorageManager, trace: BindingTrace, moduleInfo: ModuleInfo?, lookupTracker: LookupTracker) -> PackageFragmentProvider?): PackageProvider The packageFragmentProvider function allows us to provide synthetic descriptors for declarations of a PackageFragmentDescriptor. A PackageFragmentDescriptor holds all the information about declared members in a package fragment such as top level typealiases, functions, properties, and class-like constructs such as object and interface. |
| packageFragmentProvider | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.packageFragmentProvider(phase: PackageProvider, ctx: CompilerContext) |
| preprocessedVirtualFileFactory | [jvm] open fun preprocessedVirtualFileFactory(createPreprocessedFile: CompilerContext.(file: VirtualFile?) -> VirtualFile?, createPreprocessedLightFile: CompilerContext.(file: LightVirtualFile?) -> LightVirtualFile? = Noop.nullable2()): PreprocessedVirtualFileFactory |
| registerAnalysisHandler | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerAnalysisHandler(phase: AnalysisHandler, ctx: CompilerContext) |
| registerClassBuilder | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerClassBuilder(phase: ClassBuilder, ctx: CompilerContext) |
| registerClassGenerator | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerClassGenerator(phase: ClassGeneration, ctx: CompilerContext) |
| registerCodegen | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerCodegen(phase: Codegen, ctx: CompilerContext) |
| registerCollectAdditionalSources | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerCollectAdditionalSources(phase: CollectAdditionalSources, ctx: CompilerContext) |
| registerCompilerConfiguration | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerConfiguration(phase: Config, ctx: CompilerContext) |
| registerDeclarationAttributeAlterer | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerDeclarationAttributeAlterer(phase: DeclarationAttributeAlterer, ctx: CompilerContext) |
| registerExtensions | [jvm] open override fun CompilerPluginRegistrar.ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) |
| registerExtraImports | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerExtraImports(phase: ExtraImports, ctx: CompilerContext) |
| registerIRGeneration | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerIRGeneration(phase: IRGeneration, compilerContext: CompilerContext) |
| registerMetaAnalyzer | [jvm] open fun registerMetaAnalyzer(): ExtensionPhase |
| registerMetaComponents | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerMetaComponents(configuration: CompilerConfiguration, context: CompilerContext? = null) |
| registerPreprocessedVirtualFileFactory | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerPreprocessedVirtualFileFactory(phase: PreprocessedVirtualFileFactory, ctx: CompilerContext) |
| registerProjectComponents | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) |
| registerStorageComponentContainer | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerStorageComponentContainer(phase: StorageComponentContainer, ctx: CompilerContext) |
| registerSyntheticResolver | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerSyntheticResolver(phase: SyntheticResolver, compilerContext: CompilerContext) |
| registerSyntheticScopeProvider | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerSyntheticScopeProvider(phase: SyntheticScopeProvider, ctx: CompilerContext) |
| registerSyntheticScopeProviderIfNeeded | [jvm] open fun CompilerPluginRegistrar.ExtensionStorage.registerSyntheticScopeProviderIfNeeded() |
| storageComponent | [jvm] open fun storageComponent(registerModuleComponents: CompilerContext.(container: StorageComponentContainer, moduleDescriptor: ModuleDescriptor) -> Unit, check: CompilerContext.(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) -> Unit = Noop.effect4): StorageComponentContainer The storageComponent function allows access to the StorageComponentContributor. This is the Dependency Injector and service registry the compiler uses in all phases. In this function, you can register new services or modify existing ones before the container is composed and sealed prior to compilation. |
| suppressDiagnostic | [jvm] open fun suppressDiagnostic(f: (Diagnostic) -> Boolean): ExtensionPhase The suppressDiagnostic function allows selectively determining whether a diagnostic emitted by the compiler affects compilation. As the compiler performs resolution, it will generate diagnostic of type Diagnostic with different Severity levels: Severity.INFO, Severity.ERROR, and Severity.WARNING. When the suppressDiagnostic returns true, the emitted diagnostic is suppressed and removed from the BindingTrace. This will cause the Diagnostic to not be considered in further compilation phases. |
| suppressDiagnosticWithTrace | [jvm] open fun suppressDiagnosticWithTrace(f: BindingTrace.(Diagnostic) -> Boolean): ExtensionPhase |
| syntheticResolver | [jvm] open fun syntheticResolver(addSyntheticSupertypes: CompilerContext.(thisDescriptor: ClassDescriptor, supertypes: MutableList<KotlinType>) -> Unit = Noop.effect3, generatePackageSyntheticClasses: CompilerContext.(thisDescriptor: PackageFragmentDescriptor, name: Name, ctx: LazyClassContext, declarationProvider: PackageMemberDeclarationProvider, result: MutableSet<ClassDescriptor>) -> Unit = Noop.effect6, generateSyntheticClasses: CompilerContext.(thisDescriptor: ClassDescriptor, name: Name, ctx: LazyClassContext, declarationProvider: ClassMemberDeclarationProvider, result: MutableSet<ClassDescriptor>) -> Unit = Noop.effect6, generateSyntheticMethods: CompilerContext.(thisDescriptor: ClassDescriptor, name: Name, bindingContext: BindingContext, fromSupertypes: List<SimpleFunctionDescriptor>, result: MutableCollection<SimpleFunctionDescriptor>) -> Unit = Noop.effect6, generateSyntheticProperties: CompilerContext.(thisDescriptor: ClassDescriptor, name: Name, bindingContext: BindingContext, ArrayList<PropertyDescriptor>, result: MutableSet<PropertyDescriptor>) -> Unit = Noop.effect6, generateSyntheticSecondaryConstructors: CompilerContext.(thisDescriptor: ClassDescriptor, bindingContext: BindingContext, result: MutableCollection<ClassConstructorDescriptor>) -> Unit = Noop.effect4, getSyntheticCompanionObjectNameIfNeeded: CompilerContext.(thisDescriptor: ClassDescriptor) -> Name? = Noop.nullable2(), getSyntheticFunctionNames: CompilerContext.(thisDescriptor: ClassDescriptor) -> List<Name>? = Noop.nullable2(), getSyntheticNestedClassNames: CompilerContext.(thisDescriptor: ClassDescriptor) -> List<Name>? = Noop.nullable2()): SyntheticResolver The syntheticResolver extension allows the user to change the top level class and nested class descriptors requested by IntelliJ and some parts of the CLI compiler. This interface will be incomplete if your plugin is producing top level declarations that are typealiases, functions, or properties. For the above cases, we would need to combine it or entirely replace it with a packageFragmentProvider that can provide descriptors for those top level declarations. |
| syntheticScopes | [jvm] open fun syntheticScopes(syntheticConstructor: CompilerContext.(constructor: ConstructorDescriptor) -> ConstructorDescriptor? = Noop.nullable2(), syntheticConstructors: CompilerContext.(classifierDescriptors: Collection<DeclarationDescriptor>) -> Collection<FunctionDescriptor> = Noop.emptyCollection2(), syntheticConstructorsForName: CompilerContext.(contributedClassifier: ClassifierDescriptor, location: LookupLocation) -> Collection<FunctionDescriptor> = Noop.emptyCollection3(), syntheticExtensionProperties: CompilerContext.(receiverTypes: Collection<KotlinType>, location: LookupLocation) -> Collection<PropertyDescriptor> = Noop.emptyCollection3(), syntheticExtensionPropertiesForName: CompilerContext.(receiverTypes: Collection<KotlinType>, name: Name, location: LookupLocation) -> Collection<PropertyDescriptor> = Noop.emptyCollection4(), syntheticMemberFunctions: CompilerContext.(receiverTypes: Collection<KotlinType>) -> Collection<FunctionDescriptor> = Noop.emptyCollection2(), syntheticMemberFunctionsForName: CompilerContext.(receiverTypes: Collection<KotlinType>, name: Name, location: LookupLocation) -> Collection<FunctionDescriptor> = Noop.emptyCollection4(), syntheticStaticFunctions: CompilerContext.(functionDescriptors: Collection<DeclarationDescriptor>) -> Collection<FunctionDescriptor> = Noop.emptyCollection2(), syntheticStaticFunctionsForName: CompilerContext.(contributedFunctions: Collection<FunctionDescriptor>, location: LookupLocation) -> Collection<FunctionDescriptor> = Noop.emptyCollection3()): ExtensionPhase The syntheticScopes function encapsulates a powerful interface that lets you peak and modify the resolution scope of constructors, extension functions, properties, and static functions. Altering the synthetic scope, we can provide our own descriptors to IntelliJ. These descriptors are required for IntelliJ IDEA to enable synthetic generated code required by IDE features such as autocompletion and code refactoring. |
| updateConfig | [jvm] open fun updateConfig(updateConfiguration: CompilerContext.(configuration: CompilerConfiguration) -> Unit): Config The updateConfig function provides access to the CompilerConfiguration that contains the map of properties used to enable/disable the different features in compilation. |
Properties
| Name | Summary |
|---|---|
| supportsK2 | [jvm] open override val supportsK2: Boolean = false |