Λrrow Meta

Package arrow.meta.quotes

Types

Quote	Quote Templates DSL`interface Quote<P : KtElement, K : KtElement, S>`
QuoteDefinition	`data class QuoteDefinition<P : KtElement, K : KtElement, S :` `Scope<K>>`
QuoteFactory	`class QuoteFactory<K : KtElement, S :` `Scope<K>> : Factory<KtElement, K, S>`
Scope	The property scope used in destructuring templates & the arrow.meta.phases.analysis.ElementScope DSL`open class Scope<out K : KtElement>`
ScopedList	`data class ScopedList<K : KtElement>`
SyntheticElement	`interface SyntheticElement`
Transform	The resulting action from matching on transformation`sealed class Transform<out K : KtElement>`
WhenScope	`open class WhenScope<out K : KtElement> :` `Scope<K>`

Extensions for External Classes

java.util.ArrayList
org.jetbrains.kotlin.descriptors.ClassDescriptor
org.jetbrains.kotlin.descriptors.DeclarationDescriptor
org.jetbrains.kotlin.descriptors.PackageViewDescriptor
org.jetbrains.kotlin.psi.KtClassOrObject
org.jetbrains.kotlin.psi.KtFile

Properties

META_DEBUG_COMMENT const val META_DEBUG_COMMENT: String

Functions

binaryExpression	`fun` `Meta.binaryExpression(ctx:` `CompilerContext, match: KtBinaryExpression.() ->` `Boolean, map:` `BinaryExpression.(KtBinaryExpression) ->` `Transform<KtBinaryExpression>):` `ExtensionPhase`
blockExpression	`fun` `Meta.blockExpression(ctx:` `CompilerContext, match: KtBlockExpression.() ->` `Boolean, map:` `BlockExpression.(KtBlockExpression) ->` `Transform<KtBlockExpression>):` `ExtensionPhase`
breakExpression	`fun` `Meta.breakExpression(ctx:` `CompilerContext, match: KtBreakExpression.() ->` `Boolean, map:` `BreakExpression.(KtBreakExpression) ->` `Transform<KtBreakExpression>):` `ExtensionPhase`
catchClause	`fun` `Meta.catchClause(ctx:` `CompilerContext, match: KtCatchClause.() ->` `Boolean, map:` `CatchClause.(KtCatchClause) ->` `Transform<KtCatchClause>):` `ExtensionPhase`
changeSource	`fun` `CompilerContext.changeSource(file: KtFile, newSource:` `String, rootFile: KtFile, sourcePath:` `String? = null): KtFile`
classBody	`fun` `Meta.classBody(ctx:` `CompilerContext, match: KtClassBody.() ->` `Boolean, map:` `ClassBody.(KtClassBody) ->` `Transform<KtClassBody>):` `ExtensionPhase`
classDeclaration	`fun` `Meta.classDeclaration(ctx:` `CompilerContext, match: KtClass.() ->` `Boolean, map:` `ClassDeclaration.(KtClass) ->` `Transform<KtClass>):` `ExtensionPhase`
continueExpression	`fun` `Meta.continueExpression(ctx:` `CompilerContext, match: KtContinueExpression.() ->` `Boolean, map:` `ContinueExpression.(KtContinueExpression) ->` `Transform<KtContinueExpression>):` `ExtensionPhase`
destructuringDeclaration	`fun` `Meta.destructuringDeclaration(ctx:` `CompilerContext, match: KtDestructuringDeclaration.() ->` `Boolean, map:` `DestructuringDeclaration.(KtDestructuringDeclaration) ->` `Transform<KtDestructuringDeclaration>):` `ExtensionPhase`
dotQualifiedExpression	`fun` `Meta.dotQualifiedExpression(ctx:` `CompilerContext, match: KtDotQualifiedExpression.() ->` `Boolean, map:` `DotQualifiedExpression.(KtDotQualifiedExpression) ->` `Transform<KtDotQualifiedExpression>):` `ExtensionPhase`
file	`fun` `Meta.file(ctx:` `CompilerContext, match: KtFile.() ->` `Boolean, map:` `File.(KtFile) ->` `Transform<KtFile>):` `ExtensionPhase`
finallySection	`fun` `Meta.finallySection(ctx:` `CompilerContext, match: KtFinallySection.() ->` `Boolean, map:` `FinallySection.(KtFinallySection) ->` `Transform<KtFinallySection>):` `ExtensionPhase`
fold	`fun <A, K : KtElement>` `ScopedList<K>.fold(a: A, f: (A, K) -> A): A`
foldIndexed	`fun <A, K : KtElement>` `ScopedList<K>.foldIndexed(a: A, f: (Int, A, K) -> A): A`
forExpression	`fun` `Meta.forExpression(ctx:` `CompilerContext, match: KtForExpression.() ->` `Boolean, map:` `ForExpression.(KtForExpression) ->` `Transform<KtForExpression>):` `ExtensionPhase`
functionLiteral	`fun` `Meta.functionLiteral(ctx:` `CompilerContext, match: KtFunctionLiteral.() ->` `Boolean, map:` `FunctionLiteral.(KtFunctionLiteral) ->` `Transform<KtFunctionLiteral>):` `ExtensionPhase`
get	`operator fun <A, B> A.get(field:` `String): B`
ifExpression	`fun` `Meta.ifExpression(ctx:` `CompilerContext, match: KtIfExpression.() ->` `Boolean, map:` `IfExpression.(KtIfExpression) ->` `Transform<KtIfExpression>):` `ExtensionPhase`
importDirective	`fun` `Meta.importDirective(ctx:` `CompilerContext, match: KtImportDirective.() ->` `Boolean, map:` `ImportDirective.(KtImportDirective) ->` `Transform<KtImportDirective>):` `ExtensionPhase`
isExpression	`fun` `Meta.isExpression(ctx:` `CompilerContext, match: KtIsExpression.() ->` `Boolean, map:` `IsExpression.(KtIsExpression) ->` `Transform<KtIsExpression>):` `ExtensionPhase`
lambdaExpression	`fun` `Meta.lambdaExpression(ctx:` `CompilerContext, match: KtLambdaExpression.() ->` `Boolean, map:` `LambdaExpression.(KtLambdaExpression) ->` `Transform<KtLambdaExpression>):` `ExtensionPhase`
many	`fun <K : KtElement> Many<K>.many(ktFile: KtFile, compilerContext:` `CompilerContext, match: K.() ->` `Boolean):` `Pair<File,` `MutableList<Pair<KtFile, File>>>`
map	`fun <K : KtElement>` `Scope<K>.map(f: (K) -> K):` `Scope<K>` `fun <K : KtElement>` `ScopedList<K>.map(f: (K) -> K?):` `ScopedList<K>`
namedFunction	`fun` `Meta.namedFunction(ctx:` `CompilerContext, match: KtNamedFunction.() ->` `Boolean, map:` `NamedFunction.(KtNamedFunction) ->` `Transform<KtNamedFunction>):` `ExtensionPhase`
newSource	`fun <K : KtElement> NewSource<K>.newSource():` `List<Pair<KtFile, File>>`
objectDeclaration	`fun` `Meta.objectDeclaration(ctx:` `CompilerContext, match: KtObjectDeclaration.() ->` `Boolean, map:` `ObjectDeclaration.(KtObjectDeclaration) ->` `Transform<KtObjectDeclaration>):` `ExtensionPhase`
orEmpty	`fun <K : KtElement>` `Scope<K>?.orEmpty():` `Scope<K>`
packageDirective	`fun` `Meta.packageDirective(ctx:` `CompilerContext, match: KtPackageDirective.() ->` `Boolean, map:` `PackageDirective.(KtPackageDirective) ->` `Transform<KtPackageDirective>):` `ExtensionPhase`
parameter	`fun` `Meta.parameter(ctx:` `CompilerContext, match: KtParameter.() ->` `Boolean, map:` `Parameter.(KtParameter) ->` `Transform<KtParameter>):` `ExtensionPhase`
plus	`operator fun <K : KtElement>` `ScopedList<K>.plus(k:` `ScopedList<K>):` `ScopedList<K>` `operator fun <K : KtElement>` `ScopedList<K>.plus(k:` `Scope<K>):` `ScopedList<K>` `operator fun <K : KtElement>` `Transform<K>.plus(transform:` `Transform<K>): Many<K>` `operator fun <K : KtElement> Many<K>.plus(transform:` `Transform<K>): Many<K>`
processContext	`fun <K : KtElement> processContext(source: KtFile, match: K.() ->` `Boolean): K?`
processFiles	`fun <K : KtElement, P : KtElement, S :` `Scope<K>> processFiles(files:` `Collection<KtFile>, quoteFactory: Factory<P, K, S>, match: K.() ->` `Boolean, map: S.(K) ->` `Transform<K>):` `List<Pair<KtFile,` `List<Transform<K>>>>`
processKtFile	`fun <K : KtElement, P : KtElement, S :` `Scope<K>> processKtFile(file: KtFile, quoteFactory: Factory<P, K, S>, match: K.() ->` `Boolean, map: S.(K) ->` `Transform<K>):` `Pair<KtFile,` `List<Transform<K>>>` `fun <K : KtElement, P : KtElement, S :` `Scope<K>> processKtFile(file: KtFile, on:` `Class<K>, quoteFactory: Factory<P, K, S>, match: K.() ->` `Boolean, map: S.(K) ->` `Transform<K>):` `Pair<KtFile,` `List<Transform<K>>>`
property	`fun` `Meta.property(ctx:` `CompilerContext, match: KtProperty.() ->` `Boolean, map:` `Property.(KtProperty) ->` `Transform<KtProperty>):` `ExtensionPhase`
propertyAccessor	`fun` `Meta.propertyAccessor(ctx:` `CompilerContext, match: KtPropertyAccessor.() ->` `Boolean, map:` `PropertyAccessor.(KtPropertyAccessor) ->` `Transform<KtPropertyAccessor>):` `ExtensionPhase`
quote	`fun <K : KtElement>` `Meta.quote(ctx:` `CompilerContext, match: K.() ->` `Boolean, map:` `Scope<K>.(K) ->` `Transform<K>):` `ExtensionPhase` `fun <K : KtElement, S :` `Scope<K>>` `Meta.quote(ctx:` `CompilerContext, match: K.() ->` `Boolean, map: S.(K) ->` `Transform<K>, transform: (K) -> S):` `ExtensionPhase` `fun <P : KtElement, K : KtElement, S :` `Scope<K>>` `Meta.quote(ctx:` `CompilerContext, quoteFactory: Factory<P, K, S>, match: K.() ->` `Boolean, map: S.(K) ->` `Transform<K>):` `ExtensionPhase`
remove	`fun <K : KtElement> Remove<K>.remove(file: File, context: PsiElement? = null): File`
replace	`fun <K : KtElement> Replace<K>.replace(file: File, context: PsiElement? = null): File`
returnExpression	`fun` `Meta.returnExpression(ctx:` `CompilerContext, match: KtReturnExpression.() ->` `Boolean, map:` `ReturnExpression.(KtReturnExpression) ->` `Transform<KtReturnExpression>):` `ExtensionPhase`
scope	`fun <K : KtElement> K?.scope():` `Scope<K>`
thisExpression	`fun` `Meta.thisExpression(ctx:` `CompilerContext, match: KtThisExpression.() ->` `Boolean, map:` `ThisExpression.(KtThisExpression) ->` `Transform<KtThisExpression>):` `ExtensionPhase`
throwExpression	`fun` `Meta.throwExpression(ctx:` `CompilerContext, match: KtThrowExpression.() ->` `Boolean, map:` `ThrowExpression.(KtThrowExpression) ->` `Transform<KtThrowExpression>):` `ExtensionPhase`
transformFile	`fun <K : KtElement>` `CompilerContext.transformFile(ktFile: KtFile, mutations:` `List<Transform<K>>, match: K.() ->` `Boolean):` `List<KtFile>`
tryExpression	`fun` `Meta.tryExpression(ctx:` `CompilerContext, match: KtTryExpression.() ->` `Boolean, map:` `TryExpression.(KtTryExpression) ->` `Transform<KtTryExpression>):` `ExtensionPhase`
typeAlias	`fun` `Meta.typeAlias(ctx:` `CompilerContext, match: KtTypeAlias.() ->` `Boolean, map:` `TypeAlias.(KtTypeAlias) ->` `Transform<KtTypeAlias>):` `ExtensionPhase`
typeReference	`fun` `Meta.typeReference(ctx:` `CompilerContext, match: KtTypeReference.() ->` `Boolean, map:` `TypeReference.(KtTypeReference) ->` `Transform<KtTypeReference>):` `ExtensionPhase`
updateFile	`fun <K : KtElement>` `CompilerContext.updateFile(mutations:` `List<Transform<K>>, file: KtFile, match: K.() ->` `Boolean):` `List<KtFile>`
updateFiles	`fun <K : KtElement>` `CompilerContext.updateFiles(result:` `ArrayList<KtFile>, fileMutations:` `List<Pair<KtFile,` `List<Transform<K>>>>, match: K.() ->` `Boolean):` `Unit`
valueArgument	”"”someObject.add(${argumentName = argumentExpression}.valueArgument)”””“`fun` `Meta.valueArgument(ctx:` `CompilerContext, match: KtValueArgument.() ->` `Boolean, map:` `ValueArgument.(KtValueArgument) ->` `Transform<KtValueArgument>):` `ExtensionPhase`
whenCondition	`fun` `Meta.whenCondition(ctx:` `CompilerContext, match: KtWhenCondition.() ->` `Boolean, map:` `WhenCondition.(KtWhenCondition) ->` `Transform<KtWhenCondition>):` `ExtensionPhase`
whenEntry	`fun` `Meta.whenEntry(ctx:` `CompilerContext, match: KtWhenEntry.() ->` `Boolean, map:` `WhenEntry.(KtWhenEntry) ->` `Transform<KtWhenEntry>):` `ExtensionPhase`
whenExpression	`fun` `Meta.whenExpression(ctx:` `CompilerContext, match: KtWhenExpression.() ->` `Boolean, map:` `WhenExpression.(KtWhenExpression) ->` `Transform<KtWhenExpression>):` `ExtensionPhase`
whileExpression	`fun` `Meta.whileExpression(ctx:` `CompilerContext, match: KtWhileExpression.() ->` `Boolean, map:` `WhileExpression.(KtWhileExpression) ->` `Transform<KtWhileExpression>):` `ExtensionPhase`