script parameters

still a lot of things to do

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Severity;
 import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -170,7 +171,7 @@ public class JetTestUtils {
     }
 
     public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace) {
-        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace,
+        return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, Collections.<AnalyzerScriptParameter>emptyList(),
                 CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true));
     }
 

compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
@@ -106,7 +107,8 @@ public class CheckerTestUtilTest extends JetLiteFixture {
 
         public void test(final @NotNull PsiFile psiFile) {
             BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
-                    (JetFile) psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
+                    (JetFile) psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
+                    CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true))
                         .getBindingContext();
 
             String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile)).toString();

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java

@@ -31,6 +31,7 @@ import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -38,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 
 import java.io.File;
 import java.nio.charset.Charset;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -171,7 +173,10 @@ public class JetDiagnosticsTest extends JetLiteFixture {
         }
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                getProject(), jetFiles, Predicates.<PsiFile>alwaysTrue(), myEnvironment.getCompilerDependencies()).getBindingContext();
+                getProject(), jetFiles, Collections.<AnalyzerScriptParameter>emptyList(),
+                Predicates.<PsiFile>alwaysTrue(),
+                myEnvironment.getCompilerDependencies())
+                    .getBindingContext();
 
         boolean ok = true;
 

compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -86,7 +87,8 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                psiFile, jetCoreEnvironment.getCompilerDependencies())
+                psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
+                jetCoreEnvironment.getCompilerDependencies())
                     .getBindingContext();
         return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test")));
     }

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

@@ -26,13 +26,19 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.ref.JetTypeName;
 import org.jetbrains.jet.parsing.JetParsingTest;
+import org.objectweb.asm.Type;
 
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -143,15 +149,56 @@ public abstract class CodegenTestCase extends UsefulTestCase {
         assertEquals(myFile.getExpectedValue(), actual);
     }
 
+    @NotNull
+    private Class<?> loadClassFromType(@NotNull Type type) {
+        try {
+            switch (type.getSort()) {
+                case Type.OBJECT:
+                    return Class.forName(type.getClassName());
+                case Type.INT:
+                    return int.class;
+                case Type.LONG:
+                    return long.class;
+                default:
+                    // AFAIK there is no way to create array class from class
+                    if (type.getDescriptor().equals("[Ljava/lang/String;")) {
+                        return String[].class;
+                    }
+                    throw new IllegalStateException("not implemented: " + type.getDescriptor());
+            }
+        }
+        catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private Constructor getConstructor(@NotNull Class<?> clazz, org.objectweb.asm.commons.Method method) {
+        if (!method.getName().equals("<init>")) {
+            throw new IllegalArgumentException("not constructor: " + method);
+        }
+        Class[] classes = new Class[method.getArgumentTypes().length];
+        for (int i = 0; i < classes.length; ++i) {
+            classes[i] = loadClassFromType(method.getArgumentTypes()[i]);
+        }
+        try {
+            return clazz.getConstructor(classes);
+        }
+        catch (NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     @NotNull
     protected String blackBox() throws Exception {
-        ClassFileFactory codegens = generateClassesInFile();
-        GeneratedClassLoader loader = createClassLoader(codegens);
+        GenerationState state = generateClassesInFileGetState();
+        GeneratedClassLoader loader = createClassLoader(state.getFactory());
 
         try {
             if (myFile.getPsiFile().isScript()) {
                 Class<?> scriptClass = loader.loadClass("Script");
-                Object scriptInstance = scriptClass.newInstance();
+
+                Constructor constructor = getConstructor(scriptClass, state.getScriptConstructorMethod());
+                Object scriptInstance = constructor.newInstance(myFile.getScriptParameterValues().toArray());
                 Field field = scriptClass.getDeclaredField("rv");
                 field.setAccessible(true);
                 Object result = field.get(scriptInstance);
@@ -183,7 +230,8 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) {
         final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                myFile.getPsiFile(), myEnvironment.getCompilerDependencies());
+                myFile.getPsiFile(), myFile.getScriptParameterTypes(),
+                myEnvironment.getCompilerDependencies());
         analyzeExhaust.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
         GenerationState state = new GenerationState(myEnvironment.getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile.getPsiFile()));
@@ -226,14 +274,22 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     @NotNull
     protected ClassFileFactory generateClassesInFile() {
+        GenerationState generationState = generateClassesInFileGetState();
+        return generationState.getFactory();
+    }
+
+    @NotNull
+    private GenerationState generateClassesInFileGetState() {
+        GenerationState generationState;
         try {
             ClassBuilderFactory classBuilderFactory = ClassBuilderFactories.binaries(false);
 
-            return generateCommon(classBuilderFactory).getFactory();
+            generationState = generateCommon(classBuilderFactory);
         } catch (RuntimeException e) {
             System.out.println(generateToText());
             throw e;
         }
+        return generationState;
     }
 
     protected Method generateFunction() {

compiler/tests/org/jetbrains/jet/codegen/CodegenTestFile.java

@@ -16,11 +16,17 @@
 
 package org.jetbrains.jet.codegen;
 
+import com.google.common.collect.Lists;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.ref.JetTypeName;
 
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -33,10 +39,20 @@ public class CodegenTestFile {
     private final JetFile psiFile;
     @NotNull
     private final String expectedValue;
+    @NotNull
+    private final List<AnalyzerScriptParameter> scriptParameterTypes;
+    @NotNull
+    private final List<Object> scriptParameterValues;
 
-    private CodegenTestFile(@NotNull JetFile psiFile, @NotNull String expectedValue) {
+    private CodegenTestFile(
+            @NotNull JetFile psiFile,
+            @NotNull String expectedValue,
+            @NotNull List<AnalyzerScriptParameter> scriptParameterTypes,
+            @NotNull List<Object> scriptParameterValues) {
         this.psiFile = psiFile;
         this.expectedValue = expectedValue;
+        this.scriptParameterTypes = scriptParameterTypes;
+        this.scriptParameterValues = scriptParameterValues;
     }
 
     @NotNull
@@ -50,12 +66,56 @@ public class CodegenTestFile {
     }
 
     @NotNull
-    public static CodegenTestFile create(@NotNull String name, @NotNull String content, @NotNull Project project) {
-        JetFile file = (JetFile) JetTestUtils.createFile(name, content, project);
+    public List<AnalyzerScriptParameter> getScriptParameterTypes() {
+        return scriptParameterTypes;
+    }
+
+    @NotNull
+    public List<Object> getScriptParameterValues() {
+        return scriptParameterValues;
+    }
+
+    @NotNull
+    public static CodegenTestFile create(@NotNull String fileName, @NotNull String content, @NotNull Project project) {
+        JetFile file = (JetFile) JetTestUtils.createFile(fileName, content, project);
 
         Matcher matcher = Pattern.compile("// expected: (.*)").matcher(content);
         String expectedValue = matcher.find() ? matcher.group(1) : "OK";
 
-        return new CodegenTestFile(file, expectedValue);
+        List<AnalyzerScriptParameter> scriptParameterTypes = Lists.newArrayList();
+        List<Object> scriptParameterValues = Lists.newArrayList();
+
+        if (file.isScript()) {
+            Pattern scriptParametersPattern = Pattern.compile("param: (\\S+): (\\S+): (\\S.*)");
+            Matcher scriptParametersMatcher = scriptParametersPattern.matcher(file.getText());
+
+            while (scriptParametersMatcher.find()) {
+                String name = scriptParametersMatcher.group(1);
+                String type = scriptParametersMatcher.group(2);
+                String valueString = scriptParametersMatcher.group(3);
+                Object value;
+
+                if (type.equals("jet.String")) {
+                    value = valueString;
+                }
+                else if (type.equals("jet.Long")) {
+                    value = Long.parseLong(valueString);
+                }
+                else if (type.equals("jet.Int")) {
+                    value = Integer.parseInt(valueString);
+                }
+                else if (type.equals("jet.Array<jet.String>")) {
+                    value = valueString.split(" ");
+                }
+                else {
+                    throw new AssertionError("TODO");
+                }
+
+                scriptParameterTypes.add(new AnalyzerScriptParameter(Name.identifier(name), JetTypeName.parse(type)));
+                scriptParameterValues.add(value);
+            }
+        }
+
+        return new CodegenTestFile(file, expectedValue, scriptParameterTypes, scriptParameterValues);
     }
 }

compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java

@@ -22,13 +22,14 @@ import org.jetbrains.jet.cli.common.messages.MessageCollector;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.Collections;
 
 public class CompileTextTest extends CodegenTestCase {
     public void testMe() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
         createEnvironmentWithMockJdkAndIdeaAnnotations();
         String text = "import org.jetbrains.jet.codegen.CompileTextTest; fun x() = CompileTextTest()";
         K2JVMCompileEnvironmentConfiguration configuration = new K2JVMCompileEnvironmentConfiguration(
-                myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
+                myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR, false, Collections.<String>emptyList());
         configuration.getEnvironment().addToClasspathFromClassLoader(getClass().getClassLoader());
         ClassLoader classLoader = KotlinToJVMBytecodeCompiler.compileText(configuration, text);
         Class<?> namespace = classLoader.loadClass("namespace");

compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 
@@ -36,7 +37,8 @@ public class GenerationUtils {
 
     public static GenerationState compileFileGetGenerationStateForTest(JetFile psiFile, @NotNull CompilerSpecialMode compilerSpecialMode) {
         final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
-                psiFile, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
+                psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
+                CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true));
         analyzeExhaust.throwIfError();
         GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
         state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);

compiler/tests/org/jetbrains/jet/codegen/ScriptGenTest.java

@@ -42,4 +42,16 @@ public class ScriptGenTest extends CodegenTestCase {
         // TODO: check function is visible as instance field (it is currently not)
     }
 
+    public void testScriptParameter() {
+        blackBoxFile("script/parameter.ktscript");
+    }
+
+    public void testScriptParameterLong() {
+        blackBoxFile("script/parameterLong.ktscript");
+    }
+
+    public void testScriptParameterArray() {
+        blackBoxFile("script/parameterArray.ktscript");
+    }
+
 }

compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java

@@ -39,6 +39,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Collections;
 import java.util.Set;
 
 /**
@@ -87,7 +88,7 @@ public class TestlibTest extends CodegenTestCase {
             myEnvironment.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/kunit/src"));
 
             GenerationState generationState = KotlinToJVMBytecodeCompiler
-                    .analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR), false);
+                    .analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR, false, Collections.<String>emptyList()), false);
 
             if (generationState == null) {
                 throw new RuntimeException("There were compilation errors");

compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java

@@ -26,12 +26,14 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -77,7 +79,8 @@ public class DescriptorRendererTest extends JetLiteFixture {
         JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName));
         AnalyzeExhaust analyzeExhaust =
                 AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
-                        (JetFile) psiFile, myEnvironment.getCompilerDependencies());
+                        (JetFile) psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
+                        myEnvironment.getCompilerDependencies());
         final BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
         psiFile.acceptChildren(new JetVisitorVoid() {

compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -44,6 +45,7 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -152,8 +154,9 @@ public abstract class ExpectedResolveData {
         Project project = files.iterator().next().getProject();
         JetStandardLibrary lib = JetStandardLibrary.getInstance();
 
-        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files,
-                Predicates.<PsiFile>alwaysTrue(), jetCoreEnvironment.getCompilerDependencies());
+        AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Collections.<AnalyzerScriptParameter>emptyList(),
+                Predicates.<PsiFile>alwaysTrue(),
+                jetCoreEnvironment.getCompilerDependencies());
         BindingContext bindingContext = analyzeExhaust.getBindingContext();
         for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
             if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) {

compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -32,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -65,6 +67,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             JetDeclaration aClass = declarations.get(0);
             assert aClass instanceof JetClass;
             AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file,
+                    Collections.<AnalyzerScriptParameter>emptyList(),
                                                 myEnvironment.getCompilerDependencies());
             DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
             WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING);