From 7d8bde2ac6a6699414dd4898b46045b704444560 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 22 Nov 2012 15:15:38 +0400 Subject: [PATCH] Test data moved out of JetTypeCheckerTest --- compiler/testData/type-checker-test.kt | 37 ++++ .../tests/org/jetbrains/jet/JetTestUtils.java | 6 + .../jet/types/JetTypeCheckerTest.java | 198 +++--------------- 3 files changed, 68 insertions(+), 173 deletions(-) create mode 100644 compiler/testData/type-checker-test.kt diff --git a/compiler/testData/type-checker-test.kt b/compiler/testData/type-checker-test.kt new file mode 100644 index 00000000000..da0cb9a9c4b --- /dev/null +++ b/compiler/testData/type-checker-test.kt @@ -0,0 +1,37 @@ +package testData + +open class Base_T() +open class Derived_T() : Base_T +open class DDerived_T() : Derived_T +open class DDerived1_T() : Derived_T +open class DDerived2_T() : Derived_T, Base_T +open class Base_inT() +open class Derived_inT() : Base_inT +open class Derived1_inT() : Base_inT, Derived_T +open class Base_outT() +open class Derived_outT() : Base_outT +open class MDerived_T() : Base_outT, Base_T + +class Properties() { val p : Int } +class Props() { val p : T } +class Functions() { + fun f() : Unit {} + fun f(a : Int) : Int {} + fun f(a : T) : Any {} + fun f(a : Pair) : T {} + fun f(a : E) : T {} +} +class WithPredicate() { + fun isValid() : Boolean + fun isValid(x : Int) : Boolean + val p : Boolean +} + +open class List() +open class AbstractList : List +open class ArrayList() : Any, AbstractList, List + +fun f() : Unit {} +fun f(a : Int) : Int {a} +fun f(a : Float, b : Int) : Float {a} +fun f(a : Float) : T {a} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 790114813a5..859a0107461 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.diagnostics.Severity; import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -493,4 +494,9 @@ public class JetTestUtils { public static KotlinPaths getPathsForTests() { return new KotlinPaths(new File("dist/kotlinc")); } + + public static JetFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException { + String text = FileUtil.loadFile(ioFile); + return JetPsiFactory.createFile(project, text); + } } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 07e8ce5f4bc..8330bc73f17 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -20,7 +20,6 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; @@ -28,13 +27,18 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptorImpl; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.resolve.DescriptorResolver; +import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +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.scopes.*; @@ -46,8 +50,9 @@ import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.lexer.JetTokens; +import java.io.File; +import java.io.IOException; import java.util.*; /** @@ -56,7 +61,6 @@ import java.util.*; public class JetTypeCheckerTest extends JetLiteFixture { private KotlinBuiltIns builtIns; - private ClassDefinitions classDefinitions; private DescriptorResolver descriptorResolver; private JetScope scopeWithImports; private TypeResolver typeResolver; @@ -77,14 +81,13 @@ public class JetTypeCheckerTest extends JetLiteFixture { super.setUp(); builtIns = KotlinBuiltIns.getInstance(); - classDefinitions = new ClassDefinitions(); InjectorForTests injector = new InjectorForTests(getProject()); descriptorResolver = injector.getDescriptorResolver(); typeResolver = injector.getTypeResolver(); expressionTypingServices = injector.getExpressionTypingServices(); - scopeWithImports = addImports(classDefinitions.BASIC_SCOPE); + scopeWithImports = getDeclarationsScope("compiler/testData/type-checker-test.kt"); } @Override @@ -576,12 +579,12 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertType(String contextType, final String expression, String expectedType) { final JetType thisType = makeType(contextType); - JetScope scope = new JetScopeAdapter(classDefinitions.BASIC_SCOPE) { + JetScope scope = new JetScopeAdapter(scopeWithImports) { @NotNull @Override public List getImplicitReceiversHierarchy() { return Lists.newArrayList(new ReceiverParameterDescriptorImpl( - classDefinitions.BASIC_SCOPE.getContainingDeclaration(), + getContainingDeclaration(), thisType, new ExpressionReceiver(JetPsiFactory.createExpression(getProject(), expression), thisType) )); @@ -602,10 +605,19 @@ public class JetTypeCheckerTest extends JetLiteFixture { assertEquals(expectedType, type); } + private WritableScope getDeclarationsScope(String path) throws IOException { + ModuleDescriptor moduleDescriptor = LazyResolveTestUtil.resolveEagerly( + Collections.singletonList(JetTestUtils.loadJetFile(getProject(), new File(path))), + getEnvironment() + ); + + NamespaceDescriptor testData = moduleDescriptor.getRootNamespace().getMemberScope().getNamespace(Name.identifier("testData")); + return addImports(testData.getMemberScope()); + } + private WritableScopeImpl addImports(JetScope scope) { WritableScopeImpl writableScope = new WritableScopeImpl( scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"); - writableScope.importScope(builtIns.getBuiltInsScope()); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, @@ -613,6 +625,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope()); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); + writableScope.importScope(builtIns.getBuiltInsScope()); return writableScope; } @@ -623,165 +636,4 @@ public class JetTypeCheckerTest extends JetLiteFixture { private JetType makeType(JetScope scope, String typeStr) { return typeResolver.resolveType(scope, JetPsiFactory.createType(getProject(), typeStr), JetTestUtils.DUMMY_TRACE, true); } - - private class ClassDefinitions { - private Map CLASSES = new HashMap(); - private String[] CLASS_DECLARATIONS = { - "open class Base_T()", - "open class Derived_T() : Base_T", - "open class DDerived_T() : Derived_T", - "open class DDerived1_T() : Derived_T", - "open class DDerived2_T() : Derived_T, Base_T", - "open class Base_inT()", - "open class Derived_inT() : Base_inT", - "open class Derived1_inT() : Base_inT, Derived_T", - "open class Base_outT()", - "open class Derived_outT() : Base_outT", - "open class MDerived_T() : Base_outT, Base_T", - "class Properties() { val p : Int }", - "class Props() { val p : T }", - "class Functions() { " + - "fun f() : Unit {} " + - "fun f(a : Int) : Int {} " + - "fun f(a : T) : Any {} " + - "fun f(a : #(Int, Int)) : T {} " + - "fun f(a : E) : T {} " + - "}", - "class WithPredicate() { " + - "fun isValid() : Boolean " + - "fun isValid(x : Int) : Boolean " + - "val p : Boolean " + - "}", - - "open class List()", - "open class AbstractList : List", - "open class ArrayList() : Any, AbstractList, List" - - }; - private String[] FUNCTION_DECLARATIONS = { - "fun f() : Unit {}", - "fun f(a : Int) : Int {a}", - "fun f(a : Float, b : Int) : Float {a}", - "fun f(a : Float) : T {a}", - }; - - public JetScope BASIC_SCOPE = new JetScopeAdapter(builtIns.getBuiltInsScope()) { - @Override - public ClassifierDescriptor getClassifier(@NotNull Name name) { - if (CLASSES.isEmpty()) { - for (String classDeclaration : CLASS_DECLARATIONS) { - JetClass classElement = JetPsiFactory.createClass(getProject(), classDeclaration); - ClassDescriptor classDescriptor = resolveClassDescriptor(this, classElement); - CLASSES.put(classDescriptor.getName().getName(), classDescriptor); - } - } - ClassDescriptor classDescriptor = CLASSES.get(name.getName()); - if (classDescriptor != null) { - return classDescriptor; - } - return super.getClassifier(name); - } - - @NotNull - @Override - public Collection getFunctions(@NotNull Name name) { - Set writableFunctionGroup = Sets.newLinkedHashSet(); - for (String funDecl : FUNCTION_DECLARATIONS) { - FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(this.getContainingDeclaration(), this, JetPsiFactory.createFunction(getProject(), funDecl), JetTestUtils.DUMMY_TRACE); - if (name.equals(functionDescriptor.getName())) { - writableFunctionGroup.add(functionDescriptor); - } - } - return writableFunctionGroup; - } - }; - - @Nullable - public ClassDescriptor resolveClassDescriptor(@NotNull JetScope scope, @NotNull JetClass classElement) { - final ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl( - scope.getContainingDeclaration(), - Collections.emptyList(), - Modality.FINAL, - JetPsiUtil.safeName(classElement.getName())); - - BindingTrace trace = JetTestUtils.DUMMY_TRACE; - - trace.record(BindingContext.CLASS, classElement, classDescriptor); - - final WritableScope parameterScope = new WritableScopeImpl( - scope, classDescriptor, new TraceBasedRedeclarationHandler(trace), "JetTypeCheckerTest.resolveClassDescriptor"); - parameterScope.changeLockLevel(WritableScope.LockLevel.BOTH); - - // This call has side-effects on the parameterScope (fills it in) - List typeParameters - = descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters(), JetTestUtils.DUMMY_TRACE); - descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters, JetTestUtils.DUMMY_TRACE); - - List delegationSpecifiers = classElement.getDelegationSpecifiers(); - // TODO : assuming that the hierarchy is acyclic - Collection supertypes = delegationSpecifiers.isEmpty() - ? Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()) - : descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver, JetTestUtils.DUMMY_TRACE, true); - // for (JetType supertype: supertypes) { - // if (supertype.getConstructor().isSealed()) { - // trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype); - // } - // } - boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD); - - final WritableScope memberDeclarations = new WritableScopeImpl( - JetScope.EMPTY, classDescriptor, new TraceBasedRedeclarationHandler(trace), "JetTypeCheckerTest.resolveClassDescriptor"); - memberDeclarations.changeLockLevel(WritableScope.LockLevel.BOTH); - - List declarations = classElement.getDeclarations(); - for (JetDeclaration declaration : declarations) { - declaration.accept(new JetVisitorVoid() { - @Override - public void visitProperty(JetProperty property) { - if (property.getTypeRef() != null) { - memberDeclarations.addPropertyDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property, JetTestUtils.DUMMY_TRACE)); - } - else { - // TODO : Caution: a cyclic dependency possible - throw new UnsupportedOperationException(); - } - } - - @Override - public void visitNamedFunction(JetNamedFunction function) { - if (function.getReturnTypeRef() != null) { - memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function, JetTestUtils.DUMMY_TRACE)); - } - else { - // TODO : Caution: a cyclic dependency possible - throw new UnsupportedOperationException(); - } - } - - @Override - public void visitJetElement(JetElement element) { - throw new UnsupportedOperationException(element.toString()); - } - }); - } - - Set constructors = Sets.newLinkedHashSet(); - classDescriptor.initialize( - !open, - typeParameters, - supertypes, - memberDeclarations, - constructors, - null - ); - ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement, JetTestUtils.DUMMY_TRACE); - if (primaryConstructorDescriptor != null) { - primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType()); - constructors.add(primaryConstructorDescriptor); - classDescriptor.setPrimaryConstructor(primaryConstructorDescriptor); - } - return classDescriptor; - } - - } }