//arrow-meta/arrow.meta/Meta

Meta

[jvm]
interface Meta : ComponentRegistrar, 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

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.
[jvm]
open fun packageFragmentProvider(project: Project, 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 registerAnalysisHandler(project: Project, phase: AnalysisHandler, ctx: CompilerContext)
registerClassBuilder [jvm]
open fun registerClassBuilder(project: Project, phase: ClassBuilder, ctx: CompilerContext)
registerCodegen [jvm]
open fun registerCodegen(project: Project, phase: Codegen, ctx: CompilerContext)
registerCollectAdditionalSources [jvm]
open fun registerCollectAdditionalSources(project: Project, phase: CollectAdditionalSources, ctx: CompilerContext)
registerCompilerConfiguration [jvm]
open fun registerCompilerConfiguration(project: Project, phase: Config, ctx: CompilerContext)
registerDeclarationAttributeAlterer [jvm]
open fun registerDeclarationAttributeAlterer(project: Project, phase: DeclarationAttributeAlterer, ctx: CompilerContext)
registerExtraImports [jvm]
open fun registerExtraImports(project: Project, phase: ExtraImports, ctx: CompilerContext)
registerIRGeneration [jvm]
open fun registerIRGeneration(project: Project, phase: IRGeneration, compilerContext: CompilerContext)
registerMetaAnalyzer [jvm]
open fun registerMetaAnalyzer(): ExtensionPhase
registerMetaComponents [jvm]
open fun registerMetaComponents(project: Project, configuration: CompilerConfiguration, context: CompilerContext? = null)
registerPreprocessedVirtualFileFactory [jvm]
open fun registerPreprocessedVirtualFileFactory(project: Project, phase: PreprocessedVirtualFileFactory, ctx: CompilerContext)
registerProjectComponents [jvm]
open override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration)
CLI Compiler ComponentRegistrar entry point.
registerStorageComponentContainer [jvm]
open fun registerStorageComponentContainer(project: Project, phase: StorageComponentContainer, ctx: CompilerContext)
registerSyntheticResolver [jvm]
open fun registerSyntheticResolver(project: Project, phase: SyntheticResolver, compilerContext: CompilerContext)
registerSyntheticScopeProvider [jvm]
open fun registerSyntheticScopeProvider(project: Project, phase: SyntheticScopeProvider, ctx: CompilerContext)
registerSyntheticScopeProviderIfNeeded [jvm]
open fun registerSyntheticScopeProviderIfNeeded(project: Project)
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.

Do you like Arrow?

Arrow Org
<