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

Big refactoring. Migrating to package views and fragments.

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2013-10-11 21:43:40 +04:00
parent 369824cd2e
commit 7abe6a5b4a
141 changed files with 1728 additions and 1465 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/JetTestUtils.java
+12 -14
View File
@@ -50,8 +50,7 @@ import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.lang.ModuleConfiguration;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.diagnostics.Severity;
@@ -61,11 +60,8 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.name.SpecialNames;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.plugin.JetLanguage;
import org.jetbrains.jet.test.InnerTestClasses;
import org.jetbrains.jet.test.TestMetadata;
@@ -711,14 +707,16 @@ public class JetTestUtils {
}
@NotNull
public static NamespaceDescriptorImpl createTestNamespace(@NotNull Name testPackageName) {
ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<test module>");
NamespaceDescriptorImpl rootNamespace =
new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), SpecialNames.ROOT_NAMESPACE);
module.setRootNamespace(rootNamespace);
NamespaceDescriptorImpl test = new NamespaceDescriptorImpl(rootNamespace, Collections.<AnnotationDescriptor>emptyList(), testPackageName);
test.initialize(new WritableScopeImpl(JetScope.EMPTY, test, RedeclarationHandler.DO_NOTHING, "members of test namespace"));
return test;
public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName) {
return createTestPackageFragment(testPackageName, "<test module>");
}
@NotNull
public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) {
ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName);
MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module);
module.addFragmentProvider(provider);
return provider.getOrCreateFragment(FqName.topLevel(testPackageName));
}
@NotNull
compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java
+21 -20
View File
@@ -24,7 +24,7 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -61,22 +61,23 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
JetTestUtils.createFile(ktFile.getName(), FileUtil.loadFile(ktFile), getProject())
), getEnvironment());
NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(TEST_PACKAGE_NAME));
assert testNamespace != null;
PackageFragmentDescriptor testPackage = moduleDescriptor.getPackageFragmentProvider()
.getPackageFragments(FqName.topLevel(TEST_PACKAGE_NAME)).get(0); // TODO 2 hack
assert testPackage != null;
InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
NamespaceDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testNamespace);
PackageFragmentDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testPackage);
RecursiveDescriptorComparator
.validateAndCompareDescriptors(testNamespace, deserialized, RecursiveDescriptorComparator.RECURSIVE, null);
.validateAndCompareDescriptors(testPackage, deserialized, RecursiveDescriptorComparator.RECURSIVE, null);
}
@NotNull
private static NamespaceDescriptor serializeAndDeserialize(
private static PackageFragmentDescriptor serializeAndDeserialize(
@NotNull JavaDescriptorResolver javaDescriptorResolver,
@NotNull NamespaceDescriptor testPackage
@NotNull PackageFragmentDescriptor testPackage
) {
List<ClassDescriptor> classesAndObjects = getAllClassesAndObjects(testPackage.getMemberScope());
@@ -91,36 +92,36 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
classDataMap.put(key, value);
}
NamespaceDescriptorImpl namespace = JetTestUtils.createTestNamespace(TEST_PACKAGE_NAME);
MutablePackageFragmentDescriptor packageFragment = JetTestUtils.createTestPackageFragment(TEST_PACKAGE_NAME, "<fake>");
DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, namespace, classDataMap);
DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, packageFragment, classDataMap);
for (ClassDescriptor classDescriptor : classesAndObjects) {
ClassId classId = getClassId(classDescriptor);
ClassDescriptor descriptor = descriptorFinder.findClass(classId);
assert descriptor != null : "Class not loaded: " + classId;
namespace.getMemberScope().addClassifierDescriptor(descriptor);
packageFragment.getMemberScope().addClassifierDescriptor(descriptor);
}
PackageData data = PackageData.read(serializedPackage, JavaProtoBufUtil.getExtensionRegistry());
DescriptorDeserializer deserializer = DescriptorDeserializer
.create(new LockBasedStorageManager(), namespace, data.getNameResolver(), descriptorFinder, UNSUPPORTED);
.create(new LockBasedStorageManager(), packageFragment, data.getNameResolver(), descriptorFinder, UNSUPPORTED);
for (ProtoBuf.Callable proto : data.getPackageProto().getMemberList()) {
CallableMemberDescriptor descriptor = deserializer.loadCallable(proto);
if (descriptor instanceof FunctionDescriptor) {
namespace.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor);
packageFragment.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor);
}
else if (descriptor instanceof PropertyDescriptor) {
namespace.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor);
packageFragment.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor);
}
else {
throw new IllegalStateException("Unknown descriptor type: " + descriptor);
}
}
namespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
packageFragment.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
return namespace;
return packageFragment;
}
@NotNull
@@ -135,9 +136,9 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
}
@NotNull
private static byte[] serializePackage(@NotNull NamespaceDescriptor descriptor) {
private static byte[] serializePackage(@NotNull PackageFragmentDescriptor descriptor) {
DescriptorSerializer serializer = new DescriptorSerializer();
ProtoBuf.Package proto = serializer.packageProto(descriptor).build();
ProtoBuf.Package proto = serializer.packageProto(Collections.singleton(descriptor)).build();
PackageData data = new PackageData(createNameResolver(serializer.getNameTable()), proto);
return data.toBytes();
}
@@ -160,12 +161,12 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
private static class DescriptorFinderFromClassDataOrJava extends AbstractDescriptorFinder {
private final JavaDescriptorResolver javaDescriptorResolver;
private final NamespaceDescriptor packageForClasses;
private final PackageFragmentDescriptor packageForClasses;
private final Map<String, ClassData> classDataMap;
public DescriptorFinderFromClassDataOrJava(
@NotNull JavaDescriptorResolver javaDescriptorResolver,
@NotNull NamespaceDescriptor packageForClasses,
@NotNull PackageFragmentDescriptor packageForClasses,
@NotNull Map<String, ClassData> classDataMap
) {
super(new LockBasedStorageManager(), UNSUPPORTED);
@@ -189,7 +190,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
@Nullable
@Override
public NamespaceDescriptor findPackage(@NotNull FqName name) {
public PackageFragmentDescriptor findPackage(@NotNull FqName name) {
assert DescriptorUtils.getFQName(packageForClasses).equals(name.toUnsafe()) : name + " : " + packageForClasses;
return packageForClasses;
}
compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java
+15 -15
View File
@@ -27,7 +27,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -52,7 +52,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
public void testBuiltIns() throws Exception {
Collection<DeclarationDescriptor> allDescriptors = KotlinBuiltIns.getInstance().getBuiltInsScope().getAllDescriptors();
NamespaceDescriptorImpl actualNamespace = getDeserializedDescriptorsAsNamespace(allDescriptors);
PackageFragmentDescriptor actualPackage = getDeserializedDescriptorsAsPackage(allDescriptors);
RecursiveDescriptorComparator.Configuration configuration = RecursiveDescriptorComparator.RECURSIVE.withRenderer(
new DescriptorRendererBuilder()
@@ -65,26 +65,26 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
.build()
);
RecursiveDescriptorComparator
.validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage(), actualNamespace, configuration, null);
.validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(), actualPackage, configuration, null);
}
private static NamespaceDescriptorImpl getDeserializedDescriptorsAsNamespace(Collection<DeclarationDescriptor> allDescriptors) {
private static PackageFragmentDescriptor getDeserializedDescriptorsAsPackage(Collection<DeclarationDescriptor> allDescriptors) {
DescriptorSerializer serializer = new DescriptorSerializer();
final Map<ClassId, ProtoBuf.Class> classProtos = serializeClasses(serializer, allDescriptors);
List<ProtoBuf.Callable> callableProtos = serializeCallables(serializer, allDescriptors);
final NamespaceDescriptorImpl actualNamespace = JetTestUtils.createTestNamespace(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME);
final MutablePackageFragmentDescriptor actualPackage = JetTestUtils.createTestPackageFragment(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME);
final NameResolver nameResolver = NameSerializationUtil.createNameResolver(serializer.getNameTable());
DescriptorFinder finder = new AbstractDescriptorFinder(new LockBasedStorageManager(), AnnotationDeserializer.UNSUPPORTED) {
@NotNull
@Override
public NamespaceDescriptor findPackage(@NotNull FqName fqName) {
public PackageFragmentDescriptor findPackage(@NotNull FqName fqName) {
assert fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) : "Unsupported package: " + fqName;
return actualNamespace;
return actualPackage;
}
@NotNull
@@ -110,7 +110,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
case ENUM_CLASS:
case ANNOTATION_CLASS:
case OBJECT:
actualNamespace.getMemberScope().addClassifierDescriptor(classDescriptor);
actualPackage.getMemberScope().addClassifierDescriptor(classDescriptor);
break;
case ENUM_ENTRY:
assert false : "Enum entry appears to be a top-level declaration: " + classDescriptor;
@@ -125,10 +125,10 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
finder.findClass(classId);
}
deserializeCallables(callableProtos, actualNamespace, nameResolver, finder);
deserializeCallables(callableProtos, actualPackage, nameResolver, finder);
actualNamespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
return actualNamespace;
actualPackage.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING);
return actualPackage;
}
private static Map<ClassId, ProtoBuf.Class> serializeClasses(
@@ -163,21 +163,21 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment {
private static void deserializeCallables(
List<ProtoBuf.Callable> callableProtos,
NamespaceDescriptorImpl actualNamespace,
MutablePackageFragmentDescriptor actualPackage,
NameResolver nameResolver,
DescriptorFinder descriptorFinder
) {
DescriptorDeserializer descriptorDeserializer =
DescriptorDeserializer.create(new LockBasedStorageManager(), actualNamespace, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED);
DescriptorDeserializer.create(new LockBasedStorageManager(), actualPackage, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED);
for (ProtoBuf.Callable callableProto : callableProtos) {
CallableMemberDescriptor callableMemberDescriptor = descriptorDeserializer.loadCallable(callableProto);
if (callableMemberDescriptor instanceof PropertyDescriptor) {
PropertyDescriptor propertyDescriptor = (PropertyDescriptor) callableMemberDescriptor;
actualNamespace.getMemberScope().addPropertyDescriptor(propertyDescriptor);
actualPackage.getMemberScope().addPropertyDescriptor(propertyDescriptor);
}
else if (callableMemberDescriptor instanceof FunctionDescriptor) {
FunctionDescriptor functionDescriptor = (FunctionDescriptor) callableMemberDescriptor;
actualNamespace.getMemberScope().addFunctionDescriptor(functionDescriptor);
actualPackage.getMemberScope().addFunctionDescriptor(functionDescriptor);
}
}
}
compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java
+3 -3
View File
@@ -19,7 +19,7 @@ package org.jetbrains.jet.descriptors.serialization;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
import java.util.Collection;
@@ -63,8 +63,8 @@ public class ClassSerializationUtil {
@NotNull
public static ClassId getClassId(@NotNull ClassDescriptor classDescriptor) {
DeclarationDescriptor owner = classDescriptor.getContainingDeclaration();
if (owner instanceof NamespaceDescriptor) {
return new ClassId(((NamespaceDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName()));
if (owner instanceof PackageFragmentDescriptor) {
return new ClassId(((PackageFragmentDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName()));
}
return getClassId((ClassDescriptor) owner).createNestedClassId(classDescriptor.getName());
}
compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt
+2 -2
View File
@@ -55,7 +55,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol
private fun doTest(path: String, getValueToTest: (JetProperty, BindingContext) -> String) {
val myFile = File(path)
val fileText = FileUtil.loadFile(myFile)
val namespaceDescriptor = getNamespaceDescriptor(fileText)
val packageView = getPackage(fileText)
val propertiesForTest = getObjectsToTest(fileText)
@@ -66,7 +66,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol
val expected = InTextDirectivesUtils.findStringWithPrefixes(fileText, expectedProperyPrefix)
assertNotNull(expected, "Failed to find expected directive: $expectedProperyPrefix")
val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(namespaceDescriptor, propertyName)
val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(packageView, propertyName)
val jetProperty = BindingContextUtils.descriptorToDeclaration(context!!, property) as JetProperty
val testedObject = getValueToTest(jetProperty, context!!)
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java
+27 -25
View File
@@ -22,8 +22,10 @@ import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.test.TestCaseWithTmpdir;
@@ -55,43 +57,43 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir
AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(ktFile, tmpdir, getTestRootDisposable(),
ConfigurationKind.JDK_ONLY);
NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
TEST_PACKAGE_FQNAME);
assert namespaceFromSource != null;
Assert.assertEquals("test", namespaceFromSource.getName().asString());
PackageViewDescriptor packageFromSource = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
assert packageFromSource != null;
Assert.assertEquals("test", packageFromSource.getName().asString());
NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromJavaRoot(
PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot(
tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first;
checkUsageOfDeserializedScope(namespaceFromClass);
checkUsageOfDeserializedScope(packageFromBinary);
for (DeclarationDescriptor descriptor : namespaceFromClass.getMemberScope().getAllDescriptors()) {
for (DeclarationDescriptor descriptor : packageFromBinary.getMemberScope().getAllDescriptors()) {
if (descriptor instanceof ClassDescriptor) {
assert descriptor instanceof DeserializedClassDescriptor : DescriptorUtils.getFQName(descriptor) + " is loaded as " + descriptor.getClass();
}
}
validateAndCompareDescriptors(namespaceFromSource, namespaceFromClass,
validateAndCompareDescriptors(packageFromSource, packageFromBinary,
RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
.checkPrimaryConstructors(true)
.checkPropertyAccessors(includeAccessors),
txtFile);
}
private static void checkUsageOfDeserializedScope(@NotNull NamespaceDescriptor namespaceFromClass) {
JetScope scope = namespaceFromClass.getMemberScope();
boolean hasOwnMembers = false;
for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {
if (declarationDescriptor instanceof CallableMemberDescriptor) {
hasOwnMembers = true;
}
}
if (hasOwnMembers) {
assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope.";
}
else {
//NOTE: should probably change
assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members.";
}
// TODO 2 do something
private static void checkUsageOfDeserializedScope(@NotNull PackageViewDescriptor packageFromBinary) {
//JetScope scope = packageFromBinary.getMemberScope();
//boolean hasOwnMembers = false;
//for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {
// if (declarationDescriptor instanceof CallableMemberDescriptor) {
// hasOwnMembers = true;
// }
//}
//if (hasOwnMembers) {
// assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope.";
//}
//else {
// //NOTE: should probably change
// assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members.";
//}
}
}
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java
+24 -26
View File
@@ -33,13 +33,12 @@ import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
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.TopDownAnalysisParameters;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.junit.Assert;
@@ -52,7 +51,6 @@ import java.util.List;
import java.util.Map;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*;
import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES;
import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.*;
@@ -66,10 +64,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
File javaFile = new File(javaFileName);
File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
File txtFile = getTxtFile(javaFile.getPath());
NamespaceDescriptor kotlinNamespace = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.ALL);
Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
PackageViewDescriptor kotlinPackage = analyzeKotlinAndLoadTestPackage(ktFile, myTestRootDisposable, ConfigurationKind.ALL);
Pair<PackageViewDescriptor, BindingContext> javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary(
Arrays.asList(javaFile), tmpdir, myTestRootDisposable, ConfigurationKind.ALL);
checkLoadedNamespaces(txtFile, kotlinNamespace, javaNamespaceAndContext.first, javaNamespaceAndContext.second);
checkLoadedPackages(txtFile, kotlinPackage, javaPackageAndContext.first, javaPackageAndContext.second);
}
protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception {
@@ -105,10 +103,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
getTestRootDisposable(), ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK);
Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
Pair<PackageViewDescriptor, BindingContext> javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary(
srcFiles, compiledDir, getTestRootDisposable(), ConfigurationKind.ALL);
checkJavaNamespace(getTxtFile(javaFileName), javaNamespaceAndContext.first, javaNamespaceAndContext.second, configuration);
checkJavaPackage(getTxtFile(javaFileName), javaPackageAndContext.first, javaPackageAndContext.second, configuration);
}
protected void doTestSourceJava(@NotNull String javaFileName) throws Exception {
@@ -119,11 +117,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
assertTrue(testPackageDir.mkdir());
FileUtil.copy(originalJavaFile, new File(testPackageDir, originalJavaFile.getName()));
Pair<NamespaceDescriptor, BindingContext> javaNamespaceAndContext = loadTestNamespaceAndBindingContextFromJavaRoot(
Pair<PackageViewDescriptor, BindingContext> javaNamespaceAndContext = loadTestPackageAndBindingContextFromJavaRoot(
tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY);
checkJavaNamespace(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second,
DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES));
checkJavaPackage(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second,
DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES));
}
protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception {
@@ -149,6 +147,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace);
ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
environment.getProject(),
new TopDownAnalysisParameters(
@@ -159,21 +158,20 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.<AnalyzerScriptParameter>emptyList());
JavaDescriptorResolver javaDescriptorResolver = injectorForJava.getJavaDescriptorResolver();
NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, INCLUDE_KOTLIN_SOURCES);
assert namespaceDescriptor != null : "Test namespace not found";
PackageViewDescriptor packageView = moduleDescriptor.getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null : "Test namespace not found";
checkJavaNamespace(expectedFile, namespaceDescriptor, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
}
private static void checkForLoadErrorsAndCompare(
@NotNull NamespaceDescriptor javaNamespace,
@NotNull PackageViewDescriptor javaPackage,
@NotNull BindingContext bindingContext,
@NotNull Runnable compareNamespacesRunnable
) {
boolean fail = false;
try {
ExpectedLoadErrorsUtil.checkForLoadErrors(javaNamespace, bindingContext);
ExpectedLoadErrorsUtil.checkForLoadErrors(javaPackage, bindingContext);
}
catch (ComparisonFailure e) {
// to let the next check run even if this one failed
@@ -193,30 +191,30 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
}
}
private static void checkLoadedNamespaces(
private static void checkLoadedPackages(
final File txtFile,
final NamespaceDescriptor kotlinNamespace,
final NamespaceDescriptor javaNamespace,
final PackageViewDescriptor kotlinPackage,
final PackageViewDescriptor javaPackage,
BindingContext bindingContext
) {
checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() {
checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() {
@Override
public void run() {
validateAndCompareDescriptors(kotlinNamespace, javaNamespace, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
validateAndCompareDescriptors(kotlinPackage, javaPackage, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
}
});
}
private static void checkJavaNamespace(
private static void checkJavaPackage(
final File txtFile,
final NamespaceDescriptor javaNamespace,
final PackageViewDescriptor javaPackage,
BindingContext bindingContext,
final Configuration configuration
) {
checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() {
checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() {
@Override
public void run() {
validateAndCompareDescriptorWithFile(javaNamespace, configuration, txtFile);
validateAndCompareDescriptorWithFile(javaPackage, configuration, txtFile);
}
});
}
compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java
+11 -14
View File
@@ -23,13 +23,11 @@ import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.MockLibraryUtil;
import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.*;
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.test.TestCaseWithTmpdir;
import org.jetbrains.jet.test.util.DescriptorValidator;
@@ -64,28 +62,27 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
private void doTestWithTxt(@NotNull File... extraClassPath) throws Exception {
File ktFile = new File(getTestDataDirectory(), getTestName(false) + ".kt");
NamespaceDescriptor namespace = analyzeFileToNamespace(ktFile, extraClassPath);
PackageViewDescriptor packageView = analyzeFileToPackageView(ktFile, extraClassPath);
RecursiveDescriptorComparator.Configuration comparator =
RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(
DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES);
File txtFile = new File(getTestDataDirectory(), FileUtil.getNameWithoutExtension(ktFile) + ".txt");
validateAndCompareDescriptorWithFile(namespace, comparator, txtFile);
validateAndCompareDescriptorWithFile(packageView, comparator, txtFile);
}
@NotNull
private NamespaceDescriptor analyzeFileToNamespace(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException {
private PackageViewDescriptor analyzeFileToPackageView(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException {
Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject();
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
JetTestUtils.loadJetFile(project, ktFile),
Collections.<AnalyzerScriptParameter>emptyList()
).getBindingContext();
);
NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, namespaceDescriptor);
return namespaceDescriptor;
PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView);
return packageView;
}
@NotNull
@@ -102,7 +99,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
@NotNull
private Collection<DeclarationDescriptor> analyzeAndGetAllDescriptors(@NotNull File... extraClassPath) throws IOException {
File ktFile = new File(getTestDataDirectory(), getTestName(true) + ".kt");
return analyzeFileToNamespace(ktFile, extraClassPath).getMemberScope().getAllDescriptors();
return analyzeFileToPackageView(ktFile, extraClassPath).getMemberScope().getAllDescriptors();
}
@NotNull
compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java
+4 -9
View File
@@ -38,10 +38,10 @@ public class ExpectedLoadErrorsUtil {
public static final String ANNOTATION_CLASS_NAME = ExpectLoadError.class.getName();
public static void checkForLoadErrors(
@NotNull NamespaceDescriptor namespaceFromJava,
@NotNull PackageViewDescriptor packageFromJava,
@NotNull BindingContext bindingContext
) {
Map<DeclarationDescriptor, List<String>> expectedErrors = getExpectedLoadErrors(namespaceFromJava);
Map<DeclarationDescriptor, List<String>> expectedErrors = getExpectedLoadErrors(packageFromJava);
Map<DeclarationDescriptor, List<String>> actualErrors = getActualLoadErrors(bindingContext);
for (DeclarationDescriptor descriptor : ContainerUtil.union(expectedErrors.keySet(), actualErrors.keySet())) {
@@ -56,15 +56,10 @@ public class ExpectedLoadErrorsUtil {
}
}
private static Map<DeclarationDescriptor, List<String>> getExpectedLoadErrors(@NotNull NamespaceDescriptor namespaceFromJava) {
private static Map<DeclarationDescriptor, List<String>> getExpectedLoadErrors(@NotNull PackageViewDescriptor packageFromJava) {
final Map<DeclarationDescriptor, List<String>> map = new HashMap<DeclarationDescriptor, List<String>>();
namespaceFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
@Override
public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) {
return visitDeclarationRecursively(descriptor, descriptor.getMemberScope());
}
packageFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies<Void, Void>() {
@Override
public Void visitPackageViewDescriptor(PackageViewDescriptor descriptor, Void data) {
return visitDeclarationRecursively(descriptor, descriptor.getMemberScope());
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java
+16 -14
View File
@@ -31,7 +31,7 @@ import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -47,7 +47,6 @@ import java.util.Collection;
import java.util.Collections;
import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations;
import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
public final class LoadDescriptorUtil {
@@ -73,7 +72,7 @@ public final class LoadDescriptorUtil {
}
@NotNull
public static Pair<NamespaceDescriptor, BindingContext> loadTestNamespaceAndBindingContextFromJavaRoot(
public static Pair<PackageViewDescriptor, BindingContext> loadTestPackageAndBindingContextFromJavaRoot(
@NotNull File javaRoot,
@NotNull Disposable disposable,
@NotNull ConfigurationKind configurationKind
@@ -87,15 +86,14 @@ public final class LoadDescriptorUtil {
JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
BindingTraceContext trace = new BindingTraceContext();
InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace);
NamespaceDescriptor namespaceDescriptor =
injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, IGNORE_KOTLIN_SOURCES);
assert namespaceDescriptor != null;
PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null;
return Pair.create(namespaceDescriptor, trace.getBindingContext());
return Pair.create(packageView, trace.getBindingContext());
}
@NotNull
public static Pair<NamespaceDescriptor, BindingContext> compileJavaAndLoadTestNamespaceAndBindingContextFromBinary(
public static Pair<PackageViewDescriptor, BindingContext> compileJavaAndLoadTestPackageAndBindingContextFromBinary(
@NotNull Collection<File> javaFiles,
@NotNull File outDir,
@NotNull Disposable disposable,
@@ -103,7 +101,7 @@ public final class LoadDescriptorUtil {
)
throws IOException {
compileJavaWithAnnotationsJar(javaFiles, outDir);
return loadTestNamespaceAndBindingContextFromJavaRoot(outDir, disposable, configurationKind);
return loadTestPackageAndBindingContextFromJavaRoot(outDir, disposable, configurationKind);
}
private static void compileJavaWithAnnotationsJar(@NotNull Collection<File> javaFiles, @NotNull File outDir) throws IOException {
@@ -117,12 +115,16 @@ public final class LoadDescriptorUtil {
}
@NotNull
public static NamespaceDescriptor analyzeKotlinAndLoadTestNamespace(@NotNull File ktFile, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind) throws Exception {
public static PackageViewDescriptor analyzeKotlinAndLoadTestPackage(
@NotNull File ktFile,
@NotNull Disposable disposable,
@NotNull ConfigurationKind configurationKind
) throws Exception {
JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(ktFile, disposable, configurationKind);
NamespaceDescriptor namespace =
fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME);
assert namespace != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName();
return namespace;
PackageViewDescriptor packageView =
fileAndExhaust.getExhaust().getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName();
return packageView;
}
private static class JetFileAndExhaust {
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+4 -4
View File
@@ -54,7 +54,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
Collection<JetFile> files = Lists.newArrayList(psiFile);
ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration());
LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager();
final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,
@@ -64,9 +64,9 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
psiFile.accept(new JetVisitorVoid() {
@Override
public void visitJetFile(@NotNull JetFile file) {
String qualifiedName = file.getNamespaceHeader().getQualifiedName();
if (!qualifiedName.isEmpty()) {
NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(new FqName(qualifiedName));
FqName fqName = file.getNamespaceHeader().getFqName();
if (!fqName.isRoot()) {
PackageViewDescriptor packageDescriptor = lazyModule.getPackage(fqName);
descriptors.add(packageDescriptor);
}
file.acceptChildren(this);
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java
+3 -2
View File
@@ -22,6 +22,7 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTest;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -45,8 +46,8 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag
ModuleDescriptor eagerModule = LazyResolveTestUtil.resolveEagerly(jetFiles, getEnvironment());
String path = JetTestUtils.getFilePath(new File(FileUtil.getRelativePath(TEST_DATA_DIR, testDataFile)));
NamespaceDescriptor expected = eagerModule.getNamespace(FqName.ROOT);
NamespaceDescriptor actual = lazyModule.getNamespace(FqName.ROOT);
PackageViewDescriptor expected = eagerModule.getPackage(FqName.ROOT);
PackageViewDescriptor actual = lazyModule.getPackage(FqName.ROOT);
String txtFileRelativePath = path.replaceAll("\\.kt$|\\.ktscript", ".txt");
File txtFile = new File("compiler/testData/lazyResolve/diagnostics/" + txtFileRelativePath);
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java
+3 -2
View File
@@ -23,6 +23,7 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -73,10 +74,10 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe
FqName test = new FqName("test");
NamespaceDescriptor actual = lazyModule.getNamespace(test);
PackageViewDescriptor actual = lazyModule.getPackage(test);
Assert.assertNotNull("Namespace for name " + test + " is null after lazy resolve", actual);
NamespaceDescriptor expected = eagerModule.getNamespace(test);
PackageViewDescriptor expected = eagerModule.getPackage(test);
Assert.assertNotNull("Namespace for name " + test + " is null after eager resolve", expected);
File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt");
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
+2 -3
View File
@@ -24,10 +24,9 @@ import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.resolve.ExpectedResolveData;
import org.jetbrains.jet.resolve.JetExpectedResolveDataUtil;
@@ -75,7 +74,7 @@ public abstract class AbstractLazyResolveTest extends JetLiteFixture {
KotlinCodeAnalyzer resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment(), true);
NamespaceDescriptor actual = resolveSession.getPackageDescriptorByFqName(new FqName("test"));
PackageViewDescriptor actual = resolveSession.getModuleDescriptor().getPackage(new FqName("test"));
Assert.assertNotNull("Package 'test' was not found", actual);
resolveSession.forceResolveAll();
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java
+2 -2
View File
@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.lazy;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import java.io.File;
@@ -33,7 +33,7 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment {
}
public void testBuiltIns() throws Exception {
NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage();
PackageFragmentDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackageFragment();
validateAndCompareDescriptorWithFile(builtInsPackage, RECURSIVE_ALL, new File("compiler/testData/builtin-classes.txt"));
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java
+3 -2
View File
@@ -23,6 +23,7 @@ import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
@@ -52,8 +53,8 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag
ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment);
for (Name name : namespaceShortNames) {
NamespaceDescriptor eager = module.getNamespace(FqName.topLevel(name));
NamespaceDescriptor lazy = lazyModule.getNamespace(FqName.topLevel(name));
PackageViewDescriptor eager = module.getPackage(FqName.topLevel(name));
PackageViewDescriptor lazy = lazyModule.getPackage(FqName.topLevel(name));
RecursiveDescriptorComparator.validateAndCompareDescriptors(eager, lazy, RecursiveDescriptorComparator.RECURSIVE, null);
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
+1 -1
View File
@@ -90,7 +90,7 @@ public class LazyResolveTestUtil {
}
public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment, boolean addBuiltIns) {
return resolveLazilyWithSession(files, environment, addBuiltIns).getRootModuleDescriptor();
return resolveLazilyWithSession(files, environment, addBuiltIns).getModuleDescriptor();
}
@NotNull
compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java
+9
View File
@@ -27,12 +27,14 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
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.name.FqName;
import java.io.IOException;
import java.util.ArrayList;
@@ -94,6 +96,13 @@ public class DescriptorRendererTest extends JetLiteFixture {
AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, Collections.<AnalyzerScriptParameter>emptyList());
final BindingContext bindingContext = analyzeExhaust.getBindingContext();
final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
FqName fqName = psiFile.getNamespaceHeader().getFqName();
if (!fqName.isRoot()) {
PackageViewDescriptor packageDescriptor = analyzeExhaust.getModuleDescriptor().getPackage(fqName);
descriptors.add(packageDescriptor);
}
psiFile.acceptChildren(new JetVisitorVoid() {
@Override
public void visitJetElement(@NotNull JetElement element) {
compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+2 -2
View File
@@ -261,7 +261,7 @@ public abstract class ExpectedResolveData {
}
assert expected != null : "No declaration for " + name;
if (referenceTarget instanceof NamespaceDescriptor) {
if (referenceTarget instanceof PackageViewDescriptor) {
JetNamespaceHeader expectedHeader = PsiTreeUtil.getParentOfType(expected, JetNamespaceHeader.class);
FqName expectedFqName;
if (expectedHeader != null) {
@@ -275,7 +275,7 @@ public abstract class ExpectedResolveData {
else {
throw new IllegalStateException(expected.getClass().getName() + " name=" + name);
}
assertEquals(expectedFqName, ((NamespaceDescriptor) referenceTarget).getFqName());
assertEquals(expectedFqName, ((PackageViewDescriptor) referenceTarget).getFqName());
continue;
}
compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java
+19 -16
View File
@@ -22,6 +22,7 @@ import com.intellij.util.Function;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -44,9 +45,10 @@ import java.util.List;
public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFixture {
private static final String PATH = "compiler/testData/resolveAnnotations/testFile.kt";
private static final FqName NAMESPACE = new FqName("test");
private static final FqName PACKAGE = new FqName("test");
protected BindingContext context;
protected AnalyzeExhaust analyzeExhaust;
@Override
protected JetCoreEnvironment createEnvironment() {
@@ -54,7 +56,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
}
protected void doTest(@NotNull String content, @NotNull String expectedAnnotation) {
NamespaceDescriptor test = getNamespaceDescriptor(content);
PackageViewDescriptor test = getPackage(content);
ClassDescriptor myClass = getClassDescriptor(test, "MyClass");
checkDescriptor(expectedAnnotation, myClass);
checkDescriptor(expectedAnnotation, getClassObjectDescriptor(myClass));
@@ -97,11 +99,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
}
@NotNull
private static FunctionDescriptor getFunctionDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
protected static FunctionDescriptor getFunctionDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
Name functionName = Name.identifier(name);
JetScope memberScope = namespaceDescriptor.getMemberScope();
JetScope memberScope = packageView.getMemberScope();
Collection<FunctionDescriptor> functions = memberScope.getFunctions(functionName);
assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + namespaceDescriptor.getName();
assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + packageView.getName();
return functions.iterator().next();
}
@@ -115,11 +117,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
}
@NotNull
protected static PropertyDescriptor getPropertyDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
protected static PropertyDescriptor getPropertyDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
Name propertyName = Name.identifier(name);
JetScope memberScope = namespaceDescriptor.getMemberScope();
JetScope memberScope = packageView.getMemberScope();
Collection<VariableDescriptor> properties = memberScope.getProperties(propertyName);
assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + namespaceDescriptor.getName();
assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + packageView.getName();
return (PropertyDescriptor) properties.iterator().next();
}
@@ -133,10 +135,10 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
}
@NotNull
protected static ClassDescriptor getClassDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) {
protected static ClassDescriptor getClassDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) {
Name className = Name.identifier(name);
ClassifierDescriptor aClass = namespaceDescriptor.getMemberScope().getClassifier(className);
assertNotNull("Failed to find class: " + namespaceDescriptor.getName() + "." + className, aClass);
ClassifierDescriptor aClass = packageView.getMemberScope().getClassifier(className);
assertNotNull("Failed to find class: " + packageView.getName() + "." + className, aClass);
assert aClass instanceof ClassDescriptor : "Not a class: " + aClass;
return (ClassDescriptor) aClass;
}
@@ -257,13 +259,14 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
}
@NotNull
protected NamespaceDescriptor getNamespaceDescriptor(@NotNull String content) {
protected PackageViewDescriptor getPackage(@NotNull String content) {
JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject());
context = JetTestUtils.analyzeFile(ktFile).getBindingContext();
analyzeExhaust = JetTestUtils.analyzeFile(ktFile);
context = analyzeExhaust.getBindingContext();
NamespaceDescriptor namespaceDescriptor = context.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, NAMESPACE);
assertNotNull("Failed to find namespace: " + NAMESPACE, namespaceDescriptor);
return namespaceDescriptor;
PackageViewDescriptor packageView = analyzeExhaust.getModuleDescriptor().getPackage(PACKAGE);
assertNotNull("Failed to find namespace: " + PACKAGE, packageView);
return packageView;
}
protected static String getContent(@NotNull String annotationText) throws IOException {
compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt
+2 -2
View File
@@ -24,8 +24,8 @@ import org.jetbrains.jet.JetTestUtils
public abstract class AbstractAnnotationParameterTest : AbstractAnnotationDescriptorResolveTest() {
fun doTest(path: String) {
val fileText = FileUtil.loadFile(File(path))
val namespaceDescriptor = getNamespaceDescriptor(fileText)
val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(namespaceDescriptor, "MyClass")
val packageView = getPackage(fileText)
val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(packageView, "MyClass")
val expected = InTextDirectivesUtils.findListWithPrefixes(fileText, "// EXPECTED: ").makeString(", ")
val actual = AbstractAnnotationDescriptorResolveTest.getAnnotations(classDescriptor)
compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java
+7 -8
View File
@@ -356,12 +356,13 @@ public class DescriptorValidator {
private void assertFound(
@NotNull JetScope scope,
@NotNull DeclarationDescriptor expected,
@Nullable DeclarationDescriptor found
@Nullable DeclarationDescriptor found,
boolean shouldBeSame
) {
if (found == null) {
report(expected, "Not found in " + scope);
}
if (expected != found) {
if (shouldBeSame ? expected != found : !expected.equals(found)) {
report(expected, "Lookup error in " + scope + ": " + found);
}
}
@@ -380,8 +381,7 @@ public class DescriptorValidator {
public Void visitNamespaceDescriptor(
NamespaceDescriptor descriptor, JetScope scope
) {
assertFound(scope, descriptor, scope.getNamespace(descriptor.getName()));
return null;
throw new IllegalStateException("namespace don't exist");
}
@Override
@@ -395,8 +395,7 @@ public class DescriptorValidator {
public Void visitPackageViewDescriptor(
PackageViewDescriptor descriptor, JetScope scope
) {
// TODO
//assertFound(scope, descriptor, scope.getPackage(descriptor.getName()));
assertFound(scope, descriptor, scope.getPackage(descriptor.getName()), false);
return null;
}
@@ -420,7 +419,7 @@ public class DescriptorValidator {
public Void visitTypeParameterDescriptor(
TypeParameterDescriptor descriptor, JetScope scope
) {
assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()));
assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true);
return null;
}
@@ -428,7 +427,7 @@ public class DescriptorValidator {
public Void visitClassDescriptor(
ClassDescriptor descriptor, JetScope scope
) {
assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()));
assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true);
return null;
}
compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java
+9 -7
View File
@@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.MemberComparator;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -78,14 +77,14 @@ public class RecursiveDescriptorComparator {
}
private void appendDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull Printer printer, boolean topLevel) {
if (descriptor instanceof ClassOrNamespaceDescriptor && !topLevel) {
if ((descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) && !topLevel) {
printer.println();
}
boolean isPrimaryConstructor = descriptor instanceof ConstructorDescriptor && ((ConstructorDescriptor) descriptor).isPrimary();
printer.print(isPrimaryConstructor && conf.checkPrimaryConstructors ? "/*primary*/ " : "", conf.renderer.render(descriptor));
if (descriptor instanceof ClassOrNamespaceDescriptor) {
if (descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) {
if (!topLevel) {
printer.printlnWithNoIndent(" {").pushIndent();
}
@@ -98,8 +97,12 @@ public class RecursiveDescriptorComparator {
ClassDescriptor klass = (ClassDescriptor) descriptor;
appendSubDescriptors(klass.getDefaultType().getMemberScope(), getConstructorsAndClassObject(klass), printer);
}
else if (descriptor instanceof NamespaceDescriptor) {
appendSubDescriptors(((NamespaceDescriptor) descriptor).getMemberScope(),
else if (descriptor instanceof PackageFragmentDescriptor) {
appendSubDescriptors(((PackageFragmentDescriptor) descriptor).getMemberScope(),
Collections.<DeclarationDescriptor>emptyList(), printer);
}
else if (descriptor instanceof PackageViewDescriptor) {
appendSubDescriptors(((PackageViewDescriptor) descriptor).getMemberScope(),
Collections.<DeclarationDescriptor>emptyList(), printer);
}
@@ -142,7 +145,7 @@ public class RecursiveDescriptorComparator {
&& JAVA_OBJECT_METHOD_NAMES.contains(subDescriptor.getName().asString())
&& !conf.includeMethodsOfJavaObject
||
subDescriptor instanceof NamespaceDescriptor && !conf.recurseIntoPackage.apply(DescriptorUtils.getFQName(subDescriptor));
subDescriptor instanceof PackageViewDescriptor && !conf.recurseIntoPackage.apply(((PackageViewDescriptor) subDescriptor).getFqName().toUnsafe()); // TODO 2 accept safe fq name instead
}
private void appendSubDescriptors(
@@ -216,7 +219,6 @@ public class RecursiveDescriptorComparator {
if (expected != null) {
String expectedSerialized = comparator.serializeRecursively(expected);
Assert.assertSame(expected.getClass(), actual.getClass());
Assert.assertEquals("Expected and actual descriptors differ", expectedSerialized, actualSerialized);
}
compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java
+1 -1
View File
@@ -118,7 +118,7 @@ public class RecursiveDescriptorProcessor {
@Override
public Boolean visitModuleDeclaration(ModuleDescriptor descriptor, D data) {
return applyWorker(descriptor, data)
&& visitChildren(descriptor.getNamespace(FqName.ROOT), data);
&& visitChildren(descriptor.getPackage(FqName.ROOT), data);
}
@Override
compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java
+3 -5
View File
@@ -44,7 +44,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
String text = FileUtil.loadFile(ktFile);
JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
AnalyzeExhaust exhaust = JetTestUtils.analyzeFile(jetFile);
NamespaceDescriptor testPackage = exhaust.getModuleDescriptor().getNamespace(FqName.topLevel(Name.identifier("test")));
PackageViewDescriptor testPackage = exhaust.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test")));
assert testPackage != null;
List<String> descriptors = recursivelyCollectDescriptors(testPackage);
@@ -74,7 +74,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
return closestInterface(aClass.getSuperclass());
}
private static List<String> recursivelyCollectDescriptors(NamespaceDescriptor testPackage) {
private static List<String> recursivelyCollectDescriptors(PackageViewDescriptor testPackage) {
final List<String> lines = Lists.newArrayList();
RecursiveDescriptorProcessor.process(testPackage, null, new DeclarationDescriptorVisitor<Boolean, Void>() {
@@ -98,9 +98,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
}
@Override
public Boolean visitPackageFragmentDescriptor(
PackageFragmentDescriptor descriptor, Void data
) {
public Boolean visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, Void data) {
add(descriptor);
return true;
}
compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java
+1 -1
View File
@@ -72,7 +72,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment {
private void doTest(String text, String expected) {
JetFile jetFile = JetPsiFactory.createFile(getProject(), "fun.kt", text);
ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
Collection<FunctionDescriptor> functions = module.getNamespace(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"));
Collection<FunctionDescriptor> functions = module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"));
assert functions.size() == 1 : "Many functions defined";
FunctionDescriptor function = ContainerUtil.getFirstItem(functions);
compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+8 -8
View File
@@ -28,12 +28,13 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForTests;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.ImportPath;
import org.jetbrains.jet.lang.resolve.TypeResolver;
import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -52,9 +53,6 @@ import java.io.File;
import java.io.IOException;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES;
public class JetTypeCheckerTest extends JetLiteFixture {
private KotlinBuiltIns builtIns;
@@ -578,7 +576,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
getEnvironment()
);
NamespaceDescriptor testData = moduleDescriptor.getNamespace(new FqName("testData"));
PackageFragmentDescriptor testData = moduleDescriptor.getPackageFragmentProvider().getPackageFragments(new FqName("testData")).get(0); // TODO 2 hack
return addImports(testData.getMemberScope());
}
@@ -588,10 +586,12 @@ public class JetTypeCheckerTest extends JetLiteFixture {
scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, INCLUDE_KOTLIN_SOURCES).getMemberScope());
writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), IGNORE_KOTLIN_SOURCES).getMemberScope());
ModuleDescriptor module = javaDescriptorResolver.getPackageFragmentProvider().getModule();
for (ImportPath defaultImport : module.getDefaultImports()) {
writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());
}
writableScope.importScope(module.getPackage(FqName.ROOT).getMemberScope());
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
writableScope.importScope(builtIns.getBuiltInsScope());
return writableScope;
}
compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java
+1 -1
View File
@@ -83,7 +83,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt"));
JetFile jetFile = JetPsiFactory.createFile(getProject(), text);
ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
JetScope topLevelDeclarations = module.getNamespace(FqName.ROOT).getMemberScope();
JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope();
ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context"));
assert contextClass instanceof ClassDescriptor;
WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.EMPTY, module, RedeclarationHandler.THROW_EXCEPTION,