Add GenerateBuiltInsTest

Tests that generated sources of built-ins (Functions, Ranges, etc.) are
up-to-date

generators/src/org/jetbrains/jet/generators/builtins/common.kt

@@ -18,10 +18,6 @@ package org.jetbrains.jet.generators.builtins
 
 import org.jetbrains.jet.generators.builtins.ProgressionKind.*
 
-trait BuiltInsSourceGenerator {
-    fun generate(): Unit
-}
-
 enum class ProgressionKind {
     BYTE
     CHAR

generators/src/org/jetbrains/jet/generators/builtins/functions.kt

@@ -18,7 +18,7 @@ package org.jetbrains.jet.generators.builtins.functions
 
 import java.io.PrintWriter
 import org.jetbrains.jet.generators.builtins.functions.FunctionKind.*
-import org.jetbrains.jet.generators.builtins.*
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.*
 
 val MAX_PARAM_COUNT = 22
 
@@ -40,7 +40,7 @@ enum class FunctionKind(
     fun getSuperClassName(i: Int) = superClassNamePrefix?.plus(i)
 }
 
-abstract class GenerateFunctionsBase(val out: PrintWriter, val kind: FunctionKind): BuiltInsSourceGenerator {
+abstract class GenerateFunctionsBase(out: PrintWriter, val kind: FunctionKind): BuiltInsSourceGenerator(out) {
     fun generateTypeParameters(i: Int, variance: Boolean) {
         out.print("<")
         if (kind.hasReceiverParameter) {
@@ -59,7 +59,7 @@ abstract class GenerateFunctionsBase(val out: PrintWriter, val kind: FunctionKin
 }
 
 class GenerateFunctions(out: PrintWriter, kind: FunctionKind) : GenerateFunctionsBase(out, kind) {
-    override fun generate() {
+    override fun generateBody() {
         for (i in 0..MAX_PARAM_COUNT) {
             out.print("public trait " + kind.getClassName(i))
             generateTypeParameters(i, true)
@@ -103,7 +103,7 @@ class GenerateFunctions(out: PrintWriter, kind: FunctionKind) : GenerateFunction
 }
 
 class GenerateFunctionsImpl(out: PrintWriter, kind: FunctionKind) : GenerateFunctionsBase(out, kind) {
-    override fun generate() {
+    override fun generateBody() {
         for (i in 0..MAX_PARAM_COUNT) {
             out.print("public abstract class " + kind.getImplClassName(i))
             generateTypeParameters(i, true)

generators/src/org/jetbrains/jet/generators/builtins/generateBuiltIns.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.generators.builtins
+package org.jetbrains.jet.generators.builtins.generateBuiltIns
 
 import org.jetbrains.jet.generators.builtins.functions.*
 import org.jetbrains.jet.generators.builtins.iterators.*
@@ -23,55 +23,49 @@ import org.jetbrains.jet.generators.builtins.progressions.*
 import org.jetbrains.jet.generators.builtins.ranges.*
 import java.io.PrintWriter
 import java.io.File
-import kotlin.properties.Delegates
 
-fun existingDirectory(path: String): File {
+fun assertExists(file: File): Unit =
-    val result = File(path)
+        if (!file.exists()) error("Output dir does not exist: ${file.getAbsolutePath()}")
-    if (!result.exists()) {
-        throw IllegalStateException("Output dir does not exist: ${result.getAbsolutePath()}")
-    }
-    return result
-}
 
-val BUILT_INS_DIR: File by Delegates.lazy { existingDirectory("core/builtins/src/jet/") }
+val BUILT_INS_DIR = File("core/builtins/src/jet/")
-val RUNTIME_JVM_DIR: File by Delegates.lazy { existingDirectory("core/runtime.jvm/src/jet/") }
+val RUNTIME_JVM_DIR = File("core/runtime.jvm/src/jet/")
 
-fun generateFile(dir: File, name: String, generator: (PrintWriter) -> BuiltInsSourceGenerator) {
+abstract class BuiltInsSourceGenerator(val out: PrintWriter) {
-    val file = File(dir, name)
+    protected abstract fun generateBody(): Unit
-    println("generating $file")
+
-    PrintWriter(file) use {
+    final fun generate() {
-        fileHeader(it)
+        out.println(File("injector-generator/copyright.txt").readText())
-        generator(it).generate()
+        // Don't include generator class name in the message: these are built-in sources,
+        // and we don't want to scare users with any internal information about our project
+        out.println("// Auto-generated file. DO NOT EDIT!")
+        out.println()
+        out.println("package jet")
+        out.println()
+
+        generateBody()
     }
 }
 
-fun fileHeader(out: PrintWriter) {
+fun generateBuiltIns(generate: (File, (PrintWriter) -> BuiltInsSourceGenerator) -> Unit) {
-    out.println(File("injector-generator/copyright.txt").readText())
+    assertExists(BUILT_INS_DIR)
-    // Don't include generator class name in the message: these are built-in sources,
+    assertExists(RUNTIME_JVM_DIR)
-    // and we don't want to scare users with any internal information about our project
-    out.println("// Auto-generated file. DO NOT EDIT!")
-    out.println()
-    out.println("package jet")
-    out.println()
-}
-
-
-fun main(args: Array<String>) {
-    fun generateBuiltInFile(name: String, generator: (PrintWriter) -> BuiltInsSourceGenerator) {
-        generateFile(BUILT_INS_DIR, name, generator)
-    }
-
-    fun generateRuntimeJvmFile(name: String, generator: (PrintWriter) -> BuiltInsSourceGenerator) {
-        generateFile(RUNTIME_JVM_DIR, name, generator)
-    }
 
     for (kind in FunctionKind.values()) {
-        generateBuiltInFile(kind.getFileName()) { GenerateFunctions(it, kind) }
+        generate(File(BUILT_INS_DIR, kind.getFileName())) { GenerateFunctions(it, kind) }
-        generateRuntimeJvmFile(kind.getImplFileName()) { GenerateFunctionsImpl(it, kind) }
+        generate(File(RUNTIME_JVM_DIR, kind.getImplFileName()), { GenerateFunctionsImpl(it, kind) })
     }
 
-    generateBuiltInFile("Iterators.kt") { GenerateIterators(it) }
+    generate(File(BUILT_INS_DIR, "Iterators.kt")) { GenerateIterators(it) }
-    generateBuiltInFile("ProgressionIterators.kt") { GenerateProgressionIterators(it) }
+    generate(File(BUILT_INS_DIR, "ProgressionIterators.kt")) { GenerateProgressionIterators(it) }
-    generateBuiltInFile("Progressions.kt") { GenerateProgressions(it) }
+    generate(File(BUILT_INS_DIR, "Progressions.kt")) { GenerateProgressions(it) }
-    generateBuiltInFile("Ranges.kt") { GenerateRanges(it) }
+    generate(File(BUILT_INS_DIR, "Ranges.kt")) { GenerateRanges(it) }
+}
+
+fun main(args: Array<String>) {
+    generateBuiltIns { file, generator ->
+        println("generating $file")
+        PrintWriter(file) use {
+            generator(it).generate()
+        }
+    }
 }

generators/src/org/jetbrains/jet/generators/builtins/iterators.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.generators.builtins.iterators
 
-import org.jetbrains.jet.generators.builtins.*
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.*
 import java.io.PrintWriter
 
 enum class IteratorKind {
@@ -32,8 +32,8 @@ enum class IteratorKind {
     val capitalized: String get() = name().toLowerCase().capitalize()
 }
 
-class GenerateIterators(val out: PrintWriter) : BuiltInsSourceGenerator {
+class GenerateIterators(out: PrintWriter) : BuiltInsSourceGenerator(out) {
-    override fun generate() {
+    override fun generateBody() {
         for (kind in IteratorKind.values()) {
             val s = kind.capitalized
             out.println("public abstract class ${s}Iterator : Iterator<$s> {")

generators/src/org/jetbrains/jet/generators/builtins/progressionIterators.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.generators.builtins.progressionIterators
 
 import org.jetbrains.jet.generators.builtins.*
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.*
 import org.jetbrains.jet.generators.builtins.ProgressionKind.*
 import java.io.PrintWriter
 
@@ -66,8 +67,8 @@ fun floatingPointProgressionIterator(kind: ProgressionKind): String {
 }"""
 }
 
-class GenerateProgressionIterators(val out: PrintWriter) : BuiltInsSourceGenerator {
+class GenerateProgressionIterators(out: PrintWriter) : BuiltInsSourceGenerator(out) {
-    override fun generate() {
+    override fun generateBody() {
         out.println("import jet.runtime.ProgressionUtil")
         out.println()
         for (kind in ProgressionKind.values()) {

generators/src/org/jetbrains/jet/generators/builtins/progressions.kt

@@ -17,11 +17,12 @@
 package org.jetbrains.jet.generators.builtins.progressions
 
 import org.jetbrains.jet.generators.builtins.*
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.*
 import org.jetbrains.jet.generators.builtins.ProgressionKind.*
 import java.io.PrintWriter
 
-class GenerateProgressions(val out: PrintWriter) : BuiltInsSourceGenerator {
+class GenerateProgressions(out: PrintWriter) : BuiltInsSourceGenerator(out) {
-    override fun generate() {
+    override fun generateBody() {
         for (kind in ProgressionKind.values()) {
             val t = kind.capitalized
             val progression = "${t}Progression"

generators/src/org/jetbrains/jet/generators/builtins/ranges.kt

@@ -17,11 +17,12 @@
 package org.jetbrains.jet.generators.builtins.ranges
 
 import org.jetbrains.jet.generators.builtins.*
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.*
 import org.jetbrains.jet.generators.builtins.ProgressionKind.*
 import java.io.PrintWriter
 
-class GenerateRanges(val out: PrintWriter) : BuiltInsSourceGenerator {
+class GenerateRanges(out: PrintWriter) : BuiltInsSourceGenerator(out) {
-    override fun generate() {
+    override fun generateBody() {
         for (kind in ProgressionKind.values()) {
             val t = kind.capitalized
             val range = "${t}Range"

generators/tests/org/jetbrains/jet/generators/builtins/GenerateBuiltInsTest.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.generators.builtins.test
+
+import java.io.PrintWriter
+import org.jetbrains.jet.generators.builtins.generateBuiltIns.generateBuiltIns
+import java.io.StringWriter
+import com.intellij.openapi.util.text.StringUtil
+import com.intellij.openapi.util.io.FileUtil
+import junit.framework.Assert
+import com.intellij.testFramework.UsefulTestCase
+
+class GenerateBuiltInsTest : UsefulTestCase() {
+    fun testBuiltInsAreUpToDate() {
+        generateBuiltIns { file, generator ->
+            val sw = StringWriter()
+            PrintWriter(sw) use {
+                generator(it).generate()
+            }
+
+            val expected = StringUtil.convertLineSeparators(sw.toString().trim())
+            val actual = StringUtil.convertLineSeparators(FileUtil.loadFile(file).trim())
+
+            Assert.assertEquals("To fix this problem you need to regenerate built-ins (run generateBuiltIns.kt)", expected, actual)
+        }
+    }
+}