azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Drop package facades: code cleanup in Kotlin project.

Browse Source
This commit is contained in:
Dmitry Petrov
2015-10-13 14:50:49 +03:00
parent 57869d85e8
commit 8cd624a58a
301 changed files with 1285 additions and 1362 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java
+2 -3
View File
@@ -20,13 +20,12 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.ContentRootsKt;
import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
import java.io.File;
import java.util.List;
import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
protected JavaElementFinder finder;
@@ -35,7 +34,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
CompilerConfiguration configuration = new CompilerConfiguration();
for (File root : getKotlinSourceRoots()) {
addKotlinSourceRoot(configuration, root.getPath());
ContentRootsKt.addKotlinSourceRoot(configuration, root.getPath());
}
extraConfiguration(configuration);
compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java
+2 -2
View File
@@ -23,6 +23,7 @@ import com.intellij.psi.*;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.name.SpecialNames;
@@ -34,7 +35,6 @@ import java.util.List;
import java.util.Set;
import static org.jetbrains.kotlin.asJava.KotlinLightClassStructureTest.ClassProperty.*;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
@SuppressWarnings("JUnitTestClassNamingConvention")
public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase {
@@ -149,7 +149,7 @@ public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase
@Override
protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {
addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
JvmContentRootsKt.addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
}
}
compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java
+2 -3
View File
@@ -21,6 +21,7 @@ import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiModifierList;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.test.JetTestUtils;
@@ -28,8 +29,6 @@ import java.io.File;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
public class LightClassAnnotationsTest extends KotlinAsJavaTestBase {
private final File testDir = new File("compiler/testData/asJava/annotations");
@@ -40,7 +39,7 @@ public class LightClassAnnotationsTest extends KotlinAsJavaTestBase {
@Override
protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {
addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
JvmContentRootsKt.addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
}
public void testExtraAnnotations() throws Exception {
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
+6 -7
View File
@@ -28,6 +28,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
import org.jetbrains.kotlin.context.ContextKt;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.context.SimpleGlobalContext;
@@ -55,13 +56,11 @@ import org.jetbrains.kotlin.test.InTextDirectivesUtils;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.util.DescriptorValidator;
import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.util.*;
import static org.jetbrains.kotlin.context.ContextPackage.withModule;
import static org.jetbrains.kotlin.context.ContextPackage.withProject;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE;
import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE_ALL;
@@ -128,7 +127,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
moduleBindings.put(testModule, moduleTrace.getBindingContext());
ModuleContext moduleContext = withModule(withProject(context, getProject()), module);
ModuleContext moduleContext = ContextKt.withModule(ContextKt.withProject(context, getProject()), module);
analyzeModuleContents(moduleContext, jetFiles, moduleTrace);
checkAllResolvedCallsAreCompleted(jetFiles, moduleTrace.getBindingContext());
@@ -178,13 +177,13 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
// now we throw a previously found error, if any
if (exceptionFromDescriptorValidation != null) {
throw UtilsPackage.rethrow(exceptionFromDescriptorValidation);
throw ExceptionUtilsKt.rethrow(exceptionFromDescriptorValidation);
}
if (exceptionFromLazyResolveLogValidation != null) {
throw UtilsPackage.rethrow(exceptionFromLazyResolveLogValidation);
throw ExceptionUtilsKt.rethrow(exceptionFromLazyResolveLogValidation);
}
if (exceptionFromDynamicCallDescriptorsValidation != null) {
throw UtilsPackage.rethrow(exceptionFromDynamicCallDescriptorsValidation);
throw ExceptionUtilsKt.rethrow(exceptionFromDynamicCallDescriptorsValidation);
}
}
compiler/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.java
+3 -3
View File
@@ -32,7 +32,7 @@ import kotlin.CollectionsKt;
import kotlin.jvm.functions.Function1;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.asJava.AsJavaPackage;
import org.jetbrains.kotlin.asJava.DuplicateJvmSignatureUtilKt;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.diagnostics.*;
import org.jetbrains.kotlin.psi.JetDeclaration;
@@ -400,8 +400,8 @@ public abstract class BaseDiagnosticsTest extends
Set<Diagnostic> jvmSignatureDiagnostics = new HashSet<Diagnostic>();
Collection<JetDeclaration> declarations = PsiTreeUtil.findChildrenOfType(jetFile, JetDeclaration.class);
for (JetDeclaration declaration : declarations) {
Diagnostics diagnostics = AsJavaPackage.getJvmSignatureDiagnostics(declaration, bindingContext.getDiagnostics(),
GlobalSearchScope.allScope(getProject()));
Diagnostics diagnostics = DuplicateJvmSignatureUtilKt.getJvmSignatureDiagnostics(declaration, bindingContext.getDiagnostics(),
GlobalSearchScope.allScope(getProject()));
if (diagnostics == null) continue;
jvmSignatureDiagnostics.addAll(diagnostics.forElement(declaration));
}
compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java
+5 -6
View File
@@ -24,11 +24,12 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.ContentRootsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.io.IOException;
@@ -38,8 +39,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixture {
protected class ModuleAndDependencies {
final M module;
@@ -59,7 +58,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
return true;
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -69,7 +68,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
CompilerConfiguration configuration = createCompilerConfiguration(javaFilesDir);
File kotlinSourceRoot = getKotlinSourceRoot();
if (kotlinSourceRoot != null) {
addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath());
ContentRootsKt.addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath());
}
return createEnvironment(getTestRootDisposable(), configuration);
}
@@ -104,7 +103,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
JetTestUtils.mkdirs(dir);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
return dir;
}
compiler/tests/org/jetbrains/kotlin/cli/CliBaseTest.java
+2 -2
View File
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
import org.jetbrains.kotlin.load.java.JvmAbi;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.Tmpdir;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.junit.Rule;
import org.junit.rules.TestName;
@@ -60,7 +60,7 @@ public class CliBaseTest {
return Pair.create(bytes.toString("utf-8"), exitCode);
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
finally {
System.setErr(origErr);
compiler/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeTextTest.java
+2 -2
View File
@@ -23,7 +23,7 @@ import com.intellij.util.Processor;
import kotlin.Charsets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.util.*;
@@ -65,7 +65,7 @@ public abstract class AbstractBytecodeTextTest extends CodegenTestCase {
}
catch (Throwable e) {
System.out.println(text);
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
+6 -6
View File
@@ -24,7 +24,7 @@ import kotlin.Pair;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.org.objectweb.asm.*;
import java.io.File;
@@ -77,7 +77,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
OutputFileCollection outputFiles =
GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, environment);
OutputUtilsPackage.writeAllTo(outputFiles, tmpdir);
OutputUtilsKt.writeAllTo(outputFiles, tmpdir);
}
@NotNull
@@ -90,7 +90,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
text = FileUtil.loadFile(file, true);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
return new Pair(JetTestUtils.createFile(file.getName(), text, environment.getProject()), environment);
@@ -122,7 +122,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
private static List<Integer> extractActualLineNumbersFromBytecode(@NotNull GenerationState state, boolean testFunInvoke) {
ClassFileFactory factory = state.getFactory();
List<Integer> actualLineNumbers = Lists.newArrayList();
for (OutputFile outputFile : CodegenPackage.getClassFiles(factory)) {
for (OutputFile outputFile : ClassFileUtilsKt.getClassFiles(factory)) {
if (PackageClassUtils.isPackageClassFqName(new FqName(FileUtil.getNameWithoutExtension(outputFile.getRelativePath())))) {
// Don't test line numbers in *Package facade classes
continue;
@@ -134,7 +134,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
}
catch (Throwable e) {
System.out.println(factory.createText());
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/codegen/AbstractScriptCodegenTest.java
+2 -2
View File
@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.resolve.ScriptNameUtil;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
@@ -68,7 +68,7 @@ public abstract class AbstractScriptCodegenTest extends CodegenTestCase {
}
catch (Throwable e) {
System.out.println(generateToText());
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
+5 -5
View File
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
@@ -33,7 +34,7 @@ import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.tree.ClassNode;
import org.jetbrains.org.objectweb.asm.tree.MethodNode;
@@ -55,7 +56,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*;
import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName;
import static org.jetbrains.kotlin.test.JetTestUtils.compilerConfigurationForTests;
@@ -176,7 +176,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
@NotNull
private URL[] getClassPathURLs() {
List<URL> urls = Lists.newArrayList();
for (File file : getJvmClasspathRoots(myEnvironment.getConfiguration())) {
for (File file : JvmContentRootsKt.getJvmClasspathRoots(myEnvironment.getConfiguration())) {
try {
urls.add(file.toURI().toURL());
}
@@ -261,7 +261,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
private static boolean verifyAllFilesWithAsm(ClassFileFactory factory, ClassLoader loader) {
boolean noErrors = true;
for (OutputFile file : CodegenPackage.getClassFiles(factory)) {
for (OutputFile file : ClassFileUtilsKt.getClassFiles(factory)) {
noErrors &= verifyWithAsm(file, loader);
}
return noErrors;
@@ -324,7 +324,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
return (Class<? extends Annotation>) initializedClassLoader.loadClass(fqName);
}
catch (ClassNotFoundException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
+3 -3
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.resolve.BindingTraceContext;
import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.io.IOException;
@@ -145,7 +145,7 @@ public class CodegenTestUtil {
return javaClassesTempDirectory;
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -175,7 +175,7 @@ public class CodegenTestUtil {
return annotation.getClass().getMethod(name).invoke(annotation);
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/codegen/DxChecker.java
+1 -1
View File
@@ -44,7 +44,7 @@ public class DxChecker {
array[0] = "testArgs";
arguments.parse(array);
for (OutputFile file : CodegenPackage.getClassFiles(outputFiles)) {
for (OutputFile file : ClassFileUtilsKt.getClassFiles(outputFiles)) {
try {
byte[] bytes = file.asByteArray();
checkFileWithDx(bytes, file.getRelativePath(), arguments);
compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java
+2 -2
View File
@@ -21,7 +21,7 @@ import com.intellij.openapi.util.text.StringUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
@@ -87,7 +87,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase {
loadFile("notNullAssertions/noAssertionsForKotlin.kt");
OutputFileCollection outputFiles = generateClassesInFile();
File compiledDirectory = new File(FileUtil.getTempDirectory(), "kotlin-classes");
OutputUtilsPackage.writeAllTo(outputFiles, compiledDirectory);
OutputUtilsKt.writeAllTo(outputFiles, compiledDirectory);
setUpEnvironment(false, true, compiledDirectory);
loadFile("notNullAssertions/noAssertionsForKotlinMain.kt");
compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java
+2 -2
View File
@@ -23,7 +23,7 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.name.SpecialNames;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.ClassVisitor;
import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -201,7 +201,7 @@ public class InnerClassInfoGenTest extends CodegenTestCase {
return result.isEmpty() ? "<empty>" : result.substring(1);
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/codegen/OuterClassGenTest.java
+3 -2
View File
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
import org.jetbrains.kotlin.name.SpecialNames;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.utils.StringsKt;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.ClassVisitor;
import org.jetbrains.org.objectweb.asm.Opcodes;
@@ -33,7 +34,6 @@ import java.io.File;
import java.io.InputStream;
import static org.jetbrains.kotlin.codegen.CodegenTestUtil.compileJava;
import static org.jetbrains.kotlin.utils.UtilsPackage.join;
public class OuterClassGenTest extends CodegenTestCase {
@@ -193,7 +193,8 @@ public class OuterClassGenTest extends CodegenTestCase {
return new ClassReader(file.asByteArray());
}
}
throw new AssertionError("Couldn't find class by regexp: " + internalNameRegexp + " in:\n" + join(outputFiles.asList(), "\n"));
throw new AssertionError("Couldn't find class by regexp: " + internalNameRegexp + " in:\n" + StringsKt
.join(outputFiles.asList(), "\n"));
}
private static void checkInfo(@NotNull ClassReader kotlinReader, @NotNull ClassReader javaReader) {
compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java
+6 -6
View File
@@ -27,10 +27,12 @@ import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.codegen.state.GenerationState;
import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.ContentRootsKt;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.psi.JetClass;
import org.jetbrains.kotlin.psi.JetDeclaration;
@@ -45,8 +47,6 @@ import org.jetbrains.kotlin.types.JetType;
import java.io.File;
import java.lang.reflect.Modifier;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
import static org.jetbrains.kotlin.types.TypeUtils.getAllSupertypes;
@SuppressWarnings("JUnitTestCaseWithNoTests")
@@ -83,14 +83,14 @@ public class TestlibTest extends UsefulTestCase {
super.setUp();
CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.FULL_JDK);
addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
JvmContentRootsKt.addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
junitJar = new File("libraries/lib/junit-4.11.jar");
assertTrue(junitJar.exists());
addJvmClasspathRoot(configuration, junitJar);
JvmContentRootsKt.addJvmClasspathRoot(configuration, junitJar);
addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test");
addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src");
ContentRootsKt.addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test");
ContentRootsKt.addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src");
configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
compiler/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java
+2 -3
View File
@@ -17,6 +17,7 @@
package org.jetbrains.kotlin.codegen.forTestCompile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.lang.ref.SoftReference;
@@ -26,8 +27,6 @@ import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import static org.jetbrains.kotlin.utils.UtilsPackage.rethrow;
public class ForTestCompileRuntime {
private static volatile SoftReference<ClassLoader> reflectJarClassLoader = new SoftReference<ClassLoader>(null);
private static volatile SoftReference<ClassLoader> runtimeJarClassLoader = new SoftReference<ClassLoader>(null);
@@ -80,7 +79,7 @@ public class ForTestCompileRuntime {
return new URLClassLoader(urls.toArray(new URL[urls.size()]), null);
}
catch (MalformedURLException e) {
throw rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
+8 -9
View File
@@ -22,9 +22,10 @@ import com.intellij.util.Processor;
import kotlin.Charsets;
import kotlin.io.FilesKt;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.codegen.CodegenTestCase;
import org.jetbrains.kotlin.codegen.GenerationUtils;
import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -34,7 +35,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.InTextDirectivesUtils;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.io.File;
import java.lang.reflect.Method;
@@ -42,8 +43,6 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoot;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
import static org.jetbrains.kotlin.codegen.CodegenTestUtil.compileJava;
import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName;
@@ -62,7 +61,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
blackBoxFileWithJavaByFullPath(filename);
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -150,14 +149,14 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar()
);
addJavaSourceRoot(configuration, dirFile);
JvmContentRootsKt.addJavaSourceRoot(configuration, dirFile);
myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
loadFiles(ArrayUtil.toStringArray(ktFilePaths));
classFileFactory =
GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles(),
new JvmPackagePartProvider(myEnvironment)).getFactory();
File kotlinOut = JetTestUtils.tmpDir(toString());
OutputUtilsPackage.writeAllTo(classFileFactory, kotlinOut);
OutputUtilsKt.writeAllTo(classFileFactory, kotlinOut);
List<String> javacOptions = new ArrayList<String>(0);
for (JetFile jetFile : myFiles.getPsiFiles()) {
@@ -166,7 +165,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
File javaOut = compileJava(javaFilePaths, Collections.singletonList(kotlinOut.getPath()), javacOptions);
// Add javac output to classpath so that the created class loader can find generated Java classes
addJvmClasspathRoot(configuration, javaOut);
JvmContentRootsKt.addJvmClasspathRoot(configuration, javaOut);
blackBox();
}
@@ -189,7 +188,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
}
catch (Throwable e) {
System.out.println(generateToText());
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTest.java
+2 -2
View File
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.integration;
import com.intellij.util.ArrayUtil;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.StringsKt;
import java.io.File;
import java.util.ArrayList;
@@ -35,7 +35,7 @@ public class CompilerSmokeTest extends KotlinIntegrationTestBase {
Collection<String> javaArgs = new ArrayList<String>();
javaArgs.add("-cp");
javaArgs.add(UtilsPackage.join(Arrays.asList(
javaArgs.add(StringsKt.join(Arrays.asList(
getCompilerLib().getAbsolutePath() + File.separator + "kotlin-compiler.jar",
new File("dependencies/bootstrap-compiler/Kotlin/kotlinc/lib/kotlin-runtime.jar").getAbsolutePath(),
new File("dependencies/bootstrap-compiler/Kotlin/kotlinc/lib/kotlin-reflect.jar").getAbsolutePath()
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
+2 -2
View File
@@ -22,7 +22,7 @@ import com.intellij.openapi.util.io.FileUtil;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.codegen.ClassFileFactory;
@@ -113,7 +113,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
ClassFileFactory outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
OutputUtilsPackage.writeAllTo(outputFiles, outputDir);
OutputUtilsKt.writeAllTo(outputFiles, outputDir);
Disposer.dispose(disposable);
return outputFiles;
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
+7 -7
View File
@@ -24,7 +24,10 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.cli.jvm.config.ModuleNameKt;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.ContentRootsKt;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -55,9 +58,6 @@ import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoot;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getModuleName;
import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*;
import static org.jetbrains.kotlin.test.JetTestUtils.*;
import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed;
@@ -140,16 +140,16 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK);
addKotlinSourceRoot(configuration, sourcesDir.getAbsolutePath());
addJavaSourceRoot(configuration, new File("compiler/testData/loadJava/include"));
addJavaSourceRoot(configuration, tmpdir);
ContentRootsKt.addKotlinSourceRoot(configuration, sourcesDir.getAbsolutePath());
JvmContentRootsKt.addJavaSourceRoot(configuration, new File("compiler/testData/loadJava/include"));
JvmContentRootsKt.addJavaSourceRoot(configuration, tmpdir);
KotlinCoreEnvironment environment =
KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject(),
getModuleName(environment));
ModuleNameKt.getModuleName(environment));
TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
moduleContext,
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java
+2 -3
View File
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer;
import org.jetbrains.kotlin.resolve.BindingContext;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.DescriptorUtils;
import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.TypeTransformingVisitor;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -43,8 +44,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.resolveTopLevelClass;
public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase {
private static final int CLASSES_IN_CHUNK = 100;
@@ -86,7 +85,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
int chunkStart = chunkIndex * CLASSES_IN_CHUNK;
for (FqName javaClass : affectedClasses.subList(chunkStart, Math.min(chunkStart + CLASSES_IN_CHUNK, affectedClasses.size()))) {
ClassDescriptor topLevelClass = resolveTopLevelClass(module, javaClass, NoLookupLocation.FROM_TEST);
ClassDescriptor topLevelClass = DescriptorUtilsKt.resolveTopLevelClass(module, javaClass, NoLookupLocation.FROM_TEST);
PackageViewDescriptor topLevelPackage = module.getPackage(javaClass);
if (topLevelClass == null) {
continue;
compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java
+2 -2
View File
@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
import org.jetbrains.kotlin.test.*;
import org.jetbrains.kotlin.test.util.DescriptorValidator;
import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.ClassVisitor;
import org.jetbrains.org.objectweb.asm.ClassWriter;
@@ -137,7 +137,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
return outputFile;
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
+2 -2
View File
@@ -23,7 +23,7 @@ import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -70,7 +70,7 @@ public final class LoadDescriptorUtil {
AnalysisResult result = filesAndResult.getAnalysisResult();
List<JetFile> files = filesAndResult.getJetFiles();
GenerationState state = GenerationUtils.compileFilesGetGenerationState(files.get(0).getProject(), result, files);
OutputUtilsPackage.writeAllTo(state.getFactory(), outDir);
OutputUtilsKt.writeAllTo(state.getFactory(), outDir);
return result;
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java
+2 -3
View File
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetTestUtils;
@@ -45,8 +46,6 @@ import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.resolveTopLevelClass;
public class ResolveDescriptorsFromExternalLibraries {
public static void main(String[] args) throws Exception {
boolean hasErrors = run();
@@ -211,7 +210,7 @@ public class ResolveDescriptorsFromExternalLibraries {
String className = entryName.substring(0, entryName.length() - ".class".length()).replace("/", ".");
try {
ClassDescriptor clazz = resolveTopLevelClass(module, new FqName(className), NoLookupLocation.FROM_TEST);
ClassDescriptor clazz = DescriptorUtilsKt.resolveTopLevelClass(module, new FqName(className), NoLookupLocation.FROM_TEST);
if (clazz == null) {
throw new IllegalStateException("class not found by name " + className + " in " + libDescription);
}
compiler/tests/org/jetbrains/kotlin/name/FqNameTest.java
+16 -16
View File
@@ -98,22 +98,22 @@ public class FqNameTest {
@Test
public void isValidJavaFqName() {
Assert.assertTrue(NamePackage.isValidJavaFqName(""));
Assert.assertTrue(NamePackage.isValidJavaFqName("a"));
Assert.assertTrue(NamePackage.isValidJavaFqName("1"));
Assert.assertTrue(NamePackage.isValidJavaFqName("a.a"));
Assert.assertTrue(NamePackage.isValidJavaFqName("org.jetbrains"));
Assert.assertTrue(NamePackage.isValidJavaFqName("$"));
Assert.assertTrue(NamePackage.isValidJavaFqName("org.A$B"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName(""));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("a"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("1"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("a.a"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("org.jetbrains"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("$"));
Assert.assertTrue(FqNamesUtilKt.isValidJavaFqName("org.A$B"));
Assert.assertFalse(NamePackage.isValidJavaFqName("."));
Assert.assertFalse(NamePackage.isValidJavaFqName(".."));
Assert.assertFalse(NamePackage.isValidJavaFqName("a."));
Assert.assertFalse(NamePackage.isValidJavaFqName(".a"));
Assert.assertFalse(NamePackage.isValidJavaFqName("a..b"));
Assert.assertFalse(NamePackage.isValidJavaFqName("a.b.."));
Assert.assertFalse(NamePackage.isValidJavaFqName("a.b."));
Assert.assertFalse(NamePackage.isValidJavaFqName("a.b...)"));
Assert.assertFalse(NamePackage.isValidJavaFqName("a.b.<special>"));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("."));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName(".."));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a."));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName(".a"));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a..b"));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a.b.."));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a.b."));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a.b...)"));
Assert.assertFalse(FqNamesUtilKt.isValidJavaFqName("a.b.<special>"));
}
}
compiler/tests/org/jetbrains/kotlin/parsing/AbstractJetParsingTest.java
+2 -5
View File
@@ -29,10 +29,7 @@ import com.intellij.testFramework.ParsingTestCase;
import com.intellij.util.PathUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.JetNodeTypes;
import org.jetbrains.kotlin.psi.IfNotParsed;
import org.jetbrains.kotlin.psi.JetElement;
import org.jetbrains.kotlin.psi.JetPsiFactory;
import org.jetbrains.kotlin.psi.JetVisitorVoid;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.test.JetTestUtils;
import java.lang.annotation.Annotation;
@@ -120,7 +117,7 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
}
private PsiFile createFile(@NotNull String filePath, @NotNull IElementType fileType) throws Exception {
JetPsiFactory psiFactory = JetPsiFactory(myProject);
JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(myProject);
if (fileType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT) {
return psiFactory.createExpressionCodeFragment(loadFile(filePath), null);
}
compiler/tests/org/jetbrains/kotlin/psi/JetPsiUtilTest.java
+2 -2
View File
@@ -73,7 +73,7 @@ public class JetPsiUtilTest extends JetLiteFixture {
public void testIsLocalClass() throws IOException {
String text = FileUtil.loadFile(new File(getTestDataPath() + "/psiUtil/isLocalClass.kt"), true);
JetClass aClass = JetPsiFactory(getProject()).createClass(text);
JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(text);
@SuppressWarnings("unchecked")
Collection<JetClassOrObject> classOrObjects = PsiTreeUtil.collectElementsOfType(aClass, JetClassOrObject.class);
@@ -104,7 +104,7 @@ public class JetPsiUtilTest extends JetLiteFixture {
private ImportPath getImportPathFromParsed(String text) {
JetImportDirective importDirective =
PsiTreeUtil.findChildOfType(JetPsiFactory(getProject()).createFile(text), JetImportDirective.class);
PsiTreeUtil.findChildOfType(JetPsiFactoryKt.JetPsiFactory(getProject()).createFile(text), JetImportDirective.class);
assertNotNull("At least one import directive is expected", importDirective);
compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
+6 -6
View File
@@ -29,14 +29,14 @@ import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.TypeUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
@@ -117,7 +117,7 @@ public class JetExpectedResolveDataUtil {
@NotNull
private static PsiClass findClass(String qualifiedName, Project project, KotlinCoreEnvironment environment) {
ModuleDescriptor module = LazyResolveTestUtil.resolveProject(project, environment);
ClassDescriptor classDescriptor = DescriptorUtilPackage.resolveTopLevelClass(module, new FqName(qualifiedName), NoLookupLocation.FROM_TEST);
ClassDescriptor classDescriptor = DescriptorUtilsKt.resolveTopLevelClass(module, new FqName(qualifiedName), NoLookupLocation.FROM_TEST);
assertNotNull("Class descriptor wasn't resolved: " + qualifiedName, classDescriptor);
PsiClass psiClass = (PsiClass) DescriptorToSourceUtils.getSourceFromDescriptor(classDescriptor);
assertNotNull("Class declaration wasn't found: " + classDescriptor, psiClass);
@@ -132,12 +132,12 @@ public class JetExpectedResolveDataUtil {
JetType... parameterTypes
) {
ModuleDescriptorImpl emptyModule = JetTestUtils.createEmptyModule();
ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule);
ContainerForTests container = InjectionKt.createContainerForTests(project, emptyModule);
emptyModule.setDependencies(emptyModule);
emptyModule.initialize(PackageFragmentProvider.Empty.INSTANCE$);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
new BindingTraceContext(), UtilsPackage.memberScopeAsFileScope(classDescriptor.getDefaultType().getMemberScope()),
new BindingTraceContext(), ScopeUtilsKt.memberScopeAsFileScope(classDescriptor.getDefaultType().getMemberScope()),
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
OverloadResolutionResults<FunctionDescriptor> functions = container.getFakeCallResolver().resolveFakeCall(
compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
+1 -3
View File
@@ -35,8 +35,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.jetbrains.kotlin.resolve.lazy.LazyPackage.createResolveSessionForFiles;
public class LazyResolveTestUtil {
private LazyResolveTestUtil() {
}
@@ -74,7 +72,7 @@ public class LazyResolveTestUtil {
@NotNull KotlinCoreEnvironment environment,
boolean addBuiltIns
) {
return createResolveSessionForFiles(environment.getProject(), files, addBuiltIns);
return LazyResolveTestUtilsKt.createResolveSessionForFiles(environment.getProject(), files, addBuiltIns);
}
public static ModuleDescriptor resolveLazily(List<JetFile> files, KotlinCoreEnvironment environment) {
compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java
+2 -4
View File
@@ -20,7 +20,6 @@ import com.intellij.openapi.Disposable;
import com.intellij.openapi.util.Disposer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
import org.jetbrains.kotlin.cli.common.messages.*;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
@@ -30,6 +29,7 @@ import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
import org.jetbrains.kotlin.codegen.CompilationException;
import org.jetbrains.kotlin.config.CommonConfigurationKeys;
import org.jetbrains.kotlin.config.CompilerConfiguration;
import org.jetbrains.kotlin.config.ContentRootsKt;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.parsing.JetScriptDefinition;
import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider;
@@ -46,8 +46,6 @@ import org.junit.Test;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
public class ScriptTest {
@Test
public void testScript() throws Exception {
@@ -85,7 +83,7 @@ public class ScriptTest {
CompilerConfiguration configuration =
JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK);
configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);
addKotlinSourceRoot(configuration, "compiler/testData/script/" + scriptPath);
ContentRootsKt.addKotlinSourceRoot(configuration, "compiler/testData/script/" + scriptPath);
configuration.addAll(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinitions);
configuration.put(JVMConfigurationKeys.SCRIPT_PARAMETERS, scriptParameters);
compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java
+15 -14
View File
@@ -48,6 +48,7 @@ import org.jetbrains.annotations.TestOnly;
import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.config.CommonConfigurationKeys;
import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -63,6 +64,7 @@ import org.jetbrains.kotlin.lexer.JetTokens;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.JetExpression;
import org.jetbrains.kotlin.psi.JetFile;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.resolve.BindingContext;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.resolve.TargetPlatform;
@@ -71,14 +73,14 @@ import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.storage.LockBasedStorageManager;
import org.jetbrains.kotlin.test.util.UtilPackage;
import org.jetbrains.kotlin.test.util.JetTestUtilsKt;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice;
import org.jetbrains.kotlin.util.slicedMap.SlicedMap;
import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.kotlin.utils.PathUtil;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.junit.Assert;
import javax.tools.*;
@@ -91,7 +93,6 @@ import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.*;
import static org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys.MODULE_NAME;
import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@@ -432,25 +433,25 @@ public class JetTestUtils {
@NotNull List<File> javaSource
) {
CompilerConfiguration configuration = new CompilerConfiguration();
addJavaSourceRoots(configuration, javaSource);
JvmContentRootsKt.addJavaSourceRoots(configuration, javaSource);
if (jdkKind == TestJdkKind.MOCK_JDK) {
addJvmClasspathRoot(configuration, findMockJdkRtJar());
JvmContentRootsKt.addJvmClasspathRoot(configuration, findMockJdkRtJar());
}
else if (jdkKind == TestJdkKind.ANDROID_API) {
addJvmClasspathRoot(configuration, findAndroidApiJar());
JvmContentRootsKt.addJvmClasspathRoot(configuration, findAndroidApiJar());
}
else {
addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
JvmContentRootsKt.addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
}
if (configurationKind.getWithRuntime()) {
addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
JvmContentRootsKt.addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
}
if (configurationKind.getWithReflection()) {
addJvmClasspathRoot(configuration, ForTestCompileRuntime.reflectJarForTests());
JvmContentRootsKt.addJvmClasspathRoot(configuration, ForTestCompileRuntime.reflectJarForTests());
}
addJvmClasspathRoots(configuration, classpath);
JvmContentRootsKt.addJvmClasspathRoots(configuration, classpath);
configuration.put(MODULE_NAME, "compilerConfigurationForTests");
@@ -492,7 +493,7 @@ public class JetTestUtils {
public static void assertEqualsToFile(@NotNull File expectedFile, @NotNull String actual, @NotNull Function1<String, String> sanitizer) {
try {
String actualText = UtilPackage.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(actual.trim()));
String actualText = JetTestUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(actual.trim()));
if (!expectedFile.exists()) {
FileUtil.writeToFile(expectedFile, actualText);
@@ -500,7 +501,7 @@ public class JetTestUtils {
}
String expected = FileUtil.loadFile(expectedFile, CharsetToolkit.UTF8, true);
String expectedText = UtilPackage.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(expected.trim()));
String expectedText = JetTestUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(expected.trim()));
if (!Comparing.equal(sanitizer.invoke(expectedText), sanitizer.invoke(actualText))) {
throw new FileComparisonFailure("Actual data differs from file content: " + expectedFile.getName(),
@@ -508,7 +509,7 @@ public class JetTestUtils {
}
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -896,7 +897,7 @@ public class JetTestUtils {
@NotNull
public static JetFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException {
String text = FileUtil.loadFile(ioFile, true);
return JetPsiFactory(project).createPhysicalFile(ioFile.getName(), text);
return JetPsiFactoryKt.JetPsiFactory(project).createPhysicalFile(ioFile.getName(), text);
}
@NotNull
compiler/tests/org/jetbrains/kotlin/test/MockLibraryUtil.java
+6 -6
View File
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.kotlin.preloading.ClassPreloadingUtils;
import org.jetbrains.kotlin.preloading.Preloader;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.kotlin.utils.PathUtil;
import org.jetbrains.kotlin.utils.UtilsPackage;
import java.io.*;
import java.lang.ref.SoftReference;
@@ -106,7 +106,7 @@ public class MockLibraryUtil {
return createJarFile(contentDir, classesDir, sourcesPath, jarName, addSources);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -127,7 +127,7 @@ public class MockLibraryUtil {
return createJarFile(contentDir, outDir, sourcesPath, jarName, addSources);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -164,7 +164,7 @@ public class MockLibraryUtil {
assertEquals(new String(outStream.toByteArray()), ExitCode.OK.name(), invocationResult.name());
}
catch (Throwable e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -221,7 +221,7 @@ public class MockLibraryUtil {
return classLoader.loadClass(compilerClassName);
}
catch (Throwable e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
@@ -234,7 +234,7 @@ public class MockLibraryUtil {
);
}
catch (Throwable e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/test/Tmpdir.java
+2 -2
View File
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.test;
import com.google.common.io.Files;
import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.utils.UtilsPackage;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;
@@ -36,7 +36,7 @@ public class Tmpdir extends TestWatcher {
tmpDir = Files.createTempDir().getCanonicalFile();
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
throw ExceptionUtilsKt.rethrow(e);
}
}
compiler/tests/org/jetbrains/kotlin/types/BoundsSubstitutorTest.java
+2 -1
View File
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.JetFile;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
@@ -71,7 +72,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment {
//}
private void doTest(String text, String expected) {
JetFile jetFile = JetPsiFactory(getProject()).createFile("fun.kt", text);
JetFile jetFile = JetPsiFactoryKt.JetPsiFactory(getProject()).createFile("fun.kt", text);
ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
Collection<FunctionDescriptor> functions =
module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"), NoLookupLocation.FROM_TEST);
compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java
+14 -13
View File
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.types;
import org.jetbrains.kotlin.analyzer.AnalysisResult;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.ContextKt;
import org.jetbrains.kotlin.context.ModuleContext;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -33,12 +33,12 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import java.util.Collections;
import java.util.List;
@@ -73,7 +73,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
private JetScope scope;
public void setUp() throws Exception {
ContainerForTests containerForTests = DiPackage.createContainerForTests(getProject(), root);
ContainerForTests containerForTests = InjectionKt.createContainerForTests(getProject(), root);
descriptorResolver = containerForTests.getDescriptorResolver();
functionDescriptorResolver = containerForTests.getFunctionDescriptorResolver();
scope = createScope(root.getBuiltIns().getBuiltInsPackageScope());
@@ -85,7 +85,8 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
}
private JetScope createScope(JetScope libraryScope) {
JetFile file = JetPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }");
JetFile file = JetPsiFactoryKt
.JetPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }");
List<JetDeclaration> declarations = file.getDeclarations();
JetDeclaration aClass = declarations.get(0);
assert aClass instanceof JetClass;
@@ -100,7 +101,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
}
private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject());
ModuleContext moduleContext = ContextKt.ModuleContext(root, getProject());
ResolveSession resolveSession = createLazyResolveSession(
moduleContext,
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
@@ -113,7 +114,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
}
private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) {
JetClass aClass = JetPsiFactory(getProject()).createClass(classDeclaration);
JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classDeclaration);
ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
assertEquals(expectedModality, classDescriptor.getModality());
@@ -121,39 +122,39 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
private void testFunctionModality(String classWithFunction, ClassKind kind, Modality expectedFunctionModality) {
JetClass aClass = JetPsiFactory(getProject()).createClass(classWithFunction);
JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithFunction);
ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
List<JetDeclaration> declarations = aClass.getDeclarations();
JetNamedFunction function = (JetNamedFunction) declarations.get(0);
SimpleFunctionDescriptor functionDescriptor =
functionDescriptorResolver.resolveFunctionDescriptor(classDescriptor, UtilsPackage.asLexicalScope(scope), function,
functionDescriptorResolver.resolveFunctionDescriptor(classDescriptor, ScopeUtilsKt.asLexicalScope(scope), function,
JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
assertEquals(expectedFunctionModality, functionDescriptor.getModality());
}
private void testPropertyModality(String classWithProperty, ClassKind kind, Modality expectedPropertyModality) {
JetClass aClass = JetPsiFactory(getProject()).createClass(classWithProperty);
JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithProperty);
ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
List<JetDeclaration> declarations = aClass.getDeclarations();
JetProperty property = (JetProperty) declarations.get(0);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
classDescriptor, UtilsPackage.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
classDescriptor, ScopeUtilsKt.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
assertEquals(expectedPropertyModality, propertyDescriptor.getModality());
}
private void testPropertyAccessorModality(String classWithPropertyWithAccessor, ClassKind kind, Modality expectedPropertyAccessorModality, boolean isGetter) {
JetClass aClass = JetPsiFactory(getProject()).createClass(classWithPropertyWithAccessor);
JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithPropertyWithAccessor);
ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
List<JetDeclaration> declarations = aClass.getDeclarations();
JetProperty property = (JetProperty) declarations.get(0);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
classDescriptor, UtilsPackage.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
classDescriptor, ScopeUtilsKt.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
PropertyAccessorDescriptor propertyAccessor = isGetter
? propertyDescriptor.getGetter()
: propertyDescriptor.getSetter();
compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java
+6 -6
View File
@@ -16,21 +16,21 @@
package org.jetbrains.kotlin.types;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.psi.JetNamedFunction;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.resolve.OverloadUtil;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
import org.jetbrains.kotlin.resolve.scopes.FileScope;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@@ -47,7 +47,7 @@ public class JetOverloadTest extends JetLiteFixture {
@Override
public void setUp() throws Exception {
super.setUp();
functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
functionDescriptorResolver = InjectionKt.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
}
@Override
@@ -174,8 +174,8 @@ public class JetOverloadTest extends JetLiteFixture {
}
private FunctionDescriptor makeFunction(String funDecl) {
JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl);
FileScope scope = UtilsPackage.memberScopeAsFileScope(JvmPlatform.INSTANCE$.getBuiltIns().getBuiltInsPackageScope());
JetNamedFunction function = JetPsiFactoryKt.JetPsiFactory(getProject()).createFunction(funDecl);
FileScope scope = ScopeUtilsKt.memberScopeAsFileScope(JvmPlatform.INSTANCE$.getBuiltIns().getBuiltInsPackageScope());
return functionDescriptorResolver.resolveFunctionDescriptor(root, scope, function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
}
}
compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java
+6 -5
View File
@@ -20,15 +20,16 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.psi.JetNamedFunction;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
import org.jetbrains.kotlin.resolve.OverridingUtil;
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@@ -45,7 +46,7 @@ public class JetOverridingTest extends JetLiteFixture {
@Override
public void setUp() throws Exception {
super.setUp();
functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
functionDescriptorResolver = InjectionKt.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
}
@Override
@@ -163,8 +164,8 @@ public class JetOverridingTest extends JetLiteFixture {
}
private FunctionDescriptor makeFunction(String funDecl) {
JetNamedFunction function = JetPsiFactory(getProject()).createFunction(funDecl);
LexicalScope scope = UtilsPackage.asLexicalScope(root.getBuiltIns().getBuiltInsPackageScope());
JetNamedFunction function = JetPsiFactoryKt.JetPsiFactory(getProject()).createFunction(funDecl);
LexicalScope scope = ScopeUtilsKt.asLexicalScope(root.getBuiltIns().getBuiltInsPackageScope());
return functionDescriptorResolver.resolveFunctionDescriptor(root, scope, function,
JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
}
compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
+12 -11
View File
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.JetExpression;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.resolve.BindingTraceContext;
import org.jetbrains.kotlin.resolve.ImportPath;
import org.jetbrains.kotlin.resolve.TypeResolver;
@@ -39,11 +40,12 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.*;
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import org.jetbrains.kotlin.types.checker.JetTypeChecker;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
@@ -52,7 +54,6 @@ import java.io.IOException;
import java.util.*;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
import static org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage.asLexicalScope;
public class JetTypeCheckerTest extends JetLiteFixture {
@@ -78,7 +79,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
ModuleDescriptorImpl module = JetTestUtils.createEmptyModule();
builtIns = module.getBuiltIns();
ContainerForTests container = DiPackage.createContainerForTests(getProject(), module);
ContainerForTests container = InjectionKt.createContainerForTests(getProject(), module);
module.setDependencies(Collections.singletonList(module));
module.initialize(PackageFragmentProvider.Empty.INSTANCE$);
typeResolver = container.getTypeResolver();
@@ -547,15 +548,15 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private void assertType(String expression, JetType expectedType) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory(project).createExpression(expression);
JetType type = expressionTypingServices.getType(asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
JetType type = expressionTypingServices.getType(ScopeUtilsKt.asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
assertTrue(type + " != " + expectedType, type.equals(expectedType));
}
private void assertErrorType(String expression) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory(project).createExpression(expression);
JetType type = expressionTypingServices.safeGetType(asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
JetType type = expressionTypingServices.safeGetType(ScopeUtilsKt.asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
assertTrue("Error type expected but " + type + " returned", type.isError());
}
@@ -573,7 +574,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
public List<ReceiverParameterDescriptor> getImplicitReceiversHierarchy() {
return Lists.<ReceiverParameterDescriptor>newArrayList(new ReceiverParameterDescriptorImpl(
getContainingDeclaration(),
new ExpressionReceiver(JetPsiFactory(getProject()).createExpression(expression), thisType)
new ExpressionReceiver(JetPsiFactoryKt.JetPsiFactory(getProject()).createExpression(expression), thisType)
));
}
};
@@ -586,9 +587,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private void assertType(JetScope scope, String expression, String expectedTypeStr) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory(project).createExpression(expression);
JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
JetType type = expressionTypingServices.getType(
asLexicalScope(addImports(scope)), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, new BindingTraceContext());
ScopeUtilsKt.asLexicalScope(addImports(scope)), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, new BindingTraceContext());
JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr);
assertEquals(expectedType, type);
}
@@ -636,6 +637,6 @@ public class JetTypeCheckerTest extends JetLiteFixture {
}
private JetType makeType(JetScope scope, String typeStr) {
return typeResolver.resolveType(asLexicalScope(scope), JetPsiFactory(getProject()).createType(typeStr), JetTestUtils.DUMMY_TRACE, true);
return typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(scope), JetPsiFactoryKt.JetPsiFactory(getProject()).createType(typeStr), JetTestUtils.DUMMY_TRACE, true);
}
}
compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java
+7 -6
View File
@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.JetFile;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.psi.JetTypeReference;
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
import org.jetbrains.kotlin.resolve.AnalyzingUtils;
@@ -42,11 +43,11 @@ import org.jetbrains.kotlin.resolve.BindingTraceContext;
import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.*;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import java.io.File;
import java.io.IOException;
@@ -69,7 +70,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
protected void setUp() throws Exception {
super.setUp();
container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
container = InjectionKt.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
scope = getContextScope();
}
@@ -83,7 +84,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
private JetScope getContextScope() throws IOException {
// todo comments
String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt"), true);
JetFile jetFile = JetPsiFactory(getProject()).createFile(text);
JetFile jetFile = JetPsiFactoryKt.JetPsiFactory(getProject()).createFile(text);
ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope();
ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context"), NoLookupLocation.FROM_TEST);
@@ -139,10 +140,10 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
}
private JetType resolveType(String typeStr) {
JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr);
JetTypeReference jetTypeReference = JetPsiFactoryKt.JetPsiFactory(getProject()).createType(typeStr);
AnalyzingUtils.checkForSyntacticErrors(jetTypeReference);
BindingTrace trace = new BindingTraceContext();
JetType type = container.getTypeResolver().resolveType(UtilsPackage.asLexicalScope(scope), jetTypeReference, trace, true);
JetType type = container.getTypeResolver().resolveType(ScopeUtilsKt.asLexicalScope(scope), jetTypeReference, trace, true);
if (!trace.getBindingContext().getDiagnostics().isEmpty()) {
fail("Errors:\n" + StringUtil.join(
trace.getBindingContext().getDiagnostics(),
compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java
+7 -5
View File
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
import org.jetbrains.kotlin.psi.JetTypeProjection;
import org.jetbrains.kotlin.psi.JetTypeReference;
import org.jetbrains.kotlin.resolve.TypeResolver;
@@ -35,11 +36,11 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetLiteFixture;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.tests.di.InjectionKt;
import java.util.Map;
import java.util.Set;
@@ -66,7 +67,7 @@ public class TypeUnifierTest extends JetLiteFixture {
ModuleDescriptorImpl module = JetTestUtils.createEmptyModule();
builtIns = module.getBuiltIns();
typeResolver = DiPackage.createContainerForTests(getProject(), module).getTypeResolver();
typeResolver = InjectionKt.createContainerForTests(getProject(), module).getTypeResolver();
x = createTypeVariable("X");
y = createTypeVariable("Y");
variables = Sets.newHashSet(x.getTypeConstructor(), y.getTypeConstructor());
@@ -209,11 +210,12 @@ public class TypeUnifierTest extends JetLiteFixture {
withX.addClassifierDescriptor(y);
withX.changeLockLevel(WritableScope.LockLevel.READING);
JetTypeProjection projection = JetPsiFactory(getProject()).createTypeArguments("<" + typeStr + ">").getArguments().get(0);
JetTypeProjection projection = JetPsiFactoryKt
.JetPsiFactory(getProject()).createTypeArguments("<" + typeStr + ">").getArguments().get(0);
JetTypeReference typeReference = projection.getTypeReference();
assert typeReference != null;
JetType type = typeResolver.resolveType(UtilsPackage.asLexicalScope(withX), typeReference, JetTestUtils.DUMMY_TRACE, true);
JetType type = typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(withX), typeReference, JetTestUtils.DUMMY_TRACE, true);
return new TypeProjectionImpl(getProjectionKind(typeStr, projection), type);
}