Generate Injectors: rewrite facade to Kotlin

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -1,244 +0,0 @@
-/*
- * Copyright 2010-2013 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.injectors;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.context.GlobalContext;
-import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.di.DependencyInjectorGenerator;
-import org.jetbrains.jet.di.GivenExpression;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.calls.CallResolver;
-import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
-import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
-import org.jetbrains.jet.lang.resolve.java.resolver.*;
-import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-import org.jetbrains.jet.storage.StorageManager;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
-
-// NOTE: After making changes, you need to re-generate the injectors.
-//       To do that, you can run main in this class.
-public class GenerateInjectors {
-
-    private GenerateInjectors() {
-    }
-
-    public static void main(String[] args) throws Throwable {
-        for (DependencyInjectorGenerator generator : createGenerators()) {
-            try {
-                generator.generate();
-            }
-            catch (Throwable e) {
-                System.err.println(generator.getOutputFile());
-                throw e;
-            }
-        }
-    }
-
-    public static List<DependencyInjectorGenerator> createGenerators() throws IOException {
-        return Arrays.asList(
-                generateInjectorForTopDownAnalyzerBasic(),
-                generateInjectorForTopDownAnalyzerForJvm(),
-                generateInjectorForJavaDescriptorResolver(),
-                generateInjectorForTopDownAnalyzerForJs(),
-                generateMacroInjector(),
-                generateTestInjector(),
-                generateInjectorForLazyResolve(),
-                generateInjectorForBodyResolve()
-        );
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForLazyResolve() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-
-        generator.addParameter(Project.class);
-        generator.addParameter(GlobalContextImpl.class);
-        generator.addParameter(ModuleDescriptorImpl.class);
-        generator.addParameter(DeclarationProviderFactory.class);
-        generator.addParameter(BindingTrace.class);
-
-        generator.addPublicField(ResolveSession.class);
-
-        generator.addField(CallResolverExtensionProvider.class);
-        generator.addField(false, StorageManager.class, null, new GivenExpression("resolveSession.getStorageManager()"));
-        generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
-
-        generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForTopDownAnalyzerBasic() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-        generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
-        generator.addField(MutablePackageFragmentProvider.class);
-        generator.addParameter(PlatformToKotlinClassMap.class);
-        generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic", GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForTopDownAnalyzerForJs() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-        generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class);
-        generator.addField(MutablePackageFragmentProvider.class);
-        generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("org.jetbrains.jet.lang.PlatformToKotlinClassMap.EMPTY"));
-        generator.configure("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs", GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForTopDownAnalyzerForJvm() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-        generator.implementInterface(InjectorForTopDownAnalyzer.class);
-        generateInjectorForTopDownAnalyzerCommon(generator);
-        generator.addPublicField(JavaDescriptorResolver.class);
-        generator.addField(false, JavaToKotlinClassMap.class, null,
-                           new GivenExpression("org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap.getInstance()"));
-        generator.addField(JavaClassFinderImpl.class);
-        generator.addField(TraceBasedExternalSignatureResolver.class);
-        generator.addField(TraceBasedJavaResolverCache.class);
-        generator.addField(TraceBasedErrorReporter.class);
-        generator.addField(PsiBasedMethodSignatureChecker.class);
-        generator.addField(PsiBasedExternalAnnotationResolver.class);
-        generator.addField(MutablePackageFragmentProvider.class);
-        generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",
-                           new GivenExpression(
-                                   VirtualFileFinder.class.getName() + ".SERVICE.getInstance(project)"));
-        generator.configure("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm",
-                           GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForJavaDescriptorResolver() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-
-        // Parameters
-        generator.addParameter(Project.class);
-        generator.addParameter(BindingTrace.class);
-
-        // Fields
-        generator.addField(true, GlobalContextImpl.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"));
-        generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()"));
-        generator.addPublicField(JavaClassFinderImpl.class);
-        generator.addField(TraceBasedExternalSignatureResolver.class);
-        generator.addField(TraceBasedJavaResolverCache.class);
-        generator.addField(TraceBasedErrorReporter.class);
-        generator.addField(PsiBasedMethodSignatureChecker.class);
-        generator.addField(PsiBasedExternalAnnotationResolver.class);
-        generator.addPublicField(JavaDescriptorResolver.class);
-        generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",
-                           new GivenExpression(VirtualFileFinder.class.getName() + ".SERVICE.getInstance(project)"));
-        generator.addField(true, ModuleDescriptorImpl.class, "module",
-                           new GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"<fake-jdr-module>\")"));
-
-        generator.configure("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaDescriptorResolver",
-                            GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForTopDownAnalyzerCommon(DependencyInjectorGenerator generator) {
-        // Fields
-        generator.addPublicField(TopDownAnalyzer.class);
-        generator.addPublicField(TopDownAnalysisContext.class);
-        generator.addPublicField(BodyResolver.class);
-        generator.addPublicField(ControlFlowAnalyzer.class);
-        generator.addPublicField(DeclarationsChecker.class);
-        generator.addPublicField(DescriptorResolver.class);
-        generator.addField(false, StorageManager.class, null, new GivenExpression("topDownAnalysisParameters.getStorageManager()"));
-        generator.addField(CallResolverExtensionProvider.class);
-
-        // Parameters
-        generator.addPublicParameter(Project.class);
-        generator.addParameter(TopDownAnalysisParameters.class);
-        generator.addPublicParameter(BindingTrace.class);
-        generator.addPublicParameter(ModuleDescriptorImpl.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateMacroInjector() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-
-        // Fields
-        generator.addPublicField(ExpressionTypingServices.class);
-        generator.addField(CallResolverExtensionProvider.class);
-        generator.addField(false, GlobalContext.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"));
-        generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()"));
-        generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
-
-        // Parameters
-        generator.addPublicParameter(Project.class);
-        generator.addParameter(ModuleDescriptor.class);
-
-        generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros", GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateTestInjector() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-
-        // Fields
-        generator.addPublicField(DescriptorResolver.class);
-        generator.addPublicField(ExpressionTypingServices.class);
-        generator.addPublicField(TypeResolver.class);
-        generator.addPublicField(CallResolver.class);
-        generator.addField(CallResolverExtensionProvider.class);
-        generator.addField(false, StorageManager.class, null, new GivenExpression("globalContext.getStorageManager()"));
-        generator.addField(true, KotlinBuiltIns.class, null, new GivenExpression("KotlinBuiltIns.getInstance()"));
-        generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
-        generator.addField(false, GlobalContext.class, null, new GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"));
-
-        // Parameters
-        generator.addPublicParameter(Project.class);
-        generator.addParameter(ModuleDescriptor.class);
-
-        generator.configure("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", GenerateInjectors.class);
-        return generator;
-    }
-
-    private static DependencyInjectorGenerator generateInjectorForBodyResolve() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-        // Fields
-        generator.addPublicField(BodyResolver.class);
-        generator.addField(CallResolverExtensionProvider.class);
-        generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
-        generator.addField(FunctionAnalyzerExtension.class);
-        generator.addField(false, StorageManager.class, null, new GivenExpression("topDownAnalysisParameters.getStorageManager()"));
-
-        // Parameters
-        generator.addPublicParameter(Project.class);
-        generator.addParameter(TopDownAnalysisParameters.class);
-        generator.addPublicParameter(BindingTrace.class);
-        generator.addPublicParameter(BodiesResolveContext.class);
-        generator.addParameter(ModuleDescriptor.class);
-        generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve", GenerateInjectors.class);
-        return generator;
-    }
-}

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -0,0 +1,219 @@
+/*
+ * 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.injectors
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.jet.context.GlobalContext
+import org.jetbrains.jet.context.GlobalContextImpl
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl
+import org.jetbrains.jet.lang.resolve.*
+import org.jetbrains.jet.lang.resolve.calls.CallResolver
+import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider
+import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver
+import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap
+import org.jetbrains.jet.lang.resolve.java.resolver.*
+import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices
+import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+import org.jetbrains.jet.storage.StorageManager
+import org.jetbrains.jet.di.*
+import kotlin.properties.Delegates
+
+// NOTE: After making changes, you need to re-generate the injectors.
+//       To do that, you can run main in this file.
+public fun main(args: Array<String>) {
+    for (generator in injectorGenerators) {
+        try {
+            generator.generate()
+        }
+        catch (e: Throwable) {
+            System.err.println(generator.getOutputFile())
+            throw e
+        }
+    }
+}
+
+public val injectorGenerators: List<DependencyInjectorGenerator> by Delegates.lazy {
+    GenerateInjectors().generators
+}
+
+public class GenerateInjectors {
+
+    private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() {
+        publicFields(
+                javaClass<TopDownAnalyzer>(),
+                javaClass<TopDownAnalysisContext>(),
+                javaClass<BodyResolver>(),
+                javaClass<ControlFlowAnalyzer>(),
+                javaClass<DeclarationsChecker>(),
+                javaClass<DescriptorResolver>()
+        )
+        field(javaClass<StorageManager>(), init = GivenExpression("topDownAnalysisParameters.getStorageManager()"))
+        field(javaClass<CallResolverExtensionProvider>())
+
+        publicParameter(javaClass<Project>())
+        parameter(javaClass<TopDownAnalysisParameters>())
+        publicParameters(
+                javaClass<BindingTrace>(),
+                javaClass<ModuleDescriptorImpl>()
+        )
+    }
+
+    private val generatorForTopDownAnalyzerBasic =
+            generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic", javaClass<GenerateInjectors>()) {
+                commonForTopDownAnalyzer()
+                fields(
+                        javaClass<DependencyClassByQualifiedNameResolverDummyImpl>(),
+                        javaClass<MutablePackageFragmentProvider>()
+                )
+                parameter(javaClass<PlatformToKotlinClassMap>())
+            }
+
+    private val generatorForTopDownAnalyzerForJs =
+            generator("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs", javaClass<GenerateInjectors>()) {
+                commonForTopDownAnalyzer()
+                fields(
+                        javaClass<DependencyClassByQualifiedNameResolverDummyImpl>(),
+                        javaClass<MutablePackageFragmentProvider>()
+                )
+                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("org.jetbrains.jet.lang.PlatformToKotlinClassMap.EMPTY"))
+            }
+
+    private val generatorForTopDownAnalyzerForJvm =
+            generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm", javaClass<GenerateInjectors>()) {
+                implementInterface(javaClass<InjectorForTopDownAnalyzer>())
+                commonForTopDownAnalyzer()
+                publicField(javaClass<JavaDescriptorResolver>())
+                field(javaClass<JavaToKotlinClassMap>(), init = GivenExpression("org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap.getInstance()"))
+                fields(
+                        javaClass<JavaClassFinderImpl>(),
+                        javaClass<TraceBasedExternalSignatureResolver>(),
+                        javaClass<TraceBasedJavaResolverCache>(),
+                        javaClass<TraceBasedErrorReporter>(),
+                        javaClass<PsiBasedMethodSignatureChecker>(),
+                        javaClass<PsiBasedExternalAnnotationResolver>(),
+                        javaClass<MutablePackageFragmentProvider>()
+                )
+                field(javaClass<VirtualFileFinder>(), init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
+            }
+
+    private val generatorForJavaDescriptorResolver =
+            generator("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaDescriptorResolver", javaClass<GenerateInjectors>()) {
+
+                parameters(
+                        javaClass<Project>(),
+                        javaClass<BindingTrace>()
+                )
+
+                publicField(javaClass<GlobalContextImpl>(),
+                            init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
+                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
+                publicField(javaClass<JavaClassFinderImpl>())
+                fields(
+                        javaClass<TraceBasedExternalSignatureResolver>(),
+                        javaClass<TraceBasedJavaResolverCache>(),
+                        javaClass<TraceBasedErrorReporter>(),
+                        javaClass<PsiBasedMethodSignatureChecker>(),
+                        javaClass<PsiBasedExternalAnnotationResolver>()
+                )
+                publicField(javaClass<JavaDescriptorResolver>())
+                field(javaClass<VirtualFileFinder>(),
+                      init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
+                publicField(javaClass<ModuleDescriptorImpl>(), name = "module",
+                            init = GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"<fake-jdr-module>\")"))
+            }
+
+    private val generatorForMacro =
+            generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros", javaClass<GenerateInjectors>()) {
+                publicField(javaClass<ExpressionTypingServices>())
+                field(javaClass<CallResolverExtensionProvider>())
+                field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
+                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
+                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+
+                publicParameter(javaClass<Project>())
+                parameter(javaClass<ModuleDescriptor>())
+            }
+
+    private val generatorForTests =
+            generator("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", javaClass<GenerateInjectors>()) {
+                publicFields(
+                        javaClass<DescriptorResolver>(),
+                        javaClass<ExpressionTypingServices>(),
+                        javaClass<TypeResolver>(),
+                        javaClass<CallResolver>()
+                )
+                field(javaClass<CallResolverExtensionProvider>())
+                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
+                publicField(javaClass<KotlinBuiltIns>(), init = GivenExpression("KotlinBuiltIns.getInstance()"))
+                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+                field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
+
+                publicParameter(javaClass<Project>())
+                parameter(javaClass<ModuleDescriptor>())
+            }
+
+    private val generatorForBodyResolve =
+            generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve", javaClass<GenerateInjectors>()) {
+                publicField(javaClass<BodyResolver>())
+                field(javaClass<CallResolverExtensionProvider>())
+                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+                field(javaClass<FunctionAnalyzerExtension>())
+                field(javaClass<StorageManager>(), init = GivenExpression("topDownAnalysisParameters.getStorageManager()"))
+
+                publicParameter(javaClass<Project>())
+                parameter(javaClass<TopDownAnalysisParameters>())
+                publicParameters(
+                        javaClass<BindingTrace>(),
+                        javaClass<BodiesResolveContext>()
+                )
+                parameter(javaClass<ModuleDescriptor>())
+            }
+
+    private val generatorForLazyResolve =
+            generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", javaClass<GenerateInjectors>()) {
+                parameters(
+                        javaClass<Project>(),
+                        javaClass<GlobalContextImpl>(),
+                        javaClass<ModuleDescriptorImpl>(),
+                        javaClass<DeclarationProviderFactory>(),
+                        javaClass<BindingTrace>()
+                )
+
+                publicField(javaClass<ResolveSession>())
+                field(javaClass<CallResolverExtensionProvider>())
+                field(javaClass<StorageManager>(), init = GivenExpression("resolveSession.getStorageManager()"))
+                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+            }
+
+    val generators = listOf(
+            generatorForTopDownAnalyzerBasic,
+            generatorForTopDownAnalyzerForJvm,
+            generatorForJavaDescriptorResolver,
+            generatorForTopDownAnalyzerForJs,
+            generatorForMacro,
+            generatorForTests,
+            generatorForLazyResolve,
+            generatorForBodyResolve
+    )
+}

generators/tests/org/jetbrains/jet/generators/injectors/GenerateInjectorsTest.java

@@ -30,7 +30,7 @@ public class GenerateInjectorsTest extends TestCase {
 
     public static TestSuite suite() throws IOException {
         TestSuite suite = new TestSuite();
-        for (DependencyInjectorGenerator generator : GenerateInjectors.createGenerators()) {
+        for (DependencyInjectorGenerator generator : InjectorsPackage.getInjectorGenerators()) {
             suite.addTest(new GenerateInjectorsTest(generator));
         }
         return suite;

injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java

@@ -154,37 +154,6 @@ public class DependencyInjectorGenerator {
         implementsList.add(superInterface);
     }
 
-    public void addPublicParameter(Class<?> type) {
-        addPublicParameter(new DiType(type));
-    }
-
-    public void addPublicParameter(DiType type) {
-        addPublicParameter(type, true);
-    }
-
-    public void addPublicParameter(DiType type, boolean required) {
-        addParameter(true, type, var(type), required);
-    }
-
-
-    public void addParameter(Class<?> type) {
-        addParameter(DiType.fromReflectionType(type));
-    }
-
-    public void addParameter(DiType type) {
-        addParameter(type, true);
-    }
-
-    public void addParameter(Class<?> type, boolean required) {
-        addParameter(new DiType(type), required);
-    }
-
-    public void addParameter(DiType type, boolean required) {
-        addParameter(false, type, var(type), required);
-    }
-
-
-
     public void addParameter(boolean reexport, @NotNull DiType type, @Nullable String name, boolean required) {
         Field field = addField(reexport, type, name, null);
         Parameter parameter = new Parameter(type, name, field, required);
@@ -194,31 +163,6 @@ public class DependencyInjectorGenerator {
         dependencies.addSatisfiedField(field);
     }
 
-    public Field addPublicField(Class<?> type) {
-        return addPublicField(new DiType(type));
-    }
-
-    public Field addPublicField(DiType type) {
-        return addField(true, type, null, null);
-    }
-
-    public Field addField(Class<?> type) {
-        return addField(new DiType(type));
-    }
-
-    public Field addField(DiType type) {
-        return addField(false, type, null, null);
-    }
-
-    public Field addField(Enum<?> enu) {
-        Class<? extends Enum> clazz = enu.getClass();
-        return addField(false, clazz, null, new GivenExpression(clazz.getSimpleName() + "." + enu.name()));
-    }
-
-    public Field addField(boolean isPublic, Class<?> type, @Nullable String name, @Nullable Expression init) {
-        return addField(isPublic, new DiType(type), name, init);
-    }
-
     public Field addField(boolean isPublic, DiType type, @Nullable String name, @Nullable Expression init) {
         Field field = Field.create(isPublic, type, name == null ? var(type) : name, init);
         fields.add(field);

injector-generator/src/org/jetbrains/jet/di/Expression.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
 
-interface Expression {
+public interface Expression {
     @NotNull
     String renderAsCode();
 

injector-generator/src/org/jetbrains/jet/di/InjectorGeneratorFacade.kt

@@ -0,0 +1,68 @@
+/*
+ * 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.di
+
+public fun generator(
+        targetSourceRoot: String,
+        injectorPackageName: String,
+        injectorClassName: String,
+        generatorClass: Class<*>,
+        body: DependencyInjectorGenerator.() -> Unit
+): DependencyInjectorGenerator {
+    val generator = DependencyInjectorGenerator()
+    generator.configure(targetSourceRoot, injectorPackageName, injectorClassName, generatorClass)
+    generator.body()
+    return generator
+}
+
+public fun DependencyInjectorGenerator.field(
+        fieldType: Class<*>,
+        name: String = defaultName(fieldType),
+        init: Expression? = null
+) {
+    addField(false, DiType(fieldType), name, init)
+}
+
+public fun DependencyInjectorGenerator.publicField(
+        fieldType: Class<*>,
+        name: String = defaultName(fieldType),
+        init: Expression? = null
+) {
+    addField(true, DiType(fieldType), name, init)
+}
+
+public fun DependencyInjectorGenerator.fields(vararg types: Class<*>): Unit = types.forEach { field(it) }
+public fun DependencyInjectorGenerator.publicFields(vararg types: Class<*>): Unit = types.forEach { publicField(it) }
+
+public fun DependencyInjectorGenerator.parameter(
+        parameterType: Class<*>,
+        name: String = defaultName(parameterType)
+) {
+    addParameter(false, DiType(parameterType), name, true)
+}
+
+public fun DependencyInjectorGenerator.publicParameter(
+        parameterType: Class<*>,
+        name: String = defaultName(parameterType)
+) {
+    addParameter(true, DiType(parameterType), name, true)
+}
+
+public fun DependencyInjectorGenerator.parameters(vararg types: Class<*>): Unit = types.forEach { parameter(it) }
+public fun DependencyInjectorGenerator.publicParameters(vararg types: Class<*>): Unit = types.forEach { publicParameter(it) }
+
+private fun defaultName(entityType: Class<*>) = InjectorGeneratorUtil.`var`(DiType(entityType))

injector-generator/src/org/jetbrains/jet/di/InjectorGeneratorUtil.java

@@ -53,6 +53,7 @@ public class InjectorGeneratorUtil {
         return r;
     }
 
+    @NotNull
     public static String var(@NotNull DiType type) {
         StringBuilder sb = new StringBuilder();
         sb.append(StringUtil.decapitalize(type.getClazz().getSimpleName().replaceFirst("(?<=.)Impl$", "")));