@ilya.chernikov Is there any working example for the https://github.com/Kotlin/KEEP/blob/master/proposals/script-definition-template.md ? (I know Gradle uses it, any other simple example?)

In particular, I can’t find any of these classes in

kotlin-compiler-embeddable-1.0.4-eap.jar

@cedric, the scripting api is only available in 1.1

I figured. I found some of the classes in 1.0.4 though but yes, nothing like what’s described in the KEEP

@cedric valid scripting support is in 1.1 only. M1 already has an usable implementation, but in the master it is developed further. As of examples - there are tests - https://github.com/JetBrains/kotlin/blob/master/compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest2.kt I also prepared (but not published yet) changes to spek with usage of scripting. And there is https://github.com/ligee/kotlin-jupyter which doesn’t use templates, but implements advanced resolving functionality.

@ilya.chernikov Thanks, these are great starting points. I can’t find 1.1 in the JetBrains repo though, where is it?

@cedric https://bintray.com/kotlin/kotlin-dev/kotlin

@cypher121 Thanks

@cedric if you need to look onto sources then 1.1 == master now.

@ilya.chernikov Yes, I’m using master to figure out how all this works

@User uploaded a file: and commented: it works!

@cypher121 but tokens are red, so IDE support doesn’t work yet, right?

Yeah, didn't bother too much about it yet

But just entering class name in kotlin compiler settings didn't help. Neither did adding built jar to the classpath

@ilya.chernikov What’s the mechanism for parsing a script first for references to plug-ins or jar files and then compiling it again with these jar files on the classpath?

annotation parsing seems VERY broken atm

given

@file:DependsOn(type = "jar", id = "test.jar", imports = emptyArray<String>(), dependencyResolvers = emptyArray<DependencyResolver>())

, dependencyResolvers is null

given

@file:DependsOn(id = "test.jar")

, everything, including

type

and

toString()

is "test.jar"

@cedric the provided mechanism, partly described in the KEEP, is to call resolver after parsing and pass file-level annotations to it. The resolver can analyse the annotations and provide additional classpath and imports. Then the compilation continues from this point with updated classpath. Another way implemented in gradle is two pass compilation.

@cypher121 there are some issues with non-trivial expressions there. I’d recommend to use simple params, e.g.

coordinates: String

, and parse it within the resolver.

About the IDE support - I’ll have a look.

looks like there's no way to use arrays yet, is there?

No, not yet.

that's a huge setback. hope it gets fixed soon.

@ilya.chernikov Yes I’m doing two pass compilation right now in Kobalt and probably will again with scripting, I was wondering if there was a better way. I’m not sure I understand the annotation-based approach and it’s not very well explained in the KEEP, can you elaborate?

@cedric, so basically you have a dependency resolver as a part of your template. You annotate its

resolve

method with a list of annotation classes you want to process, then get them from

ScriptContents.annotations

and process however you want. I don't have my own code at hand, but here's an examplehttps://github.com/ligee/kotlin-jupyter/blob/master/src/main/kotlin/org/jetbrains/kotlin/jupyter/resolve.kt#L20

Thanks for the example, looking

My problem is simple (and similar to Gradle):

val pl = plugins(“some:plugin:0.1”)

will cause the plug-in to be downloaded and the corresponding jar file needs to be added to the classpath before the rest of the script can be compiled. Is there any way to do this without a two-phase compilation?

I guess

@file:Plugin("some:plugin:0.1")
val pl = plugins("plugin")

might work

not a big fan of how it looks either, but I'll take that over two-pass