@Imran/Malic @danieeh @aballano @Joachim Ansorg The deadlock is resolved when I move initializations of proofs outside to each place where a new resolution facade is created: No need to worry about that now. https://github.com/arrow-kt/arrow-meta/blob/591a5eedfb8594d89b3a9048a8627084b78f23e3/idea-plugin/src/main/kotlin/arrow/meta/ide/plugins/proofs/resolve/ProofsKotlinCacheService.kt#L27

Hey! Is there a MetaExtension that would allow me to apply transformations to compiler generated methods?

Anyone else having problems debugging projects that use the arrow meta? Specifically the line number information gets changed which makes it impossible to properly set breakpoints. This can easily be seen in https://github.com/arrow-kt/arrow-meta-examples/tree/master/hello-world. After building you can inspect the bytecode using

javap -c -l use-plugin/build/classes/../HelloWorldKt.class

Looking at the line information you see that it no longer matches the source file.

Also I keep getting this warning when building and I can’t seem to figure out how to get rid of it

> Task :use-plugin:compileKotlin

w: Some JAR files in the classpath have the Kotlin Runtime library bundled into them. This may cause difficult to debug problems if there’s a different version of the Kotlin Runtime library in the classpath. Consider removing these libraries from the classpath

w: /Users/burkhard/Projects/Kotlin/arrow-meta-examples/hello-world/create-plugin/build/libs/create-plugin-all.jar: Library has Kotlin runtime bundled into it

Is it possible to replace all annotation processing done in kapt, with arrow-meta?

Are there stable releases available somewhere or am I meant to use the snapshots? Also where is the gradle plugin referenced in the Quick Start hosted? None of the plugins seem to be available from the gradle plugins portal. Do I need the gradle plugin or can I just use the arrow-meta library hosted at Maven Central?

Hi, I’m trying to define a plugin for IntelliJ but I cannot find the dependency for the

arrow.meta.plugin.idea

package so I cannot find the definition for

IdeMetaPlugin

. Thanks

Is there a good multiplatform meta sample anywhere? Having trouble understanding how to wire things together on my own based on the hello world sample.

Hello everyone. Since mocking is next to impossible in Kotlin native, the next best option is to write mocks by hand. I'm looking to lean on compiler Plugin to automate this. The idea is to generate code only for the

commonTest

dependency. I'm aware there will be limitations with this compared to mocking frameworks. I'm a complete newbie when it comes to compiler plugins and arrow meta. I've watched a few conference talks on the topic but that's about it. My question is: Is everything required for such a plugin already available? Or is it better to wait until 1.4? For example, I think IR might not be needed in this case because it looks like I want my plugin to generate Kotlin code. Also, how about an IDE plugin? Would that be required for this scenario?

Good morning. Is the syntax <STRING> <BLOCK>

"name" { /* ... */ }

like in https://github.com/arrow-kt/arrow-meta-examples/blob/master/hello-world/create-plugin/src/main/kotlin/io/arrowkt/example/HelloWorldPlugin.kt#L11 a standard Kotlin syntax or something that is added by ΛRROW Meta?

Is there a directory of compiler plug-ins written with ΛRROW Meta, besides the "hello world" example?

Is code generation only text-based, as opposed to AST-based, currently? Or is it just the most common method in use?

I'm interested in making a simple KEEP-87 inspired implicit dependency injection plugin, but I'm not sure where to start Basically, if a primary constructor is called with missing parameters, any parameters marked with @Dependency will be filled in with variables in the environment of the same type, that are also marked with @Dependency. (Example attached) I tried playing around with irConstructorCall, but couldn't get that to be called (will I have to wait for Kotlin 1.4 for IR?). And from there, I'm not sure how to transform the constructor call to find missing arguments, or how to find variables I can use

Is it possible to use some code generated with ΛRROW Meta (with

Transform.newSources

) in the same module upon which ΛRROW Meta was applied to generate it? As an example, I'm generating a wrapper class with this transformation

classDeclaration(isAnnotatedWith<Cool>()) { c ->
    Transform.newSources(
        """|package ${c.packageName}.cool
           |                       
           |class Cool${c.name}(val value : ${c.fullyQualifiedName})
           |""".trimMargin().file("cool.kt")
    )
}

Can I configure gradle and IDEA to use this class definition in the module where I apply my plugin? The problem that I see is that the content of the kapt folder is made of both new source files and modified source files.

When inspecting the

valueParameters

of the

primaryConstructor

ot a

KtClass

in a ΛRROW Meta transformation, is it normal to find the

typeReference.name

to be

null

and to have to use

text

, instead, to find the type of the parameter (

Int

, in my case)?

Hello, again. I'm trying to make my first useful plugin. It implements inline serialization for data classes with only one

val

parameter. The code can be found here: https://github.com/mel4tonin4/inline-serialization-plugin/tree/master The plugin operates on classes marked with a custom

@InlineSerializable

annotation. Currently, the serializer classes are generated and the original classes seems to be annotated with a

Serializable(with=)

decoration pointing to the serializer class... but not quite. If I enable

metadebug

I get a source file with the annotated class, but in the same kapt directory there is a file with a non-annotated class and if I try to use the class in another library, there is no

serializer()

method. Here is the content of the kapt directory: https://gist.github.com/mel4tonin4/1605d28e9bd2471c5bfb013b2d31f0ef I enabled

metadebug

only on one of the classes. Why are ChannelCount.kt.meta and ChannelCount.kt not the same?

And if I can't use Meta in my application, at the moment, it makes no sense for me to invest time in learning it now, obviously.

Can we infer that a branched expression with two different types

A

and

B

has a type

Either<A, B>

and compile it accordingly, by inserting the calls to

left()

and

right(),

with an ΛRROW Meta plug-in? Would that cause any problems?

I looked into the ΛRROW Meta issue tracker and it seems that ΛRROW Meta does not work at all with Kotlin 1.3.70+: https://github.com/arrow-kt/arrow-meta/issues/554 Notes for other people approaching ΛRROW Meta naively, like me: •

arrow-meta-compiler-plugin

version

1.3.70-SNAPSHOT

does not exist, so don't waste time looking for it based on the discussions on Slack. • For updated information on the status of ΛRROW Meta, better check the issue tracker.

How can I manipulate the code after type checking? Can you point an example of a plug-in working at that stage?

How can I resolve the type of a KtProperty inside a meta plugin? I'm trying to do something like this but I don't know if I'm even calling the right API

val Meta.demoPlugin: CliPlugin get() = "Demo" {
    meta(
        property({ true }) { ktProperty ->
            val type = ktProperty.typeReference?.name // name is null
            Transform.empty
        }
    )
}

Hey! I'm trying to check the type of a property from within a

namedFunction

block, however,

kotlinType

requires a

BindingContext

, where can I get its instance from?

namedFunction({ ... }) { c ->
    c!!containingClass().getProperties()[0].kotlinType()
}

specifically knowing the name of the class and the names of its type arguments

Hi meta folks 👋, Ive been working hard on the later chapters of the FP in Kotlin book and am deep into higher kinded type territory 😁 I've written all the code samples using the

Kind

interface, surrogate types, boilerplate etc. Is there an easier way to express HKTs with Arrow Meta yet? I remember there being some talk about making them easier to use with Arrow Meta in the past, but just not sure if this has progressed at all.

Curious if I'm missing something: When trying to build meta via the readme instructions gradle appears to hang?

./gradlew buildMeta -Dorg.gradle.debug=true
Starting a Gradle Daemon (subsequent builds will be faster)

> Starting Daemon

After 20 minutes it doesn't appear to proceed any further. Perhaps I'm missing something?

I am fiddling a bit going through predicates to determine whether a certain PsiElement meets some conditions. Is there any way to write some small tests where I can play with instantiated PsiElements in order to inspect them and test my predicates?

I'm tinkering with tests in Meta. It looks like

data class

is not supported for source code? If I have a test like this:

@Test
  fun `destructuring example`() {
    assertThis(CompilerTest(
      config = {
        metaDependencies
      },
      code = {
        """|data class Person(val firstName: String, val lastName: String, val age: Int)
           |
           |val person = Person("Matt", "Moore", 100)
           |val (firstName, lastName, age) = person
           |""".source
      },
      assert = {
        allOf(
          "firstName".source.evalsTo("Matt"),
          "lastName".source.evalsTo("Moore"),
          "age".source.evalsTo(100)
        )
      }
    ))
  }

The code snippet fails to compile. Removing the

data

keyword succeeds, but then there are no

componentN

functions generated for destructuring.

Curious, there doesn't appear to be a meta expression for matching a

KtCallExpression

node. Is

KtCallExpression

is related in any way to

KtCallableReferenceExpression

? I quickly put together a branch to add a meta matcher for

String.callExpression

but noticed when I got to the

KtPsiFactory

that there is no method there for creating a

KtCallExpression

. Which leads me to believe this is not possible at the moment since PSI might not support it? Example of what I'm talking about: https://github.com/arrow-kt/arrow-meta/compare/master...mattmoore:call-expressions?diff=unified#diff-2ab9610fb1adf0fd2d58e144d4097e56R122 Perhaps there's another way to hook into

KtCallExpression

that I'm overlooking...