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

using guice to wire TopDownAnalyzer beans

Browse Source 
attempt 2
This commit is contained in:
Stepan Koltsov
2012-03-10 00:54:16 +04:00
parent 26a5ff3a2f
commit 997fbb60a3
56 changed files with 1175 additions and 737 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/compiler-tests.iml
+1
View File
@@ -14,6 +14,7 @@
<orderEntry type="module" module-name="cli" />
<orderEntry type="library" name="idea-full" level="project" />
<orderEntry type="library" name="asm" level="project" />
<orderEntry type="library" name="guice-3.0" level="project" />
</component>
</module>
compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java
+1 -3
View File
@@ -25,7 +25,6 @@ import junit.framework.Test;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
@@ -112,8 +111,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
jetCoreEnvironment.addToClasspath(tmpdir);
jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject());
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext());
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
return javaDescriptorResolver.resolveNamespace("test");
compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java
+1 -3
View File
@@ -29,7 +29,6 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.codegen.ClassBuilderFactories;
import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
@@ -90,8 +89,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
jetCoreEnvironment.addToClasspath(tmpdir);
jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject());
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext());
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace("test");
compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java
+1 -3
View File
@@ -23,7 +23,6 @@ import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.util.PsiTreeUtil;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
@@ -135,8 +134,7 @@ public abstract class ExpectedResolveData {
}
final Set<PsiElement> unresolvedReferences = Sets.newHashSet();
Project project = files.iterator().next().getProject();
JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(project);
JetStandardLibrary lib = semanticServices.getStandardLibrary();
JetStandardLibrary lib = JetStandardLibrary.getInstance();
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Predicates.<PsiFile>alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY);
for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java
+9 -5
View File
@@ -16,6 +16,7 @@
package org.jetbrains.jet.resolve;
import com.google.inject.Guice;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.project.Project;
import com.intellij.psi.JavaPsiFacade;
@@ -25,17 +26,16 @@ import com.intellij.psi.PsiMethod;
import junit.framework.Test;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule;
import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -119,8 +119,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
@NotNull
private PsiClass findClass(String qualifiedName) {
Project project = getProject();
JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(project);
JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, jetSemanticServices, new BindingTraceContext());
JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, new BindingTraceContext());
return javaSemanticServices.getDescriptorResolver().findClass(qualifiedName);
}
@@ -135,7 +134,12 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
List<JetType> parameterTypeList = Arrays.asList(parameterType);
// JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext());
CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY);
CallResolver callResolver = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) {
@Override
protected void configureAfter() {
}
}).getInstance(CallResolver.class);
OverloadResolutionResults<FunctionDescriptor> functions = callResolver.resolveExactSignature(
classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList);
for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
+14 -8
View File
@@ -16,13 +16,15 @@
package org.jetbrains.jet.types;
import com.google.inject.Guice;
import com.google.inject.Injector;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
@@ -50,9 +52,13 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
private JetScope scope;
public void setUp() throws Exception {
JetStandardLibrary library = JetStandardLibrary.getInstance();
JetSemanticServices semanticServices = JetSemanticServices.createSemanticServices(library);
descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE);
Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) {
@Override
protected void configureAfter() {
}
});
JetStandardLibrary library = injector.getInstance(JetStandardLibrary.class);
descriptorResolver = injector.getInstance(DescriptorResolver.class);
scope = createScope(library.getLibraryScope());
}
@@ -72,7 +78,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
private MutableClassDescriptor createClassDescriptor(ClassKind kind, JetClass aClass) {
MutableClassDescriptor classDescriptor = new MutableClassDescriptor(JetTestUtils.DUMMY_TRACE, root, scope, kind);
descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor);
descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor, JetTestUtils.DUMMY_TRACE);
return classDescriptor;
}
@@ -90,7 +96,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
List<JetDeclaration> declarations = aClass.getDeclarations();
JetNamedFunction function = (JetNamedFunction) declarations.get(0);
SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function);
SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function, JetTestUtils.DUMMY_TRACE);
assertEquals(expectedFunctionModality, functionDescriptor.getModality());
}
@@ -101,7 +107,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
List<JetDeclaration> declarations = aClass.getDeclarations();
JetProperty property = (JetProperty) declarations.get(0);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property, JetTestUtils.DUMMY_TRACE);
assertEquals(expectedPropertyModality, propertyDescriptor.getModality());
}
@@ -113,7 +119,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
List<JetDeclaration> declarations = aClass.getDeclarations();
JetProperty property = (JetProperty) declarations.get(0);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property);
PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(classDescriptor, scope, property, JetTestUtils.DUMMY_TRACE);
PropertyAccessorDescriptor propertyAccessor = isGetter
? propertyDescriptor.getGetter()
: propertyDescriptor.getSetter();
compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java
+11 -6
View File
@@ -16,16 +16,18 @@
package org.jetbrains.jet.types;
import com.google.inject.Guice;
import com.google.inject.Injector;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.OverloadUtil;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
/**
@@ -35,15 +37,18 @@ public class JetOverloadTest extends JetLiteFixture {
private ModuleDescriptor root = new ModuleDescriptor("test_root");
private JetStandardLibrary library;
private JetSemanticServices semanticServices;
private DescriptorResolver descriptorResolver;
@Override
public void setUp() throws Exception {
super.setUp();
library = JetStandardLibrary.getInstance();
semanticServices = JetSemanticServices.createSemanticServices(library);
descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) {
@Override
protected void configureAfter() {
}
});
library = injector.getInstance(JetStandardLibrary.class);
descriptorResolver = injector.getInstance(DescriptorResolver.class);
}
@Override
@@ -171,7 +176,7 @@ public class JetOverloadTest extends JetLiteFixture {
private FunctionDescriptor makeFunction(String funDecl) {
JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl);
return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function, JetTestUtils.DUMMY_TRACE);
}
}
compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
+11 -6
View File
@@ -16,16 +16,18 @@
package org.jetbrains.jet.types;
import com.google.inject.Guice;
import com.google.inject.Injector;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.DescriptorResolver;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisModule;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
/**
@@ -35,15 +37,18 @@ public class JetOverridingTest extends JetLiteFixture {
private ModuleDescriptor root = new ModuleDescriptor("test_root");
private JetStandardLibrary library;
private JetSemanticServices semanticServices;
private DescriptorResolver descriptorResolver;
@Override
public void setUp() throws Exception {
super.setUp();
library = JetStandardLibrary.getInstance();
semanticServices = JetSemanticServices.createSemanticServices(library);
descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) {
@Override
protected void configureAfter() {
}
});
library = injector.getInstance(JetStandardLibrary.class);
descriptorResolver = injector.getInstance(DescriptorResolver.class);
}
@Override
@@ -161,6 +166,6 @@ public class JetOverridingTest extends JetLiteFixture {
private FunctionDescriptor makeFunction(String funDecl) {
JetNamedFunction function = JetPsiFactory.createFunction(getProject(), funDecl);
return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function);
return descriptorResolver.resolveFunctionDescriptor(root, library.getLibraryScope(), function, JetTestUtils.DUMMY_TRACE);
}
}
compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+32 -20
View File
@@ -17,13 +17,14 @@
package org.jetbrains.jet.types;
import com.google.common.collect.Sets;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.*;
@@ -36,6 +37,8 @@ import org.jetbrains.jet.lang.resolve.scopes.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import org.jetbrains.jet.lexer.JetTokens;
@@ -48,11 +51,12 @@ import java.util.*;
public class JetTypeCheckerTest extends JetLiteFixture {
private JetStandardLibrary library;
private JetSemanticServices semanticServices;
private ClassDefinitions classDefinitions;
private DescriptorResolver descriptorResolver;
private JetScope scopeWithImports;
private TypeResolver typeResolver;
private ExpressionTypingServices expressionTypingServices;
public JetTypeCheckerTest() {
super("");
@@ -62,11 +66,19 @@ public class JetTypeCheckerTest extends JetLiteFixture {
public void setUp() throws Exception {
super.setUp();
library = JetStandardLibrary.getInstance();
semanticServices = JetSemanticServices.createSemanticServices(library);
classDefinitions = new ClassDefinitions();
descriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
Injector injector = Guice.createInjector(new TopDownAnalysisModule(getProject(), false) {
@Override
protected void configureAfter() {
}
});
descriptorResolver = injector.getInstance(DescriptorResolver.class);
descriptorResolver = injector.getInstance(DescriptorResolver.class);
typeResolver = injector.getInstance(TypeResolver.class);
expressionTypingServices = injector.getInstance(ExpressionTypingServices.class);
scopeWithImports = addImports(classDefinitions.BASIC_SCOPE);
typeResolver = new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true);
}
@Override
@@ -513,7 +525,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
for (String type : types) {
typesToIntersect.add(makeType(type));
}
JetType result = TypeUtils.intersect(semanticServices.getTypeChecker(), typesToIntersect);
JetType result = TypeUtils.intersect(JetTypeChecker.INSTANCE, typesToIntersect);
// assertNotNull("Intersection is null for " + typesToIntersect, result);
assertEquals(makeType(expected), result);
}
@@ -530,7 +542,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private void assertSubtypingRelation(String subtype, String supertype, boolean expected) {
JetType typeNode1 = makeType(subtype);
JetType typeNode2 = makeType(supertype);
boolean result = semanticServices.getTypeChecker().isSubtypeOf(
boolean result = JetTypeChecker.INSTANCE.isSubtypeOf(
typeNode1,
typeNode2);
String modifier = expected ? "not " : "";
@@ -540,14 +552,14 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private void assertType(String expression, JetType expectedType) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).getType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE);
JetType type = expressionTypingServices.getType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE);
assertTrue(type + " != " + expectedType, type.equals(expectedType));
}
private void assertErrorType(String expression) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).safeGetType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE);
JetType type = expressionTypingServices.safeGetType(scopeWithImports, jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE);
assertTrue("Error type expected but " + type + " returned", ErrorUtils.isErrorType(type));
}
@@ -570,7 +582,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private void assertType(JetScope scope, String expression, String expectedTypeStr) {
Project project = getProject();
JetExpression jetExpression = JetPsiFactory.createExpression(project, expression);
JetType type = semanticServices.getTypeInferrerServices(JetTestUtils.DUMMY_TRACE).getType(addImports(scope), jetExpression, TypeUtils.NO_EXPECTED_TYPE);
JetType type = expressionTypingServices.getType(addImports(scope), jetExpression, TypeUtils.NO_EXPECTED_TYPE, JetTestUtils.DUMMY_TRACE);
JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr);
assertEquals(expectedType, type);
}
@@ -578,7 +590,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private WritableScopeImpl addImports(JetScope scope) {
WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING);
writableScope.importScope(library.getLibraryScope());
JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), semanticServices, JetTestUtils.DUMMY_TRACE);
JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE);
writableScope.importScope(new JavaPackageScope("", JavaBridgeConfiguration.createNamespaceDescriptor(JavaDescriptorResolver.JAVA_ROOT, ""), javaSemanticServices));
writableScope.importScope(new JavaPackageScope("java.lang", JavaBridgeConfiguration.createNamespaceDescriptor("lang", "java.lang"), javaSemanticServices));
writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -590,7 +602,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
}
private JetType makeType(JetScope scope, String typeStr) {
return new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true).resolveType(scope, JetPsiFactory.createType(getProject(), typeStr));
return typeResolver.resolveType(scope, JetPsiFactory.createType(getProject(), typeStr), JetTestUtils.DUMMY_TRACE, true);
}
private class ClassDefinitions {
@@ -657,7 +669,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
Set<FunctionDescriptor> writableFunctionGroup = Sets.newLinkedHashSet();
ModuleDescriptor module = new ModuleDescriptor("TypeCheckerTest");
for (String funDecl : FUNCTION_DECLARATIONS) {
FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl));
FunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(module, this, JetPsiFactory.createFunction(getProject(), funDecl), JetTestUtils.DUMMY_TRACE);
if (name.equals(functionDescriptor.getName())) {
writableFunctionGroup.add(functionDescriptor);
}
@@ -682,14 +694,14 @@ public class JetTypeCheckerTest extends JetLiteFixture {
// This call has side-effects on the parameterScope (fills it in)
List<TypeParameterDescriptor> typeParameters
= descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters);
= descriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters(), JetTestUtils.DUMMY_TRACE);
descriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters, JetTestUtils.DUMMY_TRACE);
List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
// TODO : assuming that the hierarchy is acyclic
Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
? Collections.singleton(JetStandardClasses.getAnyType())
: descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
: 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);
@@ -706,7 +718,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
@Override
public void visitProperty(JetProperty property) {
if (property.getPropertyTypeRef() != null) {
memberDeclarations.addPropertyDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property));
memberDeclarations.addPropertyDescriptor(descriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property, JetTestUtils.DUMMY_TRACE));
} else {
// TODO : Caution: a cyclic dependency possible
throw new UnsupportedOperationException();
@@ -716,7 +728,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
@Override
public void visitNamedFunction(JetNamedFunction function) {
if (function.getReturnTypeRef() != null) {
memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function));
memberDeclarations.addFunctionDescriptor(descriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function, JetTestUtils.DUMMY_TRACE));
} else {
// TODO : Caution: a cyclic dependency possible
throw new UnsupportedOperationException();
@@ -740,11 +752,11 @@ public class JetTypeCheckerTest extends JetLiteFixture {
null
);
for (JetSecondaryConstructor constructor : classElement.getSecondaryConstructors()) {
ConstructorDescriptorImpl functionDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
ConstructorDescriptorImpl functionDescriptor = descriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor, JetTestUtils.DUMMY_TRACE);
functionDescriptor.setReturnType(classDescriptor.getDefaultType());
constructors.add(functionDescriptor);
}
ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
ConstructorDescriptorImpl primaryConstructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement, JetTestUtils.DUMMY_TRACE);
if (primaryConstructorDescriptor != null) {
primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
constructors.add(primaryConstructorDescriptor);