diff --git a/.gitignore b/.gitignore index 927b20cd726..57a2b37fbb5 100644 --- a/.gitignore +++ b/.gitignore @@ -11,7 +11,7 @@ patches-master out dist ideaSDK -PluginVerifier +dependencies .idea/dictionaries/yozh.xml .idea/workspace.xml tmp diff --git a/.idea/runConfigurations/Integration_Tests.xml b/.idea/runConfigurations/Integration_Tests.xml new file mode 100644 index 00000000000..218f6e6775d --- /dev/null +++ b/.idea/runConfigurations/Integration_Tests.xml @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TeamCityBuild.xml b/TeamCityBuild.xml index a37cd929ec5..212ce07014f 100644 --- a/TeamCityBuild.xml +++ b/TeamCityBuild.xml @@ -14,7 +14,7 @@ - + diff --git a/bin/kotlin b/bin/kotlin index 5cca3809cde..933ac6ed261 100755 --- a/bin/kotlin +++ b/bin/kotlin @@ -23,6 +23,7 @@ classpath="$classpath:$root/out/production/stdlib" classpath="$classpath:$root/lib/*:$ideaRoot/lib/*:$ideaRoot/lib/rt/*" exec java $JAVA_OPTS \ + -ea \ -classpath "$classpath" \ org.jetbrains.jet.cli.jvm.K2JVMCompiler \ "$@" diff --git a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java index b8944f95dba..79611687b46 100644 --- a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java +++ b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java @@ -51,8 +51,8 @@ public class BytecodeCompiler { */ private CompileEnvironmentConfiguration env( String stdlib, String[] classpath ) { CompilerDependencies dependencies = CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR); - JetCoreEnvironment environment = JetCoreEnvironment.getCoreEnvironmentForJVM(CompileEnvironmentUtil.createMockDisposable(), dependencies); - CompileEnvironmentConfiguration env = new CompileEnvironmentConfiguration(environment, dependencies, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); + JetCoreEnvironment environment = new JetCoreEnvironment(CompileEnvironmentUtil.createMockDisposable(), dependencies); + CompileEnvironmentConfiguration env = new CompileEnvironmentConfiguration(environment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); if (( stdlib != null ) && ( stdlib.trim().length() > 0 )) { File file = new File(stdlib); diff --git a/build.xml b/build.xml index 99b8c4a2b8b..e772fe4ef7d 100644 --- a/build.xml +++ b/build.xml @@ -170,9 +170,12 @@ - + + - + + + @@ -180,7 +183,24 @@ + + + + + + + + + + + + + + + + + @@ -193,11 +213,13 @@ + - - + - + + + @@ -217,8 +239,57 @@ - + + + + + + (kotlinc.internal.com.intellij.lang.ASTNode); + } + + # Keep the special static methods that are required in enumeration classes. + -keepclassmembers enum * { + public static **[] values(); + public static ** valueOf(java.lang.String); + } + + -keepclassmembers class * { + ** toString(); + ** hashCode(); + ** project(); + + ** TYPE; + ** ourInstance; + } + ]]> + diff --git a/build/jarjar-1.2.jar b/build/jarjar-1.2.jar deleted file mode 100644 index e32d30cd2ac..00000000000 Binary files a/build/jarjar-1.2.jar and /dev/null differ diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index e497db59abb..174511076d0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -154,7 +154,8 @@ public class ExpressionCodegen extends JetVisitor { throw e; } catch (Throwable error) { - throw new CompilationException(error.getMessage(), error, selector); + String message = error.getMessage(); + throw new CompilationException(message != null ? message : "null", error, selector); } } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java index 234191b7749..8c3c821e1f7 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java @@ -179,8 +179,8 @@ public class K2JVMCompiler extends CLICompiler sourceFiles = Lists.newArrayList(); - + private final List sourceFiles = new ArrayList(); @NotNull - public static JetCoreEnvironment getCoreEnvironmentForJVM(@NotNull Disposable disposable, - @NotNull CompilerDependencies compilerDependencies) { - JetCoreEnvironment coreEnvironment = new JetCoreEnvironment(disposable); + private final CompilerDependencies compilerDependencies; - CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); - - coreEnvironment.addToClasspath(compilerDependencies.getJdkJar()); - - if (compilerSpecialMode.includeJdkHeaders()) { - for (VirtualFile root : compilerDependencies.getJdkHeaderRoots()) { - coreEnvironment.addLibraryRoot(root); - } - } - if (compilerSpecialMode.includeKotlinRuntime()) { - for (VirtualFile root : compilerDependencies.getRuntimeRoots()) { - coreEnvironment.addLibraryRoot(root); - } - } - return coreEnvironment; - } - - @NotNull - public static JetCoreEnvironment getCoreEnvironmentForJS(@NotNull Disposable disposable) { - return new JetCoreEnvironment(disposable); - } - - private JetCoreEnvironment(Disposable parentDisposable) { + public JetCoreEnvironment(Disposable parentDisposable, @NotNull CompilerDependencies compilerDependencies) { super(parentDisposable); + + this.compilerDependencies = compilerDependencies; + registerFileType(JetFileType.INSTANCE, "kt"); registerFileType(JetFileType.INSTANCE, "kts"); registerFileType(JetFileType.INSTANCE, "ktm"); @@ -90,6 +68,19 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { .getExtensionPoint(PsiElementFinder.EP_NAME) .registerExtension(new JavaElementFinder(myProject)); + CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); + + addToClasspath(compilerDependencies.getJdkJar()); + + if (compilerSpecialMode.includeJdkHeaders()) { + for (VirtualFile root : compilerDependencies.getJdkHeaderRoots()) { + addLibraryRoot(root); + } + } + if (compilerSpecialMode.includeKotlinRuntime()) { + addToClasspath(compilerDependencies.getRuntimeJar()); + } + JetStandardLibrary.initialize(getProject()); } @@ -98,7 +89,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { } private void addSources(File file) { - if (file.isDirectory()) { + if(file.isDirectory()) { File[] files = file.listFiles(); if (files != null) { for (File child : files) { @@ -110,7 +101,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { VirtualFile fileByPath = getLocalFileSystem().findFileByPath(file.getAbsolutePath()); if (fileByPath != null) { PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(fileByPath); - if (psiFile instanceof JetFile) { + if(psiFile instanceof JetFile) { sourceFiles.add((JetFile)psiFile); } } @@ -118,7 +109,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { } public void addSources(VirtualFile vFile) { - if (vFile.isDirectory()) { + if (vFile.isDirectory()) { for (VirtualFile virtualFile : vFile.getChildren()) { addSources(virtualFile); } @@ -134,9 +125,8 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { } public void addSources(String path) { - if (path == null) { + if(path == null) return; - } VirtualFile vFile = getLocalFileSystem().findFileByPath(path); if (vFile == null) { @@ -155,17 +145,20 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { public void addToClasspathFromClassLoader(ClassLoader loader) { ClassLoader parent = loader.getParent(); - if (parent != null) { + if(parent != null) addToClasspathFromClassLoader(parent); - } - if (loader instanceof URLClassLoader) { - for (URL url : ((URLClassLoader)loader).getURLs()) { + if(loader instanceof URLClassLoader) { + for (URL url : ((URLClassLoader) loader).getURLs()) { File file = new File(url.getPath()); - if (file.exists() && (!file.isFile() || file.getPath().endsWith(".jar"))) { + if(file.exists() && (!file.isFile() || file.getPath().endsWith(".jar"))) addToClasspath(file); - } } } } + + @NotNull + public CompilerDependencies getCompilerDependencies() { + return compilerDependencies; + } } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 436f60bc28a..57082240c07 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -72,7 +72,7 @@ public class KotlinToJVMBytecodeCompiler { configuration.getEnvironment().addToClasspath(new File(classpathRoot)); } - CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getCompilerDependencies()); + CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies()); GenerationState generationState = analyzeAndGenerate(configuration); if (generationState == null) { @@ -93,9 +93,9 @@ public class KotlinToJVMBytecodeCompiler { for (Module moduleBuilder : modules) { // TODO: this should be done only once for the environment - if (configuration.getCompilerDependencies().getRuntimeJar() != null) { + if (configuration.getEnvironment().getCompilerDependencies().getRuntimeJar() != null) { CompileEnvironmentUtil - .addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar()); + .addToClasspath(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies().getRuntimeJar()); } ClassFileFactory moduleFactory = compileModule(configuration, moduleBuilder, directory); if (moduleFactory == null) { @@ -132,7 +132,7 @@ public class KotlinToJVMBytecodeCompiler { } } - CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getCompilerDependencies()); + CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies()); GenerationState generationState = analyzeAndGenerate(configuration); if (generationState == null) { @@ -198,7 +198,7 @@ public class KotlinToJVMBytecodeCompiler { @Nullable public static GenerationState analyzeAndGenerate(CompileEnvironmentConfiguration configuration) { - return analyzeAndGenerate(configuration, configuration.getCompilerDependencies().getCompilerSpecialMode().isStubs()); + return analyzeAndGenerate(configuration, configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode().isStubs()); } @Nullable @@ -233,7 +233,7 @@ public class KotlinToJVMBytecodeCompiler { return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY, - configuration.getCompilerDependencies()); + configuration.getEnvironment().getCompilerDependencies()); } }, environment.getSourceFiles() ); @@ -256,7 +256,7 @@ public class KotlinToJVMBytecodeCompiler { }; GenerationState generationState = new GenerationState(project, ClassBuilderFactories.binaries(stubs), backendProgress, exhaust, environment.getSourceFiles(), - configuration.getCompilerDependencies().getCompilerSpecialMode()); + configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode()); generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); List plugins = configuration.getCompilerPlugins(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index c47411575c4..8ce7e33559e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -959,7 +959,7 @@ public class JavaDescriptorResolver { continue; } - JetType transform = semanticServices.getTypeTransformer().transformToType(type, typeVariableResolver); + JetType transform = semanticServices.getTypeTransformer().transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver); result.add(TypeUtils.makeNotNullable(transform)); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index 0da95ba01fc..8b853b146f9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -33,11 +33,9 @@ import org.jetbrains.jet.lang.types.lang.PrimitiveType; import org.jetbrains.jet.rt.signature.JetSignatureReader; import javax.inject.Inject; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; + +import static org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer.TypeUsage.*; /** * @author abreslav @@ -66,9 +64,11 @@ public class JavaTypeTransformer { @NotNull - public TypeProjection transformToTypeProjection(@NotNull final PsiType javaType, + private TypeProjection transformToTypeProjection(@NotNull final PsiType javaType, @NotNull final TypeParameterDescriptor typeParameterDescriptor, - @NotNull final TypeVariableResolver typeVariableByPsiResolver) { + @NotNull final TypeVariableResolver typeVariableByPsiResolver, + @NotNull final TypeUsage howThisTypeIsUsed + ) { TypeProjection result = javaType.accept(new PsiTypeVisitor() { @Override @@ -85,12 +85,12 @@ public class JavaTypeTransformer { PsiType bound = wildcardType.getBound(); assert bound != null; - return new TypeProjection(variance, transformToType(bound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver)); + return new TypeProjection(variance, transformToType(bound, UPPER_BOUND, typeVariableByPsiResolver)); } @Override public TypeProjection visitType(PsiType type) { - return new TypeProjection(transformToType(type, TypeUsage.TYPE_ARGUMENT, typeVariableByPsiResolver)); + return new TypeProjection(transformToType(type, howThisTypeIsUsed, typeVariableByPsiResolver)); } }); return result; @@ -136,7 +136,7 @@ public class JavaTypeTransformer { if (psiMethod.isConstructor()) { Set supertypesJet = Sets.newHashSet(); for (PsiClassType supertype : typeParameter.getExtendsListTypes()) { - supertypesJet.add(transformToType(supertype, TypeUsage.UPPER_BOUND, typeVariableResolver)); + supertypesJet.add(transformToType(supertype, UPPER_BOUND, typeVariableResolver)); } return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet); } @@ -144,20 +144,24 @@ public class JavaTypeTransformer { TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName()); - if (howThisTypeIsUsed == TypeUsage.TYPE_ARGUMENT || howThisTypeIsUsed == TypeUsage.UPPER_BOUND) { - // In Java: ArrayList - // In Kotlin: ArrayList, not ArrayList - // nullability will be taken care of in individual member signatures - return typeParameterDescriptor.getDefaultType(); + // In Java: ArrayList + // In Kotlin: ArrayList, not ArrayList + // nullability will be taken care of in individual member signatures + boolean nullable = !EnumSet.of(TYPE_ARGUMENT, UPPER_BOUND, SUPERTYPE_ARGUMENT).contains(howThisTypeIsUsed); + if (nullable) { + return TypeUtils.makeNullable(typeParameterDescriptor.getDefaultType()); } else { - return TypeUtils.makeNullable(typeParameterDescriptor.getDefaultType()); + return typeParameterDescriptor.getDefaultType(); } } else { + // 'L extends List' in Java is a List in Kotlin, not a List + boolean nullable = !EnumSet.of(SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed); + JetType jetAnalog = getKotlinAnalog(new FqName(psiClass.getQualifiedName())); if (jetAnalog != null) { - return jetAnalog; + return TypeUtils.makeNullableAsSpecified(jetAnalog, nullable); } final ClassDescriptor classData = @@ -187,13 +191,15 @@ public class JavaTypeTransformer { PsiType psiArgument = psiArguments[i]; TypeParameterDescriptor typeParameterDescriptor = parameters.get(i); - arguments.add(transformToTypeProjection(psiArgument, typeParameterDescriptor, typeVariableResolver)); + TypeUsage howTheProjectionIsUsed = howThisTypeIsUsed == SUPERTYPE ? SUPERTYPE_ARGUMENT : TYPE_ARGUMENT; + arguments.add(transformToTypeProjection(psiArgument, typeParameterDescriptor, typeVariableResolver, howTheProjectionIsUsed)); } } + return new JetTypeImpl( Collections.emptyList(), classData.getTypeConstructor(), - true, + nullable, arguments, classData.getMemberScope(arguments)); } @@ -291,6 +297,7 @@ public class JavaTypeTransformer { MEMBER_SIGNATURE_COVARIANT, MEMBER_SIGNATURE_CONTRAVARIANT, MEMBER_SIGNATURE_INVARIANT, - SUPERTYPE + SUPERTYPE, + SUPERTYPE_ARGUMENT } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index 95b0446da29..3e5650d8ee6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -127,10 +127,20 @@ public class FunctionDescriptorUtil { JetStandardClasses.getValueParameters(functionDescriptor, functionType), JetStandardClasses.getReturnTypeFromFunctionType(functionType), Modality.FINAL, - Visibilities.LOCAL); + Visibilities.PUBLIC); } public static D alphaConvertTypeParameters(D candidate) { return (D) candidate.substitute(MAKE_TYPE_PARAMETERS_FRESH); } + + public static FunctionDescriptor getInvokeFunction(@NotNull JetType functionType) { + assert JetStandardClasses.isFunctionType(functionType); + + ClassifierDescriptor classDescriptorForFunction = functionType.getConstructor().getDeclarationDescriptor(); + assert classDescriptorForFunction instanceof ClassDescriptor; + Set invokeFunctions = ((ClassDescriptor) classDescriptorForFunction).getMemberScope(functionType.getArguments()).getFunctions("invoke"); + assert invokeFunctions.size() == 1; + return invokeFunctions.iterator().next(); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index 189655ec333..997ef40c1fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -51,7 +51,7 @@ public interface Errors { //Elements with "INVISIBLE_REFERENCE" error are marked as unresolved, unlike elements with "INVISIBLE_MEMBER" error DiagnosticFactory2 INVISIBLE_REFERENCE = DiagnosticFactory2.create(ERROR); - DiagnosticFactory2 INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR, PositioningStrategies.CALL_ELEMENT); RedeclarationDiagnosticFactory REDECLARATION = new RedeclarationDiagnosticFactory(ERROR); RedeclarationDiagnosticFactory NAME_SHADOWING = new RedeclarationDiagnosticFactory(WARNING); @@ -247,12 +247,12 @@ public interface Errors { public List mark(@NotNull JetDeclarationWithBody element) { JetExpression bodyExpression = element.getBodyExpression(); if (!(bodyExpression instanceof JetBlockExpression)) { - return Collections.emptyList(); + return markElement(element); } JetBlockExpression blockExpression = (JetBlockExpression)bodyExpression; TextRange lastBracketRange = blockExpression.getLastBracketRange(); if (lastBracketRange == null) { - return Collections.emptyList(); + return markElement(element); } return markRange(lastBracketRange); } @@ -288,7 +288,6 @@ public interface Errors { @NotNull @Override public List mark(@NotNull JetWhenExpression element) { - if (hasSyntaxError(element)) return Collections.emptyList(); return markElement(element.getWhenKeywordElement()); } }); @@ -403,7 +402,7 @@ public interface Errors { JetClass klass = (JetClass)jetDeclaration; PsiElement nameAsDeclaration = klass.getNameIdentifier(); if (nameAsDeclaration == null) { - return markRange(klass.getTextRange()); + return markElement(klass); } PsiElement primaryConstructorParameterList = klass.getPrimaryConstructorParameterList(); if (primaryConstructorParameterList == null) { @@ -416,7 +415,7 @@ public interface Errors { } else { // safe way - return markRange(jetDeclaration.getTextRange()); + return markElement(jetDeclaration); } } }); @@ -449,7 +448,7 @@ public interface Errors { class Initializer { static { for (Field field : Errors.class.getFields()) { - if ((field.getModifiers() & Modifier.STATIC) != 0) { + if (Modifier.isStatic(field.getModifiers())) { try { Object value = field.get(null); if (value instanceof AbstractDiagnosticFactory) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java index eb98b2857c4..0f9f14ac019 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java @@ -59,10 +59,9 @@ public class PositioningStrategies { returnTypeRef = accessor.getReturnTypeReference(); nameNode = accessor.getNamePlaceholder().getNode(); } - if (returnTypeRef != null) return Collections.singletonList(returnTypeRef.getTextRange()); - if (nameNode != null) return Collections.singletonList(nameNode.getTextRange()); - return super.mark(declaration); - + if (returnTypeRef != null) return markElement(returnTypeRef); + if (nameNode != null) return markNode(nameNode); + return markElement(declaration); } private ASTNode getNameNode(JetNamedDeclaration function) { @@ -75,14 +74,11 @@ public class PositioningStrategies { @NotNull @Override public List mark(@NotNull PsiNameIdentifierOwner element) { - if (element.getLastChild() instanceof PsiErrorElement) { - return Collections.emptyList(); - } PsiElement nameIdentifier = element.getNameIdentifier(); if (nameIdentifier != null) { return markElement(nameIdentifier); } - return Collections.emptyList(); + return markElement(element); } }; @@ -100,9 +96,9 @@ public class PositioningStrategies { assert modifierList != null; ASTNode node = modifierList.getModifierNode(token); assert node != null; - return Collections.singletonList(node.getTextRange()); + return markNode(node); } - return Collections.emptyList(); + return markElement(modifierListOwner); } }; } @@ -151,4 +147,18 @@ public class PositioningStrategies { return markNode(element.getDefaultValue().getNode()); } }; + + public static PositioningStrategy CALL_ELEMENT = new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull PsiElement callElement) { + if (callElement instanceof JetCallElement) { + JetExpression calleeExpression = ((JetCallElement) callElement).getCalleeExpression(); + if (calleeExpression != null) { + return markElement(calleeExpression); + } + } + return markElement(callElement); + } + }; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java index fd80049556d..992f4317ad6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java @@ -34,7 +34,10 @@ public class UnresolvedReferenceDiagnosticFactory extends DiagnosticFactory1 mark(@NotNull JetReferenceExpression element) { if (element instanceof JetArrayAccessExpression) { - return ((JetArrayAccessExpression) element).getBracketRanges(); + List ranges = ((JetArrayAccessExpression) element).getBracketRanges(); + if (!ranges.isEmpty()) { + return ranges; + } } return Collections.singletonList(element.getTextRange()); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java index dc96f771033..bd148492f1f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java @@ -17,7 +17,9 @@ package org.jetbrains.jet.lang.diagnostics.rendering; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.psi.JetTypeConstraint; @@ -25,6 +27,8 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.resolve.DescriptorRenderer; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; import java.util.Collection; import java.util.Iterator; @@ -401,6 +405,22 @@ public class DefaultErrorMessages { "This may cause problems when calling this function with named arguments.", commaSeparated(TO_STRING), TO_STRING); MAP.setImmutable(); + + for (Field field : Errors.class.getFields()) { + if (Modifier.isStatic(field.getModifiers())) { + try { + Object fieldValue = field.get(null); + if (fieldValue instanceof AbstractDiagnosticFactory) { + if (MAP.get((AbstractDiagnosticFactory) fieldValue) == null) { + throw new IllegalStateException("No default diagnostic renderer is provided for " + ((AbstractDiagnosticFactory)fieldValue).getName()); + } + } + } + catch (IllegalAccessException e) { + throw new IllegalStateException(e); + } + } + } } private DefaultErrorMessages() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java index 4d5a1fa5937..d3c46683dbb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java @@ -36,6 +36,9 @@ public interface Call { @NotNull ReceiverDescriptor getExplicitReceiver(); + @NotNull + ReceiverDescriptor getThisObject(); + @Nullable JetExpression getCalleeExpression(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java index b9479f4766a..c4cac2803cd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java @@ -20,14 +20,10 @@ import com.google.common.collect.Lists; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -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.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableAsFunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.VariableAsFunctionResolvedCall; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.Slices; @@ -68,7 +64,7 @@ public class BindingContextUtils { @Nullable public static PsiElement resolveToDeclarationPsiElement(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression referenceExpression) { - DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression); + DeclarationDescriptor declarationDescriptor = referenceToDescriptor(bindingContext, referenceExpression); if (declarationDescriptor == null) { return bindingContext.get(BindingContext.LABEL_TARGET, referenceExpression); } @@ -88,7 +84,7 @@ public class BindingContextUtils { @NotNull public static List resolveToDeclarationPsiElements(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression referenceExpression) { - DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression); + DeclarationDescriptor declarationDescriptor = referenceToDescriptor(bindingContext, referenceExpression); if (declarationDescriptor == null) { return Lists.newArrayList(bindingContext.get(BindingContext.LABEL_TARGET, referenceExpression)); } @@ -114,7 +110,7 @@ public class BindingContextUtils { descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element); } else if (element instanceof JetSimpleNameExpression) { - descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element); + descriptor = referenceToDescriptor(bindingContext, (JetSimpleNameExpression) element); } else if (element instanceof JetQualifiedExpression) { descriptor = extractVariableDescriptorIfAny(bindingContext, ((JetQualifiedExpression) element).getSelectorExpression(), onlyReference); @@ -128,6 +124,16 @@ public class BindingContextUtils { return null; } + @Nullable + public static DeclarationDescriptor referenceToDescriptor(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression element) { + DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, element); + ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, element); + if (resolvedCall instanceof VariableAsFunctionResolvedCall) { + descriptor = ((VariableAsFunctionResolvedCall) resolvedCall).getVariableCall().getResultingDescriptor(); + } + return descriptor; + } + // TODO these helper methods are added as a workaround to some compiler bugs in Kotlin... // NOTE this is used by KDoc diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java new file mode 100644 index 00000000000..b168498bb7e --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve; + +/** + * @author svtk + */ +public class ChainedTemporaryBindingTrace extends TemporaryBindingTrace { + + public static ChainedTemporaryBindingTrace create(TemporaryBindingTrace trace) { + return new ChainedTemporaryBindingTrace(trace); + } + + private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace) { + super(trace); + } + + @Override + public void commit() { + super.commit(); + ((TemporaryBindingTrace) trace).commit(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java index 3ef25b43833..661969e7550 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java @@ -45,6 +45,11 @@ public final class ImportPath { return fqName.getFqName() + (isAllUnder ? ".*" : ""); } + @Override + public String toString() { + return getPathStr(); + } + @NotNull public FqName fqnPart() { return fqName; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java index e8c3425c812..3122f54397d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java @@ -25,10 +25,9 @@ public class TemporaryBindingTrace extends DelegatingBindingTrace { return new TemporaryBindingTrace(trace); } - private final BindingTrace trace; + protected final BindingTrace trace; - - private TemporaryBindingTrace(BindingTrace trace) { + protected TemporaryBindingTrace(BindingTrace trace) { super(trace.getBindingContext()); this.trace = trace; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallMaker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallMaker.java index abdb02465b6..98e42503e85 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallMaker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallMaker.java @@ -98,6 +98,12 @@ public class CallMaker { return explicitReceiver; } + @NotNull + @Override + public ReceiverDescriptor getThisObject() { + return ReceiverDescriptor.NO_RECEIVER; + } + @Override public JetExpression getCalleeExpression() { return calleeExpression; @@ -199,6 +205,12 @@ public class CallMaker { return explicitReceiver; } + @NotNull + @Override + public ReceiverDescriptor getThisObject() { + return ReceiverDescriptor.NO_RECEIVER; + } + @Nullable public JetExpression getCalleeExpression() { return callElement.getCalleeExpression(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java index 03c5013330a..e5f8c356056 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java @@ -20,21 +20,27 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; /** * @author svtk */ -public final class CallResolutionContext extends ResolutionContext { +public final class CallResolutionContext extends ResolutionContext { /*package*/ final ResolvedCallImpl candidateCall; /*package*/ final TracingStrategy tracing; + /*package*/ ReceiverDescriptor receiverForVariableAsFunctionSecondCall = ReceiverDescriptor.NO_RECEIVER; - public CallResolutionContext(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { + private CallResolutionContext(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { super(trace, task.scope, call, task.expectedType, task.dataFlowInfo); this.candidateCall = candidateCall; this.tracing = tracing; } - public CallResolutionContext(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) { - this(candidateCall, task, trace, tracing, task.call); + public static CallResolutionContext create(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) { + return new CallResolutionContext(candidateCall, task, trace, tracing, call); + } + + public static CallResolutionContext create(@NotNull ResolvedCallImpl candidateCall, @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) { + return create(candidateCall, task, trace, tracing, task.call); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 219f06d9156..1e699b0ca63 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -102,16 +102,16 @@ public class CallResolver { if (referencedName == null) { return OverloadResolutionResultsImpl.nameNotFound(); } - List> memberPrioritizers = Lists.newArrayList(); + List> callableDescriptorCollectors = Lists.newArrayList(); if (nameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) { referencedName = referencedName.substring(1); - memberPrioritizers.add(MemberPrioritizers.PROPERTY_TASK_PRIORITIZER); + callableDescriptorCollectors.add(CallableDescriptorCollectors.PROPERTIES); } else { - memberPrioritizers.add(MemberPrioritizers.VARIABLE_TASK_PRIORITIZER); + callableDescriptorCollectors.add(CallableDescriptorCollectors.VARIABLES); } - List> prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, referencedName, nameExpression, memberPrioritizers); - return doResolveCall(context, prioritizedTasks, CallTransformationStrategy.PROPERTY_CALL_TRANSFORMATION_STRATEGY, nameExpression); + List> prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, referencedName, nameExpression, callableDescriptorCollectors); + return doResolveCall(context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, nameExpression); } @NotNull @@ -119,9 +119,8 @@ public class CallResolver { @NotNull BasicResolutionContext context, @NotNull final JetReferenceExpression functionReference, @NotNull String name) { - List> tasks = TaskPrioritizer.computePrioritizedTasks( - context, name, functionReference, Collections.singletonList(MemberPrioritizers.FUNCTION_TASK_PRIORITIZER)); - return doResolveCall(context, tasks, CallTransformationStrategy.FUNCTION_CALL_TRANSFORMATION_STRATEGY, functionReference); + List> tasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES); + return doResolveCall(context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference); } @NotNull @@ -131,7 +130,7 @@ public class CallResolver { @NotNull public OverloadResolutionResults resolveFunctionCall(@NotNull BasicResolutionContext context) { - List> prioritizedTasks; + List> prioritizedTasks; JetExpression calleeExpression = context.call.getCalleeExpression(); final JetReferenceExpression functionReference; @@ -142,7 +141,7 @@ public class CallResolver { String name = expression.getReferencedName(); if (name == null) return checkArgumentTypesAndFail(context); - prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, Collections.singletonList(MemberPrioritizers.FUNCTION_TASK_PRIORITIZER)); + prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES); ResolutionTask.DescriptorCheckStrategy abstractConstructorCheck = new ResolutionTask.DescriptorCheckStrategy() { @Override public boolean performAdvancedChecks(D descriptor, BindingTrace trace, TracingStrategy tracing) { @@ -184,8 +183,8 @@ public class CallResolver { context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn)); return checkArgumentTypesAndFail(context); } - Collection> candidates = TaskPrioritizer.convertWithImpliedThis(context.scope, Collections.singletonList(NO_RECEIVER), constructors); - prioritizedTasks.add(new ResolutionTask(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY + Collection> candidates = TaskPrioritizer.convertWithImpliedThis(context.scope, Collections.singletonList(NO_RECEIVER), constructors); + prioritizedTasks.add(new ResolutionTask(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY } else { context.trace.report(NOT_A_CLASS.on(calleeExpression)); @@ -206,8 +205,8 @@ public class CallResolver { context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn)); return checkArgumentTypesAndFail(context); } - List> candidates = ResolutionCandidate.convertCollection(constructors); - prioritizedTasks = Collections.singletonList(new ResolutionTask(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY + List> candidates = ResolutionCandidate.convertCollection(constructors); + prioritizedTasks = Collections.singletonList(new ResolutionTask(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY } else if (calleeExpression != null) { // Here we handle the case where the callee expression must be something of type function, e.g. (foo.bar())(1, 2) @@ -223,7 +222,7 @@ public class CallResolver { FunctionDescriptorImpl functionDescriptor = new ExpressionAsFunctionDescriptor(context.scope.getContainingDeclaration(), "[for expression " + calleeExpression.getText() + "]"); FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, calleeType, NO_RECEIVER); - ResolutionCandidate resolutionCandidate = ResolutionCandidate.create(functionDescriptor); + ResolutionCandidate resolutionCandidate = ResolutionCandidate.create(functionDescriptor); resolutionCandidate.setReceiverArgument(context.call.getExplicitReceiver()); // strictly speaking, this is a hack: @@ -231,7 +230,7 @@ public class CallResolver { // so we wrap what we have into a fake reference and pass it on (unwrap on the other end) functionReference = new JetFakeReference(calleeExpression); - prioritizedTasks = Collections.singletonList(new ResolutionTask(Collections.singleton(resolutionCandidate), functionReference, context)); + prioritizedTasks = Collections.singletonList(new ResolutionTask(Collections.singleton(resolutionCandidate), functionReference, context)); } else { // checkTypesWithNoCallee(trace, scope, call); @@ -239,7 +238,7 @@ public class CallResolver { } } - return doResolveCall(context, prioritizedTasks, CallTransformationStrategy.FUNCTION_CALL_TRANSFORMATION_STRATEGY, functionReference); + return doResolveCall(context, prioritizedTasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference); } private OverloadResolutionResults checkArgumentTypesAndFail(BasicResolutionContext context) { @@ -248,10 +247,10 @@ public class CallResolver { } @NotNull - private OverloadResolutionResults doResolveCall( + private OverloadResolutionResults doResolveCall( @NotNull final BasicResolutionContext context, - @NotNull final List> prioritizedTasks, // high to low priority - @NotNull CallTransformationStrategy callTransformationStrategy, + @NotNull final List> prioritizedTasks, // high to low priority + @NotNull CallTransformer callTransformer, @NotNull final JetReferenceExpression reference) { ResolutionDebugInfo.Data debugInfo = ResolutionDebugInfo.create(); @@ -265,10 +264,11 @@ public class CallResolver { debugInfo.set(ResolutionDebugInfo.TASKS, prioritizedTasks); TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; - OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; - for (ResolutionTask task : prioritizedTasks) { + OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; + for (ResolutionTask task : prioritizedTasks) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); - OverloadResolutionResultsImpl results = performResolutionGuardedForExtraFunctionLiteralArguments(task.withTrace(temporaryTrace), callTransformationStrategy); + OverloadResolutionResultsImpl results = performResolutionGuardedForExtraFunctionLiteralArguments(task.withTrace(temporaryTrace), + callTransformer); if (results.isSuccess() || results.isAmbiguity()) { temporaryTrace.commit(); @@ -294,15 +294,15 @@ public class CallResolver { context.trace.report(UNRESOLVED_REFERENCE.on(reference)); checkTypesWithNoCallee(context); } - return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.nameNotFound(); + return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.nameNotFound(); } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @NotNull - private OverloadResolutionResultsImpl performResolutionGuardedForExtraFunctionLiteralArguments(@NotNull ResolutionTask task, - @NotNull CallTransformationStrategy callTransformationStrategy) { - OverloadResolutionResultsImpl results = performResolution(task, callTransformationStrategy); + private OverloadResolutionResultsImpl performResolutionGuardedForExtraFunctionLiteralArguments(@NotNull ResolutionTask task, + @NotNull CallTransformer callTransformer) { + OverloadResolutionResultsImpl results = performResolution(task, callTransformer); // If resolution fails, we should check for some of the following situations: // class A { @@ -329,14 +329,14 @@ public class CallResolver { for (ResolutionCandidate candidate : task.getCandidates()) { newCandidates.add(ResolutionCandidate.create(candidate.getDescriptor())); } - ResolutionTask newContext = new ResolutionTask(newCandidates, task.reference, TemporaryBindingTrace.create(task.trace), task.scope, new DelegatingCall(task.call) { + ResolutionTask newContext = new ResolutionTask(newCandidates, task.reference, TemporaryBindingTrace.create(task.trace), task.scope, new DelegatingCall(task.call) { @NotNull @Override public List getFunctionLiteralArguments() { return Collections.emptyList(); } }, task.expectedType, task.dataFlowInfo); - OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(newContext, callTransformationStrategy); + OverloadResolutionResultsImpl resultsWithFunctionLiteralsStripped = performResolution(newContext, callTransformer); if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) { task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments()); } @@ -346,23 +346,28 @@ public class CallResolver { } @NotNull - private OverloadResolutionResultsImpl performResolution(@NotNull ResolutionTask task, - @NotNull CallTransformationStrategy callTransformationStrategy) { + private OverloadResolutionResultsImpl performResolution(@NotNull ResolutionTask task, + @NotNull CallTransformer callTransformer) { for (ResolutionCandidate resolutionCandidate : task.getCandidates()) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(task.trace); - CallResolutionContext context = callTransformationStrategy.createCallContext(resolutionCandidate, task, temporaryTrace, task.tracing); - performResolutionForCandidateCall(context, task, temporaryTrace); + Collection> contexts = callTransformer.createCallContexts(resolutionCandidate, task, temporaryTrace); + Collection> calls = Lists.newArrayList(); + for (CallResolutionContext context : contexts) { - Collection> calls = callTransformationStrategy.transformResultCall(context, this, task); - for (ResolvedCallImpl call : calls) { - task.getResolvedCallMap().put(resolutionCandidate, call); + performResolutionForCandidateCall(context, task); + calls.addAll(callTransformer.transformCall(context, this, task)); + } + for (ResolvedCallWithTrace call : calls) { + + task.tracing.bindResolvedCall(call.getTrace(), call); + task.getResolvedCalls().add(call); } } - Set> successfulCandidates = Sets.newLinkedHashSet(); - Set> failedCandidates = Sets.newLinkedHashSet(); - for (ResolvedCallImpl candidateCall : task.getResolvedCallMap().values()) { + Set> successfulCandidates = Sets.newLinkedHashSet(); + Set> failedCandidates = Sets.newLinkedHashSet(); + for (ResolvedCallWithTrace candidateCall : task.getResolvedCalls()) { ResolutionStatus status = candidateCall.getStatus(); if (status.isSuccess()) { successfulCandidates.add(candidateCall); @@ -373,23 +378,19 @@ public class CallResolver { } } - OverloadResolutionResultsImpl results = computeResultAndReportErrors(task.trace, task.tracing, successfulCandidates, failedCandidates); + OverloadResolutionResultsImpl results = computeResultAndReportErrors(task.trace, task.tracing, successfulCandidates, failedCandidates); if (!results.isSingleResult()) { checkTypesWithNoCallee(task.toBasic()); } return results; } - private void performResolutionForCandidateCall(@NotNull CallResolutionContext context, - @NotNull ResolutionTask task, - @NotNull TemporaryBindingTrace temporaryTrace) { + private void performResolutionForCandidateCall(@NotNull CallResolutionContext context, + @NotNull ResolutionTask task) { + ResolvedCallImpl candidateCall = context.candidateCall; - - candidateCall.setTrace(temporaryTrace); D candidate = candidateCall.getCandidateDescriptor(); - context.tracing.bindReference(context.trace, candidateCall); - if (ErrorUtils.isError(candidate)) { candidateCall.addStatus(SUCCESS); checkTypesWithNoCallee(context.toBasic()); @@ -477,7 +478,7 @@ public class CallResolver { recordAutoCastIfNecessary(candidateCall.getThisObject(), candidateCall.getTrace()); } - private ResolutionStatus inferTypeArguments(CallResolutionContext context) { + private ResolutionStatus inferTypeArguments(CallResolutionContext context) { ResolvedCallImpl candidateCall = context.candidateCall; D candidate = candidateCall.getCandidateDescriptor(); @@ -624,7 +625,7 @@ public class CallResolver { } } - private ResolutionStatus checkAllValueArguments(CallResolutionContext context) { + private ResolutionStatus checkAllValueArguments(CallResolutionContext context) { ResolutionStatus result = checkValueArgumentTypes(context); ResolvedCall candidateCall = context.candidateCall; result = result.combine(checkReceiver(context, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument())); @@ -632,7 +633,7 @@ public class CallResolver { return result; } - private ResolutionStatus checkReceiver(CallResolutionContext context, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument) { + private ResolutionStatus checkReceiver(CallResolutionContext context, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument) { ResolutionStatus result = SUCCESS; if (receiverParameter.exists() && receiverArgument.exists()) { ASTNode callOperationNode = context.call.getCallOperationNode(); @@ -660,7 +661,7 @@ public class CallResolver { return result; } - private ResolutionStatus checkValueArgumentTypes(CallResolutionContext context) { + private ResolutionStatus checkValueArgumentTypes(CallResolutionContext context) { ResolutionStatus result = SUCCESS; for (Map.Entry entry : context.candidateCall.getValueArguments().entrySet()) { ValueParameterDescriptor parameterDescriptor = entry.getKey(); @@ -734,8 +735,8 @@ public class CallResolver { private OverloadResolutionResultsImpl computeResultAndReportErrors( BindingTrace trace, TracingStrategy tracing, - Set> successfulCandidates, - Set> failedCandidates) { + Set> successfulCandidates, + Set> failedCandidates) { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific if (successfulCandidates.size() > 0) { @@ -756,8 +757,8 @@ public class CallResolver { // and some are not OK at all. In this case we'd like to say "unsafe call" rather than "none applicable" // Used to be: weak errors. Generalized for future extensions for (EnumSet severityLevel : SEVERITY_LEVELS) { - Set> thisLevel = Sets.newLinkedHashSet(); - for (ResolvedCallImpl candidate : failedCandidates) { + Set> thisLevel = Sets.newLinkedHashSet(); + for (ResolvedCallWithTrace candidate : failedCandidates) { if (severityLevel.contains(candidate.getStatus())) { thisLevel.add(candidate); } @@ -777,7 +778,7 @@ public class CallResolver { assert false : "Should not be reachable, cause every status must belong to some level"; - Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); + Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); if (noOverrides.size() != 1) { tracing.noneApplicable(trace, noOverrides); tracing.recordAmbiguity(trace, noOverrides); @@ -787,7 +788,7 @@ public class CallResolver { failedCandidates = noOverrides; } - ResolvedCallImpl failed = failedCandidates.iterator().next(); + ResolvedCallWithTrace failed = failedCandidates.iterator().next(); failed.getTrace().commit(); return OverloadResolutionResultsImpl.singleFailedCandidate(failed); } @@ -797,18 +798,18 @@ public class CallResolver { } } - private static boolean allClean(Collection> results) { - for (ResolvedCallImpl result : results) { + private static boolean allClean(Collection> results) { + for (ResolvedCallWithTrace result : results) { if (result.isDirty()) return false; } return true; } - private OverloadResolutionResultsImpl chooseAndReportMaximallySpecific(Set> candidates, boolean discriminateGenerics) { + private OverloadResolutionResultsImpl chooseAndReportMaximallySpecific(Set> candidates, boolean discriminateGenerics) { if (candidates.size() != 1) { - Set> cleanCandidates = Sets.newLinkedHashSet(candidates); - for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { - ResolvedCallImpl candidate = iterator.next(); + Set> cleanCandidates = Sets.newLinkedHashSet(candidates); + for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { + ResolvedCallWithTrace candidate = iterator.next(); if (candidate.isDirty()) { iterator.remove(); } @@ -817,27 +818,31 @@ public class CallResolver { if (cleanCandidates.isEmpty()) { cleanCandidates = candidates; } - ResolvedCallImpl maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); + ResolvedCallWithTrace maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); if (maximallySpecific != null) { return OverloadResolutionResultsImpl.success(maximallySpecific); } if (discriminateGenerics) { - ResolvedCallImpl maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); + ResolvedCallWithTrace maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); if (maximallySpecificGenericsDiscriminated != null) { return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated); } } - Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); + Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); return OverloadResolutionResultsImpl.ambiguity(noOverrides); } else { - ResolvedCallImpl result = candidates.iterator().next(); + ResolvedCallWithTrace result = candidates.iterator().next(); TemporaryBindingTrace temporaryTrace = result.getTrace(); temporaryTrace.commit(); + + if (result instanceof VariableAsFunctionResolvedCall) { + ((VariableAsFunctionResolvedCall)result).getVariableCall().getTrace().commit(); + } return OverloadResolutionResultsImpl.success(result); } } @@ -868,13 +873,12 @@ public class CallResolver { BindingTraceContext trace = new BindingTraceContext(); TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace); - Set> calls = Sets.newLinkedHashSet(); + Set> calls = Sets.newLinkedHashSet(); for (ResolutionCandidate candidate : candidates) { - ResolvedCallImpl call = ResolvedCallImpl.create(candidate); - call.setTrace(temporaryBindingTrace); + ResolvedCallImpl call = ResolvedCallImpl.create(candidate, temporaryBindingTrace); calls.add(call); } - return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, calls, Collections.>emptySet()); + return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, calls, Collections.>emptySet()); } private List> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformationStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformationStrategy.java deleted file mode 100644 index 5fc68364ae5..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformationStrategy.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright 2010-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.jet.lang.resolve.calls; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.CallableDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingTrace; - -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -/** - * @author svtk - */ -public interface CallTransformationStrategy { - - @NotNull - CallResolutionContext createCallContext(@NotNull ResolutionCandidate candidate, - @NotNull ResolutionTask task, - @NotNull BindingTrace trace, - @NotNull TracingStrategy tracing); - - @NotNull - Collection> transformResultCall(@NotNull CallResolutionContext callResolutionContext, - @NotNull CallResolver callResolver, - @NotNull ResolutionTask task); - - CallTransformationStrategy - PROPERTY_CALL_TRANSFORMATION_STRATEGY = new CallTransformationStrategy() { - @NotNull - @Override - public CallResolutionContext createCallContext(@NotNull ResolutionCandidate candidate, - @NotNull ResolutionTask task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) { - ResolvedCallImpl candidateCall = ResolvedCallImpl.create(candidate); - return new CallResolutionContext(candidateCall, task, trace, tracing); - } - - @NotNull - @Override - public Collection> transformResultCall(@NotNull CallResolutionContext context, - @NotNull CallResolver callResolver, @NotNull ResolutionTask task) { - return Collections.singleton(context.candidateCall); - } - }; - - CallTransformationStrategy - FUNCTION_CALL_TRANSFORMATION_STRATEGY = new CallTransformationStrategy() { - @NotNull - @Override - public CallResolutionContext createCallContext(@NotNull ResolutionCandidate candidate, - @NotNull ResolutionTask task, - @NotNull BindingTrace trace, - @NotNull TracingStrategy tracing) { - if (candidate.getDescriptor() instanceof FunctionDescriptor) { - return new CallResolutionContext(ResolvedCallImpl.create(candidate), task, trace, tracing); - } - assert candidate.getDescriptor() instanceof VariableDescriptor; - Call propertyCall = new DelegatingCall(task.call) { - @Override - public JetValueArgumentList getValueArgumentList() { - return null; - } - - @NotNull - @Override - public List getFunctionLiteralArguments() { - return Collections.emptyList(); - } - - @NotNull - @Override - public List getTypeArguments() { - return Collections.emptyList(); - } - - @Override - public JetTypeArgumentList getTypeArgumentList() { - return null; - } - }; - return new CallResolutionContext(ResolvedCallImpl.create(candidate), task, trace, tracing, propertyCall); - } - - @NotNull - @Override - public Collection> transformResultCall(@NotNull CallResolutionContext context, - @NotNull CallResolver callResolver, @NotNull ResolutionTask task) { - FunctionDescriptor descriptor = context.candidateCall.getCandidateDescriptor(); - if (descriptor instanceof FunctionDescriptor) { - return Collections.singleton(context.candidateCall); - } - assert descriptor instanceof VariableDescriptor; - BasicResolutionContext basicResolutionContext = - BasicResolutionContext.create(context.trace, context.scope, task.call, context.expectedType, context.dataFlowInfo); - OverloadResolutionResults results = - callResolver.resolveCallWithGivenName(basicResolutionContext, task.reference, "invoke"); - return ((OverloadResolutionResultsImpl)results).getResultingCalls(); - } - }; -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java new file mode 100644 index 00000000000..63486dee599 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java @@ -0,0 +1,239 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.calls; + +import com.google.common.base.Function; +import com.google.common.collect.Collections2; +import com.google.common.collect.Lists; +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + * CallTransformer treats specially 'variable as function' call case, other cases keeps unchanged (base realization). + * + * For the call 'b.foo(1)' where foo is a variable that has method 'invoke' (for example of function type) + * CallTransformer creates two contexts, two calls in each, and performs second ('invoke') call resolution: + * + * context#1. calls: 'b.foo' 'invoke(1)' + * context#2. calls: 'foo' 'b.invoke(1)' + * + * If success VariableAsFunctionResolvedCall is created. + * + * @author svtk + */ +public class CallTransformer { + private CallTransformer() {} + + /** + * Returns two contexts for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER), one context otherwise + */ + @NotNull + public Collection> createCallContexts(@NotNull ResolutionCandidate candidate, + @NotNull ResolutionTask task, + @NotNull TemporaryBindingTrace temporaryTrace) { + + ResolvedCallImpl candidateCall = ResolvedCallImpl.create(candidate, temporaryTrace); + return Collections.singleton(CallResolutionContext.create(candidateCall, task, temporaryTrace, task.tracing)); + } + + /** + * Returns collection of resolved calls for 'invoke' for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER), + * the resolved call from callResolutionContext otherwise + */ + @NotNull + public Collection> transformCall(@NotNull CallResolutionContext callResolutionContext, + @NotNull CallResolver callResolver, + @NotNull ResolutionTask task) { + + return Collections.singleton((ResolvedCallWithTrace)callResolutionContext.candidateCall); + } + + + public static CallTransformer PROPERTY_CALL_TRANSFORMER = new CallTransformer(); + + public static CallTransformer FUNCTION_CALL_TRANSFORMER = new CallTransformer() { + @NotNull + @Override + public Collection> createCallContexts(@NotNull ResolutionCandidate candidate, + @NotNull ResolutionTask task, @NotNull TemporaryBindingTrace temporaryTrace) { + + if (candidate.getDescriptor() instanceof FunctionDescriptor) { + return super.createCallContexts(candidate, task, temporaryTrace); + } + + assert candidate.getDescriptor() instanceof VariableDescriptor; + + boolean hasReceiver = candidate.getReceiverArgument().exists(); + Call variableCall = stripCallArguments(task); + if (!hasReceiver) { + CallResolutionContext context = CallResolutionContext.create( + ResolvedCallImpl.create(candidate, temporaryTrace), task, temporaryTrace, task.tracing, variableCall); + return Collections.singleton(context); + } + Call variableCallWithoutReceiver = stripReceiver(variableCall); + CallResolutionContext contextWithReceiver = createContextWithChainedTrace( + candidate, variableCall, temporaryTrace, task); + + ResolutionCandidate candidateWithoutReceiver = ResolutionCandidate.create( + candidate.getDescriptor(), candidate.getThisObject(), ReceiverDescriptor.NO_RECEIVER); + + CallResolutionContext contextWithoutReceiver = createContextWithChainedTrace( + candidateWithoutReceiver, variableCallWithoutReceiver, temporaryTrace, task); + + contextWithoutReceiver.receiverForVariableAsFunctionSecondCall = variableCall.getExplicitReceiver(); + + return Lists.newArrayList(contextWithReceiver, contextWithoutReceiver); + } + + private CallResolutionContext createContextWithChainedTrace(ResolutionCandidate candidate, + Call call, TemporaryBindingTrace temporaryTrace, ResolutionTask task) { + + ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace); + ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace); + return CallResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call); + } + + private Call stripCallArguments(@NotNull ResolutionTask task) { + return new DelegatingCall(task.call) { + @Override + public JetValueArgumentList getValueArgumentList() { + return null; + } + + @NotNull + @Override + public List getValueArguments() { + return Collections.emptyList(); + } + + @NotNull + @Override + public List getFunctionLiteralArguments() { + return Collections.emptyList(); + } + + @NotNull + @Override + public List getTypeArguments() { + return Collections.emptyList(); + } + + @Override + public JetTypeArgumentList getTypeArgumentList() { + return null; + } + }; + } + + private Call stripReceiver(@NotNull Call variableCall) { + return new DelegatingCall(variableCall) { + @NotNull + @Override + public ReceiverDescriptor getExplicitReceiver() { + return ReceiverDescriptor.NO_RECEIVER; + } + }; + } + + @NotNull + @Override + public Collection> transformCall(@NotNull final CallResolutionContext context, + @NotNull CallResolver callResolver, @NotNull final ResolutionTask task) { + + final CallableDescriptor descriptor = context.candidateCall.getCandidateDescriptor(); + if (descriptor instanceof FunctionDescriptor) { + return super.transformCall(context, callResolver, task); + } + + assert descriptor instanceof VariableDescriptor; + JetType returnType = descriptor.getReturnType(); + if (returnType == null) { + return Collections.emptyList(); + } + + final ResolvedCallWithTrace variableResolvedCall = (ResolvedCallWithTrace)context.candidateCall; + + Call functionCall = createFunctionCall(context, task, returnType); + + final TemporaryBindingTrace variableCallTrace = context.candidateCall.getTrace(); + BasicResolutionContext basicResolutionContext = BasicResolutionContext.create(variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo); + + // 'invoke' call resolve + OverloadResolutionResults results = callResolver.resolveCallWithGivenName(basicResolutionContext, task.reference, "invoke"); + Collection> calls = ((OverloadResolutionResultsImpl)results).getResultingCalls(); + + return Collections2.transform(calls, new Function, ResolvedCallWithTrace>() { + @Override + public ResolvedCallWithTrace apply(ResolvedCallWithTrace functionResolvedCall) { + return new VariableAsFunctionResolvedCall(functionResolvedCall, variableResolvedCall); + } + }); + } + + private Call createFunctionCall(final CallResolutionContext context, + final ResolutionTask task, JetType returnType) { + + final ExpressionReceiver receiverFromVariable = new ExpressionReceiver(task.reference, returnType); + final JetSimpleNameExpression invokeExpression = (JetSimpleNameExpression) JetPsiFactory.createExpression( + task.call.getCallElement().getProject(), "invoke"); + + return new DelegatingCall(task.call) { + @NotNull + @Override + public ReceiverDescriptor getExplicitReceiver() { + return context.receiverForVariableAsFunctionSecondCall; + } + + @NotNull + @Override + public ReceiverDescriptor getThisObject() { + return receiverFromVariable; + } + + @Override + public JetExpression getCalleeExpression() { + return invokeExpression; + } + + @NotNull + @Override + public PsiElement getCallElement() { + if (task.call.getCallElement() instanceof JetCallElement) { + //to report errors properly + JetValueArgumentList list = ((JetCallElement)task.call.getCallElement()).getValueArgumentList(); + if (list != null) { + return list; + } + } + return invokeExpression; + } + }; + } + }; +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java similarity index 88% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizer.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java index 14dace99c4d..27d9c77c400 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java @@ -26,7 +26,7 @@ import java.util.Collection; /** * @author svtk */ -public interface MemberPrioritizer { +public interface CallableDescriptorCollector { @NotNull Collection getNonExtensionsByName(JetScope scope, String name); @@ -34,5 +34,5 @@ public interface MemberPrioritizer { Collection getMembersByName(@NotNull JetType receiver, String name); @NotNull - Collection getExtensionsByName(JetScope scope, String name); + Collection getNonMembersByName(JetScope scope, String name); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java similarity index 60% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java index a7e793dcb4a..9e018ec229c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java @@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.ErrorUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; import java.util.*; @@ -34,11 +33,9 @@ import java.util.*; /** * @author abreslav */ -public class MemberPrioritizers { - - - /*package*/ static MemberPrioritizer FUNCTION_TASK_PRIORITIZER = new MemberPrioritizer() { +public class CallableDescriptorCollectors { + /*package*/ static CallableDescriptorCollector FUNCTIONS = new CallableDescriptorCollector() { @NotNull @Override @@ -51,8 +48,6 @@ public class MemberPrioritizers { } } addConstructors(scope, name, functions); - - addVariableAsFunction(scope, name, functions, false); return functions; } @@ -62,22 +57,13 @@ public class MemberPrioritizers { JetScope receiverScope = receiverType.getMemberScope(); Set members = Sets.newHashSet(receiverScope.getFunctions(name)); addConstructors(receiverScope, name, members); - addVariableAsFunction(receiverScope, name, members, false); return members; } @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - Set extensionFunctions = Sets.newHashSet(scope.getFunctions(name)); - for (Iterator iterator = extensionFunctions.iterator(); iterator.hasNext(); ) { - FunctionDescriptor descriptor = iterator.next(); - if (!descriptor.getReceiverParameter().exists()) { - iterator.remove(); - } - } - addVariableAsFunction(scope, name, extensionFunctions, true); - return extensionFunctions; + public Collection getNonMembersByName(JetScope scope, String name) { + return scope.getFunctions(name); } private void addConstructors(JetScope scope, String name, Collection functions) { @@ -87,25 +73,9 @@ public class MemberPrioritizers { functions.addAll(classDescriptor.getConstructors()); } } - - private void addVariableAsFunction(JetScope scope, String name, Set functions, boolean receiverNeeded) { - VariableDescriptor variable = scope.getLocalVariable(name); - if (variable == null) { - variable = DescriptorUtils.filterNonExtensionProperty(scope.getProperties(name)); - } - if (variable != null) { - JetType outType = variable.getType(); - if (outType != null && JetStandardClasses.isFunctionType(outType)) { - VariableAsFunctionDescriptor functionDescriptor = VariableAsFunctionDescriptor.create(variable); - if ((functionDescriptor.getReceiverParameter().exists()) == receiverNeeded) { - functions.add(functionDescriptor); - } - } - } - } }; - /*package*/ static MemberPrioritizer VARIABLE_TASK_PRIORITIZER = new MemberPrioritizer() { + /*package*/ static CallableDescriptorCollector VARIABLES = new CallableDescriptorCollector() { @NotNull @Override @@ -126,17 +96,19 @@ public class MemberPrioritizers { @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - return Collections2.filter(scope.getProperties(name), new Predicate() { - @Override - public boolean apply(@Nullable VariableDescriptor variableDescriptor) { - return (variableDescriptor != null) && variableDescriptor.getReceiverParameter().exists(); - } - }); + public Collection getNonMembersByName(JetScope scope, String name) { + Collection result = Sets.newLinkedHashSet(); + + VariableDescriptor localVariable = scope.getLocalVariable(name); + if (localVariable != null) { + result.add(localVariable); + } + result.addAll(scope.getProperties(name)); + return result; } }; - /*package*/ static MemberPrioritizer PROPERTY_TASK_PRIORITIZER = new MemberPrioritizer() { + /*package*/ static CallableDescriptorCollector PROPERTIES = new CallableDescriptorCollector() { private Collection filterProperties(Collection variableDescriptors) { ArrayList properties = Lists.newArrayList(); for (VariableDescriptor descriptor : variableDescriptors) { @@ -150,19 +122,23 @@ public class MemberPrioritizers { @NotNull @Override public Collection getNonExtensionsByName(JetScope scope, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getNonExtensionsByName(scope, name)); + return filterProperties(VARIABLES.getNonExtensionsByName(scope, name)); } @NotNull @Override public Collection getMembersByName(@NotNull JetType receiver, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getMembersByName(receiver, name)); + return filterProperties(VARIABLES.getMembersByName(receiver, name)); } @NotNull @Override - public Collection getExtensionsByName(JetScope scope, String name) { - return filterProperties(VARIABLE_TASK_PRIORITIZER.getExtensionsByName(scope, name)); + public Collection getNonMembersByName(JetScope scope, String name) { + return filterProperties(VARIABLES.getNonMembersByName(scope, name)); } + }; + + /*package*/ static List> FUNCTIONS_AND_VARIABLES = Lists.newArrayList( + FUNCTIONS, VARIABLES); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DelegatingCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DelegatingCall.java index 80cc4eb7f29..9c82f0829d8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DelegatingCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DelegatingCall.java @@ -48,6 +48,12 @@ public class DelegatingCall implements Call { return delegate.getExplicitReceiver(); } + @NotNull + @Override + public ReceiverDescriptor getThisObject() { + return delegate.getThisObject(); + } + @Override @Nullable public JetExpression getCalleeExpression() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java index 5e90d79d572..6487e96c36c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java @@ -27,42 +27,42 @@ import java.util.Collections; */ /*package*/ class OverloadResolutionResultsImpl implements OverloadResolutionResults { - public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallImpl descriptor) { + public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallWithTrace descriptor) { return new OverloadResolutionResultsImpl(Code.SUCCESS, Collections.singleton(descriptor)); } public static OverloadResolutionResultsImpl nameNotFound() { - return new OverloadResolutionResultsImpl(Code.NAME_NOT_FOUND, Collections.>emptyList()); + return new OverloadResolutionResultsImpl(Code.NAME_NOT_FOUND, Collections.>emptyList()); } - public static OverloadResolutionResultsImpl singleFailedCandidate(ResolvedCallImpl candidate) { + public static OverloadResolutionResultsImpl singleFailedCandidate(ResolvedCallWithTrace candidate) { return new OverloadResolutionResultsImpl(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); } - public static OverloadResolutionResultsImpl manyFailedCandidates(Collection> failedCandidates) { + public static OverloadResolutionResultsImpl manyFailedCandidates(Collection> failedCandidates) { return new OverloadResolutionResultsImpl(Code.MANY_FAILED_CANDIDATES, failedCandidates); } - public static OverloadResolutionResultsImpl ambiguity(Collection> descriptors) { + public static OverloadResolutionResultsImpl ambiguity(Collection> descriptors) { return new OverloadResolutionResultsImpl(Code.AMBIGUITY, descriptors); } - private final Collection> results; + private final Collection> results; private final Code resultCode; - private OverloadResolutionResultsImpl(@NotNull Code resultCode, @NotNull Collection> results) { + private OverloadResolutionResultsImpl(@NotNull Code resultCode, @NotNull Collection> results) { this.results = results; this.resultCode = resultCode; } @Override @NotNull - public Collection> getResultingCalls() { + public Collection> getResultingCalls() { return results; } @Override @NotNull - public ResolvedCallImpl getResultingCall() { + public ResolvedCallWithTrace getResultingCall() { assert isSingleResult(); return results.iterator().next(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsUtil.java index 44e46111f33..07d259f9f5c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsUtil.java @@ -30,9 +30,9 @@ import java.util.Collection; public class OverloadResolutionResultsUtil { @NotNull public static OverloadResolutionResults ambiguity(OverloadResolutionResults results1, OverloadResolutionResults results2) { - Collection> resultingCalls = Lists.newArrayList(); - resultingCalls.addAll((Collection>) results1.getResultingCalls()); - resultingCalls.addAll((Collection>) results2.getResultingCalls()); + Collection> resultingCalls = Lists.newArrayList(); + resultingCalls.addAll((Collection>) results1.getResultingCalls()); + resultingCalls.addAll((Collection>) results2.getResultingCalls()); return OverloadResolutionResultsImpl.ambiguity(resultingCalls); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index 1edce3205fa..360e117c08c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -39,23 +39,23 @@ import java.util.Set; public class OverloadingConflictResolver { @Nullable - public ResolvedCallImpl findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { + public ResolvedCallWithTrace findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCallImpl objects - Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { + Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { @Override - public boolean equals(ResolvedCallImpl o1, ResolvedCallImpl o2) { + public boolean equals(ResolvedCallWithTrace o1, ResolvedCallWithTrace o2) { return o1 == null ? o2 == null : o1.getResultingDescriptor().equals(o2.getResultingDescriptor()); } @Override - public int computeHashCode(ResolvedCallImpl object) { + public int computeHashCode(ResolvedCallWithTrace object) { return object == null ? 0 : object.getResultingDescriptor().hashCode(); } }); meLoop: - for (ResolvedCallImpl candidateCall : candidates) { + for (ResolvedCallWithTrace candidateCall : candidates) { D me = candidateCall.getResultingDescriptor(); - for (ResolvedCallImpl otherCall : candidates) { + for (ResolvedCallWithTrace otherCall : candidates) { D other = otherCall.getResultingDescriptor(); if (other == me) continue; if (!moreSpecific(me, other, discriminateGenericDescriptors) || moreSpecific(other, me, discriminateGenericDescriptors)) { @@ -65,7 +65,7 @@ public class OverloadingConflictResolver { maximallySpecific.add(candidateCall); } if (maximallySpecific.size() == 1) { - ResolvedCallImpl result = maximallySpecific.iterator().next(); + ResolvedCallWithTrace result = maximallySpecific.iterator().next(); result.getTrace().commit(); return result; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionCandidate.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionCandidate.java index 829185e3e31..b134964b378 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionCandidate.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionCandidate.java @@ -31,15 +31,21 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor */ public class ResolutionCandidate { private final D candidateDescriptor; - private ReceiverDescriptor thisObject = NO_RECEIVER; // receiver object of a method - private ReceiverDescriptor receiverArgument = NO_RECEIVER; // receiver of an extension function + private ReceiverDescriptor thisObject; // receiver object of a method + private ReceiverDescriptor receiverArgument; // receiver of an extension function - private ResolutionCandidate(@NotNull D descriptor) { - candidateDescriptor = descriptor; + private ResolutionCandidate(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument) { + this.candidateDescriptor = descriptor; + this.thisObject = thisObject; + this.receiverArgument = receiverArgument; } public static ResolutionCandidate create(@NotNull D descriptor) { - return new ResolutionCandidate(descriptor); + return new ResolutionCandidate(descriptor, NO_RECEIVER, NO_RECEIVER); + } + + public static ResolutionCandidate create(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument) { + return new ResolutionCandidate(descriptor, thisObject, receiverArgument); } public void setThisObject(@NotNull ReceiverDescriptor thisObject) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionDebugInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionDebugInfo.java index b61c04a5c65..b3c6b1d7839 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionDebugInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionDebugInfo.java @@ -34,7 +34,7 @@ import java.util.Map; * @author abreslav */ public class ResolutionDebugInfo { - public static final WritableSlice>> TASKS = Slices.createSimpleSlice(); + public static final WritableSlice>> TASKS = Slices.createSimpleSlice(); public static final WritableSlice> RESULT = Slices.createSimpleSlice(); public static final WritableSlice, StringBuilder> ERRORS = Slices.createSimpleSlice(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java index 3f7468a0479..cb1b3e0f85b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.lang.resolve.calls; -import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; @@ -39,6 +38,7 @@ import org.jetbrains.jet.lexer.JetTokens; import java.util.Collection; import java.util.List; +import java.util.Set; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lang.resolve.BindingContext.*; @@ -48,9 +48,9 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*; * * @author abreslav */ -public class ResolutionTask extends ResolutionContext { +public class ResolutionTask extends ResolutionContext { private final Collection> candidates; - private final Multimap, ResolvedCallImpl> resolvedCallMap = LinkedHashMultimap.create(); + private final Set> resolvedCalls = Sets.newLinkedHashSet(); /*package*/ final JetReferenceExpression reference; private DescriptorCheckStrategy checkingStrategy; @@ -71,8 +71,8 @@ public class ResolutionTask extends ResolutionCont } @NotNull - public Multimap, ResolvedCallImpl> getResolvedCallMap() { - return resolvedCallMap; + public Set> getResolvedCalls() { + return resolvedCalls; } public void setCheckingStrategy(DescriptorCheckStrategy strategy) { @@ -86,8 +86,8 @@ public class ResolutionTask extends ResolutionCont return true; } - public ResolutionTask withTrace(BindingTrace newTrace) { - ResolutionTask newTask = new ResolutionTask(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo); + public ResolutionTask withTrace(BindingTrace newTrace) { + ResolutionTask newTask = new ResolutionTask(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo); newTask.setCheckingStrategy(checkingStrategy); return newTask; } @@ -98,22 +98,15 @@ public class ResolutionTask extends ResolutionCont public final TracingStrategy tracing = new TracingStrategy() { @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { - D descriptor = resolvedCall.getCandidateDescriptor(); - // if (descriptor instanceof VariableAsFunctionDescriptor) { - // VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor; - // trace.record(REFERENCE_TARGET, reference, variableAsFunctionDescriptor.getVariableDescriptor()); - // } - // else { - // } + public void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace resolvedCall) { + trace.record(REFERENCE_TARGET, reference, resolvedCall.getResultingDescriptor()); trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall); - trace.record(REFERENCE_TARGET, reference, descriptor); } @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) { + public void recordAmbiguity(BindingTrace trace, Collection> candidates) { Collection descriptors = Sets.newHashSet(); - for (ResolvedCallImpl candidate : candidates) { + for (ResolvedCallWithTrace candidate : candidates) { descriptors.add(candidate.getCandidateDescriptor()); } trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, descriptors); @@ -155,7 +148,14 @@ public class ResolutionTask extends ResolutionCont @Override public void noReceiverAllowed(@NotNull BindingTrace trace) { - trace.report(NO_RECEIVER_ADMITTED.on(reference)); + if (reference instanceof JetSimpleNameExpression) { + //todo temporary hack + //should be stored that the reference is unresolved (and not trace the candidate descriptor) + trace.report(UNRESOLVED_REFERENCE.on(reference)); + } + else { + trace.report(NO_RECEIVER_ADMITTED.on(reference)); + } } @Override @@ -170,12 +170,12 @@ public class ResolutionTask extends ResolutionCont } @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { + public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallElement(), descriptors)); } @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { trace.report(NONE_APPLICABLE.on(reference, descriptors)); } @@ -233,8 +233,7 @@ public class ResolutionTask extends ResolutionCont @Override public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) { - JetExpression expression = call.getCalleeExpression(); - trace.report(INVISIBLE_MEMBER.on(expression != null ? expression : call.getCallElement(), descriptor, descriptor.getContainingDeclaration())); + trace.report(INVISIBLE_MEMBER.on(call.getCallElement(), descriptor, descriptor.getContainingDeclaration())); } }; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTaskHolder.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTaskHolder.java index 4e39c8ccfde..5054e683c22 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTaskHolder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTaskHolder.java @@ -31,7 +31,7 @@ import java.util.List; /** * @author svtk */ -public class ResolutionTaskHolder { +public class ResolutionTaskHolder { private final JetReferenceExpression reference; private final BasicResolutionContext basicResolutionContext; private final Predicate> visibleStrategy; @@ -40,7 +40,7 @@ public class ResolutionTaskHolder { private final Collection>> members = Sets.newLinkedHashSet(); private final Collection>> nonLocalExtensions = Sets.newLinkedHashSet(); - private List> tasks = null; + private List> tasks = null; public ResolutionTaskHolder(@NotNull JetReferenceExpression reference, @NotNull BasicResolutionContext basicResolutionContext, @@ -68,7 +68,7 @@ public class ResolutionTaskHolder { } } - public List> getTasks() { + public List> getTasks() { if (tasks == null) { tasks = Lists.newArrayList(); List>> candidateList = Lists.newArrayList(); @@ -89,7 +89,7 @@ public class ResolutionTaskHolder { for (Collection> candidates : candidateList) { Collection> filteredCandidates = Collections2.filter(candidates, visibilityStrategy); if (!filteredCandidates.isEmpty()) { - tasks.add(new ResolutionTask(filteredCandidates, reference, basicResolutionContext)); + tasks.add(new ResolutionTask(filteredCandidates, reference, basicResolutionContext)); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java index 2bf2516e751..e6399ea151d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.lang.resolve.calls; -import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; @@ -28,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import java.util.ArrayList; -import java.util.Collection; import java.util.List; import java.util.Map; @@ -37,25 +35,30 @@ import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.UNKNOWN_STAT /** * @author abreslav */ -public class ResolvedCallImpl implements ResolvedCall { +public class ResolvedCallImpl implements ResolvedCallWithTrace { - public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { + public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { @Override - public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { + public CallableDescriptor fun(ResolvedCallWithTrace resolvedCall) { return resolvedCall.getCandidateDescriptor(); } }; - public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { + public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { @Override - public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { + public CallableDescriptor fun(ResolvedCallWithTrace resolvedCall) { return resolvedCall.getResultingDescriptor(); } }; @NotNull - public static ResolvedCallImpl create(@NotNull ResolutionCandidate candidate) { - return new ResolvedCallImpl(candidate.getDescriptor(), candidate.getThisObject(), candidate.getReceiverArgument()); + public static ResolvedCallImpl create(@NotNull ResolutionCandidate candidate, @NotNull TemporaryBindingTrace trace) { + return create(candidate.getDescriptor(), candidate.getThisObject(), candidate.getReceiverArgument(), trace); + } + + @NotNull + public static ResolvedCallImpl create(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument, @NotNull TemporaryBindingTrace trace) { + return new ResolvedCallImpl(descriptor, thisObject, receiverArgument, trace); } private final D candidateDescriptor; @@ -70,10 +73,11 @@ public class ResolvedCallImpl implements ResolvedC private TemporaryBindingTrace trace; private ResolutionStatus status = UNKNOWN_STATUS; - private ResolvedCallImpl(@NotNull D candidateDescriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument) { + private ResolvedCallImpl(@NotNull D candidateDescriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument, @NotNull TemporaryBindingTrace trace) { this.candidateDescriptor = candidateDescriptor; this.thisObject = thisObject; this.receiverArgument = receiverArgument; + this.trace = trace; } @NotNull @@ -90,10 +94,6 @@ public class ResolvedCallImpl implements ResolvedC return trace; } - public void setTrace(@NotNull TemporaryBindingTrace trace) { - this.trace = trace; - } - @Override @NotNull public D getCandidateDescriptor() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallWithTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallWithTrace.java new file mode 100644 index 00000000000..ae3d5798dbd --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallWithTrace.java @@ -0,0 +1,34 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.calls; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; + +/** + * @author svtk + */ +public interface ResolvedCallWithTrace extends ResolvedCall { + + @NotNull + ResolutionStatus getStatus(); + + boolean isDirty(); + + TemporaryBindingTrace getTrace(); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index 6a1cd61c00f..eb3f565adab 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -74,8 +74,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } @NotNull - public static List> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name, - @NotNull JetReferenceExpression functionReference, @NotNull List> memberPrioritizers) { + public static List> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name, + @NotNull JetReferenceExpression functionReference, @NotNull List> callableDescriptorCollectors) { ReceiverDescriptor explicitReceiver = context.call.getExplicitReceiver(); final JetScope scope; if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) { @@ -96,23 +96,26 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } }; - ResolutionTaskHolder result = new ResolutionTaskHolder(functionReference, context, visibleStrategy ); - doComputeTasks(scope, explicitReceiver, name, result, context, memberPrioritizers); - + ResolutionTaskHolder result = new ResolutionTaskHolder(functionReference, context, visibleStrategy ); + for (CallableDescriptorCollector callableDescriptorCollector : callableDescriptorCollectors) { + doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollector); + } return result.getTasks(); } - private static void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, - @NotNull String name, @NotNull ResolutionTaskHolder result, - @NotNull BasicResolutionContext context, @NotNull List> memberPrioritizers) { - MemberPrioritizer memberPrioritizer = memberPrioritizers.get(0); + private static void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, + @NotNull String name, @NotNull ResolutionTaskHolder result, + @NotNull BasicResolutionContext context, @NotNull CallableDescriptorCollector callableDescriptorCollector) { AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext()); List implicitReceivers = Lists.newArrayList(); scope.getImplicitReceiversHierarchy(implicitReceivers); + if (context.call.getThisObject().exists()) { + implicitReceivers.add(context.call.getThisObject()); + } if (receiver.exists()) { List variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver); - Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, memberPrioritizer.getExtensionsByName(scope, name)); + Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name)); List> nonlocals = Lists.newArrayList(); List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments @@ -120,7 +123,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor Collection> members = Lists.newArrayList(); for (ReceiverDescriptor variant : variantsForExplicitReceiver) { - Collection membersForThisVariant = memberPrioritizer.getMembersByName(variant.getType(), name); + Collection membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name); convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members); } @@ -128,7 +131,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addMembers(members); for (ReceiverDescriptor implicitReceiver : implicitReceivers) { - Collection memberExtensions = memberPrioritizer.getExtensionsByName(implicitReceiver.getType().getMemberScope(), name); + Collection memberExtensions = callableDescriptorCollector.getNonMembersByName( + implicitReceiver.getType().getMemberScope(), name); List variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver); result.addNonLocalExtensions(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, variantsForExplicitReceiver)); } @@ -136,7 +140,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addNonLocalExtensions(nonlocals); } else { - Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), memberPrioritizer.getNonExtensionsByName(scope, name)); + Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector + .getNonExtensionsByName(scope, name)); List> nonlocals = Lists.newArrayList(); List> locals = Lists.newArrayList(); @@ -147,18 +152,18 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor result.addNonLocalExtensions(nonlocals); for (ReceiverDescriptor implicitReceiver : implicitReceivers) { - doComputeTasks(scope, implicitReceiver, name, result, context, memberPrioritizers); + doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollector); } } } - private static Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { + private static Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { Collection> result = Lists.newArrayList(); convertWithReceivers(descriptors, thisObjects, receiverParameters, result); return result; } - private static void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { + private static void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { for (ReceiverDescriptor thisObject : thisObjects) { for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java index a1551908809..9207e24747b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java @@ -34,14 +34,15 @@ import java.util.List; */ /*package*/ interface TracingStrategy { TracingStrategy EMPTY = new TracingStrategy() { + @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) {} + public void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace resolvedCall) {} @Override public void unresolvedReference(@NotNull BindingTrace trace) {} @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} + public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} @Override public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {} @@ -59,10 +60,10 @@ import java.util.List; public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {} @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} + public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} @Override public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {} @@ -83,11 +84,11 @@ import java.util.List; public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {} }; - void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall); + void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace resolvedCall); void unresolvedReference(@NotNull BindingTrace trace); - void recordAmbiguity(BindingTrace trace, Collection> candidates); + void recordAmbiguity(BindingTrace trace, Collection> candidates); void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver); @@ -99,9 +100,9 @@ import java.util.List; void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount); - void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors); + void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors); - void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors); + void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors); void instantiationOfAbstractClass(@NotNull BindingTrace trace); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/VariableAsFunctionResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/VariableAsFunctionResolvedCall.java new file mode 100644 index 00000000000..1cd94383246 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/VariableAsFunctionResolvedCall.java @@ -0,0 +1,119 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.calls; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.JetStandardClasses; + +import java.util.List; +import java.util.Map; + +/** + * @author svtk + */ +public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace { + private final ResolvedCallWithTrace functionCall; + private final ResolvedCallWithTrace variableCall; + private final VariableAsFunctionDescriptor variableAsFunctionDescriptor; + + public VariableAsFunctionResolvedCall(@NotNull ResolvedCallWithTrace functionCall, + @NotNull ResolvedCallWithTrace variableCall) { + this.functionCall = functionCall; + this.variableCall = variableCall; + if (JetStandardClasses.isFunctionType(variableCall.getResultingDescriptor().getType())) { + variableAsFunctionDescriptor = VariableAsFunctionDescriptor.create(variableCall.getResultingDescriptor()); + } + else { + variableAsFunctionDescriptor = null; + } + } + + public ResolvedCallWithTrace getFunctionCall() { + return functionCall; + } + + public ResolvedCallWithTrace getVariableCall() { + return variableCall; + } + + @NotNull + @Override + public FunctionDescriptor getCandidateDescriptor() { + return variableAsFunctionDescriptor != null ? variableAsFunctionDescriptor : functionCall.getResultingDescriptor(); + } + + @NotNull + @Override + public FunctionDescriptor getResultingDescriptor() { + return variableAsFunctionDescriptor != null ? variableAsFunctionDescriptor : functionCall.getResultingDescriptor(); + } + + @NotNull + @Override + public ReceiverDescriptor getReceiverArgument() { + ReceiverDescriptor receiverArgument = variableCall.getReceiverArgument(); + return receiverArgument.exists() ? receiverArgument : functionCall.getReceiverArgument(); + } + + @NotNull + @Override + public ReceiverDescriptor getThisObject() { + return variableCall.getThisObject(); + } + + @NotNull + @Override + public Map getValueArguments() { + return functionCall.getValueArguments(); + } + + @NotNull + @Override + public List getValueArgumentsByIndex() { + return functionCall.getValueArgumentsByIndex(); + } + + @NotNull + @Override + public Map getTypeArguments() { + return functionCall.getTypeArguments(); + } + + @NotNull + @Override + public ResolutionStatus getStatus() { + if (variableCall.getStatus() == ResolutionStatus.SUCCESS) { + return functionCall.getStatus(); + } + return variableCall.getStatus(); + } + + @Override + public boolean isDirty() { + return functionCall.isDirty(); + } + + @Override + public TemporaryBindingTrace getTrace() { + //functionCall.trace is temporary trace above variableCall.trace and is committed already + return variableCall.getTrace(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java index 4074771ecb7..c34da66c0f7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.types.lang; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -25,6 +26,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.scopes.*; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeImpl; @@ -189,16 +192,23 @@ public class JetStandardClasses { STANDARD_CLASSES_NAMESPACE, Collections.emptyList(), "Function" + i); + + SimpleFunctionDescriptorImpl invoke = new SimpleFunctionDescriptorImpl(function, Collections.emptyList(), "invoke", CallableMemberDescriptor.Kind.DECLARATION); + WritableScope scopeForInvoke = createScopeForInvokeFunction(function, invoke); + List typeParameters = createTypeParameters(i, function); FUNCTION[i] = function.initialize( false, - createTypeParameters(i, function), - Collections.singleton(getAnyType()), STUB, Collections.emptySet(), null); + typeParameters, + Collections.singleton(getAnyType()), scopeForInvoke, Collections.emptySet(), null); FUNCTION_TYPE_CONSTRUCTORS.add(FUNCTION[i].getTypeConstructor()); + FunctionDescriptorUtil.initializeFromFunctionType(invoke, function.getDefaultType(), new ClassReceiver(FUNCTION[i])); ClassDescriptorImpl receiverFunction = new ClassDescriptorImpl( STANDARD_CLASSES_NAMESPACE, Collections.emptyList(), "ExtensionFunction" + i); + SimpleFunctionDescriptorImpl invokeWithReceiver = new SimpleFunctionDescriptorImpl(receiverFunction, Collections.emptyList(), "invoke", CallableMemberDescriptor.Kind.DECLARATION); + WritableScope scopeForInvokeWithReceiver = createScopeForInvokeFunction(receiverFunction, invokeWithReceiver); List parameters = createTypeParameters(i, receiverFunction); parameters.add(0, TypeParameterDescriptor.createWithDefaultBound( receiverFunction, @@ -207,11 +217,19 @@ public class JetStandardClasses { RECEIVER_FUNCTION[i] = receiverFunction.initialize( false, parameters, - Collections.singleton(getAnyType()), STUB, Collections.emptySet(), null); + Collections.singleton(getAnyType()), scopeForInvokeWithReceiver, Collections.emptySet(), null); RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.add(RECEIVER_FUNCTION[i].getTypeConstructor()); + FunctionDescriptorUtil.initializeFromFunctionType(invokeWithReceiver, receiverFunction.getDefaultType(), new ClassReceiver(RECEIVER_FUNCTION[i])); } } + private static WritableScope createScopeForInvokeFunction(ClassDescriptorImpl function, SimpleFunctionDescriptorImpl invoke) { + WritableScope scopeForInvoke = new WritableScopeImpl(STUB, function, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Scope for function type"); + scopeForInvoke.addFunctionDescriptor(invoke); + scopeForInvoke.changeLockLevel(WritableScope.LockLevel.READING); + return scopeForInvoke; + } + private static List createTypeParameters(int parameterCount, ClassDescriptorImpl function) { List parameters = new ArrayList(); for (int j = 0; j < parameterCount; j++) { @@ -411,8 +429,9 @@ public class JetStandardClasses { } arguments.add(defaultProjection(returnType)); int size = parameterTypes.size(); - TypeConstructor constructor = receiverType == null ? FUNCTION[size].getTypeConstructor() : RECEIVER_FUNCTION[size].getTypeConstructor(); - return new JetTypeImpl(annotations, constructor, false, arguments, STUB); + ClassDescriptor classDescriptor = receiverType == null ? FUNCTION[size] : RECEIVER_FUNCTION[size]; + TypeConstructor constructor = classDescriptor.getTypeConstructor(); + return new JetTypeImpl(annotations, constructor, false, arguments, classDescriptor.getMemberScope(arguments)); } private static TypeProjection defaultProjection(JetType returnType) { diff --git a/compiler/integration-tests/data/hello.compile.gold b/compiler/integration-tests/data/hello.compile.expected similarity index 100% rename from compiler/integration-tests/data/hello.compile.gold rename to compiler/integration-tests/data/hello.compile.expected diff --git a/compiler/integration-tests/data/hello.run.gold b/compiler/integration-tests/data/hello.run.expected similarity index 100% rename from compiler/integration-tests/data/hello.run.gold rename to compiler/integration-tests/data/hello.run.expected diff --git a/compiler/integration-tests/data/help.gold b/compiler/integration-tests/data/help.expected similarity index 100% rename from compiler/integration-tests/data/help.gold rename to compiler/integration-tests/data/help.expected diff --git a/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java b/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java index 8f5ab4b894a..107b96d279f 100644 --- a/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java +++ b/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java @@ -111,18 +111,19 @@ public abstract class KotlinIntegrationTestBase { protected void check(String baseName, StringBuilder content) throws IOException { final File tmpFile = new File(getTestDataDirectory(), baseName + ".tmp"); - final File goldFile = new File(getTestDataDirectory(), baseName + ".gold"); + final File expectedFile = new File(getTestDataDirectory(), baseName + ".expected"); - if (!goldFile.isFile()) { + if (!expectedFile.isFile()) { Files.write(content, tmpFile, Charsets.UTF_8); - fail("No gold file " + goldFile); + fail("No .expected file " + expectedFile); } else { - final String goldContent = Files.toString(goldFile, UTF_8); + final String goldContent = Files.toString(expectedFile, UTF_8); if (!goldContent.equals(content.toString())) { Files.write(content, tmpFile, Charsets.UTF_8); - fail("tmp and gold differ, tmp file: " + tmpFile); + fail(".tmp and .expected files differ, tmp file: " + tmpFile); } + tmpFile.delete(); } } diff --git a/compiler/testData/codegen/classes/overloadPlusAssign.jet b/compiler/testData/codegen/classes/overloadPlusAssign.jet index 5247973e8d6..5e9b4a09eb9 100644 --- a/compiler/testData/codegen/classes/overloadPlusAssign.jet +++ b/compiler/testData/codegen/classes/overloadPlusAssign.jet @@ -12,7 +12,7 @@ class ArrayWrapper() { } fun get(index: Int): T { - return contents.get(index) + return contents.get(index)!! } } diff --git a/compiler/testData/codegen/classes/overloadPlusAssignReturn.jet b/compiler/testData/codegen/classes/overloadPlusAssignReturn.jet index c5236b0ace4..2a4912f1e94 100644 --- a/compiler/testData/codegen/classes/overloadPlusAssignReturn.jet +++ b/compiler/testData/codegen/classes/overloadPlusAssignReturn.jet @@ -15,7 +15,7 @@ class ArrayWrapper() { } fun get(index: Int): T { - return contents.get(index) + return contents.get(index)!! } } diff --git a/compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet b/compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet index c5236b0ace4..2a4912f1e94 100644 --- a/compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet +++ b/compiler/testData/codegen/classes/overloadPlusToPlusAssign.jet @@ -15,7 +15,7 @@ class ArrayWrapper() { } fun get(index: Int): T { - return contents.get(index) + return contents.get(index)!! } } diff --git a/compiler/testData/codegen/classes/overloadUnaryOperator.jet b/compiler/testData/codegen/classes/overloadUnaryOperator.jet index 120f84a2746..79197f3600b 100644 --- a/compiler/testData/codegen/classes/overloadUnaryOperator.jet +++ b/compiler/testData/codegen/classes/overloadUnaryOperator.jet @@ -15,7 +15,7 @@ class ArrayWrapper() { } fun get(index: Int): T { - return contents.get(index) + return contents.get(index)!! } } diff --git a/compiler/testData/codegen/controlStructures/forUserType.jet b/compiler/testData/codegen/controlStructures/forUserType.jet index 7c0a4d1203d..1bb637e4a26 100644 --- a/compiler/testData/codegen/controlStructures/forUserType.jet +++ b/compiler/testData/codegen/controlStructures/forUserType.jet @@ -19,28 +19,28 @@ fun box() : String { val c1: java.lang.Iterable = MyCollection1() sum = 0 for (el in c1) { - sum = sum + el + sum = sum + el!! } if(sum != 15) return "c1 failed" val c2 = MyCollection1() sum = 0 for (el in c2) { - sum = sum + el + sum = sum + el!! } if(sum != 15) return "c2 failed" val c3: Iterable = MyCollection2() sum = 0 for (el in c3) { - sum = sum + el + sum = sum + el!! } if(sum != 15) return "c3 failed" val c4 = MyCollection2() sum = 0 for (el in c4) { - sum = sum + el + sum = sum + el!! } if(sum != 15) return "c4 failed" @@ -50,7 +50,7 @@ fun box() : String { } sum = 0 for (el in a) { - sum = sum + el + sum = sum + el!! } if(sum != 10) return "a failed" @@ -69,7 +69,7 @@ fun box() : String { val c7 = MyCollection5() sum = 0 for (el in c7) { - sum = sum + el + sum = sum + el!! } if(sum != 0) return "c7 failed" diff --git a/compiler/testData/codegen/functions/invoke.kt b/compiler/testData/codegen/functions/invoke.kt new file mode 100644 index 00000000000..4f85a25ef06 --- /dev/null +++ b/compiler/testData/codegen/functions/invoke.kt @@ -0,0 +1,22 @@ +package invoke + +fun test1(predicate: (Int) -> Int, i: Int) = predicate(i) + +fun test2(predicate: (Int) -> Int, i: Int) = predicate.invoke(i) + +class Method { + fun invoke(i: Int) = i +} + +fun test3(method: Method, i: Int) = method.invoke(i) + +//todo +//fun test4(method: Method, i: Int) = method(i) + +fun box() : String { + if (test1({ it }, 1) != 1) return "fail 1" + if (test2({ it }, 2) != 2) return "fail 2" + if (test3(Method(), 3) != 3) return "fail 3" + //if (test4(Method(), 4) != 4) return "fail 4" + return "OK" +} diff --git a/compiler/testData/codegen/jdk-headers/arrayList.kt b/compiler/testData/codegen/jdk-headers/arrayList.kt new file mode 100644 index 00000000000..9dfcfc9cb24 --- /dev/null +++ b/compiler/testData/codegen/jdk-headers/arrayList.kt @@ -0,0 +1,13 @@ +import java.util.ArrayList + +fun box(): String { + val a = ArrayList() + a.add(74) + a.add(75) + val i: Int = a.get(0) + val j: Int = a.get(1) + if (i != 74) return "fail 1" + if (j != 75) return "fail 2" + if (a.size() != 2) return "epic fail" + return "OK" +} diff --git a/compiler/testData/codegen/jdk-headers/hashMap.kt b/compiler/testData/codegen/jdk-headers/hashMap.kt new file mode 100644 index 00000000000..db30d64a761 --- /dev/null +++ b/compiler/testData/codegen/jdk-headers/hashMap.kt @@ -0,0 +1,15 @@ +import java.util.* + +fun box(): String { + val map: Map = HashMap() + map.put("a", 1) + map.put("bb", 2) + map.put("ccc", 3) + map.put("dddd", 4) + if (map.get("a") != 1) return "fail 1" + if (map.size() != 4) return "fail 2" + if (map.get("eeeee") != null) return "fail 3" + if (!map.containsKey("bb")) return "fail 4" + if (map.entrySet().contains("ffffff")) return "fail 5" + return "OK" +} diff --git a/compiler/testData/codegen/regressions/kt471.kt b/compiler/testData/codegen/regressions/kt471.kt index bc452506e78..00714f4000b 100644 --- a/compiler/testData/codegen/regressions/kt471.kt +++ b/compiler/testData/codegen/regressions/kt471.kt @@ -1,5 +1,3 @@ -import java.util.ArrayList - class MyNumber(val i: Int) { fun inc(): MyNumber = MyNumber(i+1) } @@ -52,21 +50,32 @@ fun test6() : Boolean { return true } +// ArrayList without jdk-headers cannot be used in these tests +class MyArrayList(var value: T) { + fun get(index: Int): T { + if (index != 17) + throw Exception() + return value + } + fun set(index: Int, value: T): Unit { + if (index != 17) + throw Exception() + this.value = value + } +} + fun test7() : Boolean { - var mnr = ArrayList() - mnr.add(MyNumber(42)) - mnr[0]++ - if (mnr[0].i != 43) return false + var mnr = MyArrayList(MyNumber(42)) + mnr[17]++ + if (mnr[17].i != 43) return false return true } fun test8() : Boolean { - var mnr = ArrayList() - mnr.add(MyNumber(42)) - mnr.add(MyNumber(41)) - mnr[1] = mnr[0]++ - if (mnr[0].i != 43) return false - if (mnr[1].i != 42) return false + var mnr = MyArrayList(MyNumber(42)) + val old = mnr[17]++ + if (old.i != 42) return false + if (mnr[17].i != 43) return false return true } diff --git a/compiler/testData/codegen/regressions/kt475.jet b/compiler/testData/codegen/regressions/kt475.jet index 62c06ece2d3..e6dee342926 100644 --- a/compiler/testData/codegen/regressions/kt475.jet +++ b/compiler/testData/codegen/regressions/kt475.jet @@ -14,5 +14,5 @@ var ArrayList.length : Int set(value: Int) = throw java.lang.Error() var ArrayList.last : T - get() = get(size()-1) + get() = get(size()-1)!! set(el : T) { set(size()-1, el) } diff --git a/compiler/testData/codegen/super/basicmethodSuperClass.jet b/compiler/testData/codegen/super/basicmethodSuperClass.jet index 1b8a48bbfe9..06344019298 100644 --- a/compiler/testData/codegen/super/basicmethodSuperClass.jet +++ b/compiler/testData/codegen/super/basicmethodSuperClass.jet @@ -1,7 +1,7 @@ import java.util.ArrayList class N() : ArrayList() { - override fun add(el: Any) : Boolean { + override fun add(el: Any?) : Boolean { if (!super.add(el)) { throw Exception() } diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.jet b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.jet new file mode 100644 index 00000000000..e40bc8873a3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.jet @@ -0,0 +1,23 @@ +// FILE: A.java +public class A {} + +// FILE: X.java +import org.jetbrains.annotations.NotNull; + +public class X { + @NotNull T fooN() {return null;} + void barN(@NotNull T a) {} +} + +// FILE: Y.java +public class Y extends X { + +} + +// FILE: test.kt + +fun main() { + Y().fooN() : Any + Y().barN(null); +} + diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.jet b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.jet new file mode 100644 index 00000000000..f44ffeaf690 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.jet @@ -0,0 +1,23 @@ +// FILE: A.java +public class A {} + +// FILE: X.java +import org.jetbrains.annotations.NotNull; + +public class X { + @NotNull T fooN() {return null;} + void barN(@NotNull T a) {} +} + +// FILE: Y.java +public class Y extends X { + +} + +// FILE: test.kt + +fun main() { + Y().fooN() : Any + Y().barN(null); +} + diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.jet b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.jet new file mode 100644 index 00000000000..32114bfd2cf --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.jet @@ -0,0 +1,21 @@ +// FILE: A.java +public class A {} + +// FILE: X.java +public class X { + T foo() {return null;} + void bar(T a) {} +} + +// FILE: Y.java +public class Y extends X { + +} + +// FILE: test.kt + +fun main() { + Y().foo().length + Y().bar(null) +} + diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.jet b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.jet new file mode 100644 index 00000000000..2d86a647a05 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.jet @@ -0,0 +1,21 @@ +// FILE: A.java +public class A {} + +// FILE: X.java +public class X { + T foo() {return null;} + void bar(T a) {} +} + +// FILE: Y.java +public class Y extends X { + +} + +// FILE: test.kt + +fun main() { + Y().foo().hashCode() + Y().bar(null) +} + diff --git a/compiler/testData/mockJDK-1.7/jre/lib/rt.jar b/compiler/testData/mockJDK-1.7/jre/lib/rt.jar index 27a89f30f17..91ce8f9eece 100644 Binary files a/compiler/testData/mockJDK-1.7/jre/lib/rt.jar and b/compiler/testData/mockJDK-1.7/jre/lib/rt.jar differ diff --git a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java index 514a00a8990..70db5fdf602 100644 --- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -30,8 +30,10 @@ import com.intellij.testFramework.LightVirtualFile; import com.intellij.testFramework.TestDataFile; import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.plugin.JetLanguage; import java.io.File; @@ -65,14 +67,26 @@ public abstract class JetLiteFixture extends UsefulTestCase { @Override protected void setUp() throws Exception { super.setUp(); - createEnvironmentWithMockJdk(); } protected void createEnvironmentWithMockJdk() { + if (myEnvironment != null) { + throw new IllegalStateException("must not set up myEnvironemnt twice"); + } myEnvironment = JetTestUtils.createEnvironmentWithMockJdk(getTestRootDisposable()); } + protected void createEnvironmentWithMockJdk(@NotNull CompilerSpecialMode compilerSpecialMode) { + if (myEnvironment != null) { + throw new IllegalStateException("must not set up myEnvironemnt twice"); + } + myEnvironment = JetTestUtils.createEnvironmentWithMockJdk(getTestRootDisposable(), compilerSpecialMode); + } + protected void createEnvironmentWithFullJdk() { + if (myEnvironment != null) { + throw new IllegalStateException("must not set up myEnvironemnt twice"); + } myEnvironment = JetTestUtils.createEnvironmentWithFullJdk(getTestRootDisposable()); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index a0e9b7d4442..2e3c6076d8e 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -26,9 +26,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; 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.resolve.BindingContext; @@ -163,9 +163,7 @@ public class JetTestUtils { public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory, - CompileCompilerDependenciesTest - .compilerDependenciesForTests(CompilerSpecialMode.REGULAR, - true)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); } public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable) { @@ -173,8 +171,10 @@ public class JetTestUtils { } public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable, @NotNull CompilerSpecialMode compilerSpecialMode) { - return JetCoreEnvironment.getCoreEnvironmentForJVM(disposable, CompileCompilerDependenciesTest - .compilerDependenciesForTests(compilerSpecialMode, true)); + JetCoreEnvironment environment = + new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true)); + environment.addToClasspath(getAnnotationsJar()); + return environment; } public static File findMockJdkRtJar() { @@ -234,7 +234,7 @@ public class JetTestUtils { public static final Pattern FILE_PATTERN = Pattern.compile("//\\s*FILE:\\s*(.*)$", Pattern.MULTILINE); public static JetCoreEnvironment createEnvironmentWithFullJdk(Disposable disposable) { - return JetCoreEnvironment.getCoreEnvironmentForJVM(disposable, + return new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false)); } diff --git a/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java index 03ab347496e..32e7c4aed69 100644 --- a/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java +++ b/compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.lang.cfg.LoopInfo; import org.jetbrains.jet.lang.cfg.pseudocode.*; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.io.File; import java.io.FileNotFoundException; @@ -42,7 +43,7 @@ public class JetControlFlowTest extends JetLiteFixture { static { System.setProperty("idea.platform.prefix", "Idea"); } - + private String myName; public JetControlFlowTest(String dataPath, String name) { @@ -50,6 +51,13 @@ public class JetControlFlowTest extends JetLiteFixture { myName = name; } + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.STDLIB); + } + @Override public String getName() { return "test" + myName; diff --git a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java index 1c447845f51..3aeae16c31a 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java @@ -40,6 +40,13 @@ public class CheckerTestUtilTest extends JetLiteFixture { super("diagnostics/checkerTestUtil"); } + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(); + } + + protected void doTest(TheTest theTest) throws Exception { prepareForTest("test"); theTest.test(myFile); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java index f1414d9cd17..603b8fc3b7c 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java @@ -54,6 +54,12 @@ public class JetDiagnosticsTest extends JetLiteFixture { this.name = name; } + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.STDLIB); + } + @Override public String getName() { return "test" + name; @@ -169,7 +175,7 @@ public class JetDiagnosticsTest extends JetLiteFixture { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( getProject(), jetFiles, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)) + myEnvironment.getCompilerDependencies()) .getBindingContext(); boolean ok = true; diff --git a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java index 4c878d6da84..955d611294d 100644 --- a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java @@ -54,7 +54,7 @@ public class JavaDescriptorResolverTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(tmpdir); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); + jetCoreEnvironment.getCompilerDependencies(), jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); Assert.assertNotNull(classDescriptor); diff --git a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java index 2636aabf2d4..d2d38b6a16a 100644 --- a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java @@ -88,7 +88,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true)) + jetCoreEnvironment.getCompilerDependencies()) .getBindingContext(); return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel("test")); } @@ -116,7 +116,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); + jetCoreEnvironment.getCompilerDependencies(), jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } diff --git a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java index a15d70efffc..67e73da8f73 100644 --- a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java @@ -90,7 +90,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); + jetCoreEnvironment.getCompilerDependencies(), jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); diff --git a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java index cc68c573163..ae2a5694855 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.codegen; import jet.JetObject; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.lang.annotation.*; import java.lang.reflect.Constructor; @@ -24,6 +25,13 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class AnnotationGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testPropField() throws NoSuchFieldException, NoSuchMethodException { loadText("[Deprecated] var x = 0"); Class aClass = generateNamespaceClass(); diff --git a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java index 83935e04995..b51c3b2bfff 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java @@ -16,9 +16,18 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Method; public class ArrayGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testKt238 () throws Exception { blackBoxFile("regressions/kt238.jet"); } @@ -237,7 +246,7 @@ public class ArrayGenTest extends CodegenTestCase { public void testCollectionAssignGetMultiIndex () throws Exception { loadText("import java.util.ArrayList\n" + "fun box() : String { val s = ArrayList(1); s.add(\"\"); s [1, -1] = \"5\"; s[2, -2] += \"7\"; return s[2,-2] }\n" + - "fun ArrayList.get(index1: Int, index2 : Int) = this[index1+index2]\n" + + "fun ArrayList.get(index1: Int, index2 : Int) = this[index1+index2]!!\n" + "fun ArrayList.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem }\n"); // System.out.println(generateToText()); Method foo = generateFunction("box"); @@ -257,7 +266,7 @@ public class ArrayGenTest extends CodegenTestCase { public void testCollectionGetMultiIndex () throws Exception { loadText("import java.util.ArrayList\n" + "fun box() : String { val s = ArrayList(1); s.add(\"\"); s [1, -1] = \"5\"; return s[2, -2] }\n" + - "fun ArrayList.get(index1: Int, index2 : Int) = this[index1+index2]\n" + + "fun ArrayList.get(index1: Int, index2 : Int) = this[index1+index2]!!\n" + "fun ArrayList.set(index1: Int, index2 : Int, elem: String) { this[index1+index2] = elem }\n"); // System.out.println(generateToText()); Method foo = generateFunction("box"); diff --git a/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java index dc1a068531b..c389165b403 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/BridgeMethodGenTest.java @@ -16,8 +16,11 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + public class BridgeMethodGenTest extends CodegenTestCase { public void testBridgeMethod () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("bridge.jet"); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java index 8598ee335b8..ac3e9db8d37 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -26,7 +28,14 @@ import java.util.List; * @author alex.tkachman */ public class ClassGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + } + public void testPSVMClass() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("classes/simpleClass.jet"); final Class aClass = loadClass("SimpleClass", generateClassesInFile()); @@ -37,6 +46,7 @@ public class ClassGenTest extends CodegenTestCase { } public void testArrayListInheritance() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("classes/inheritingFromArrayList.jet"); // System.out.println(generateToText()); final Class aClass = loadClass("Foo", generateClassesInFile()); @@ -44,30 +54,37 @@ public class ClassGenTest extends CodegenTestCase { } public void testInheritanceAndDelegation_DelegatingDefaultConstructorProperties() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/inheritance.jet"); } public void testInheritanceAndDelegation2() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/delegation2.kt"); } public void testFunDelegation() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/funDelegation.jet"); } public void testPropertyDelegation() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/propertyDelegation.jet"); } public void testDiamondInheritance() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/diamondInheritance.jet"); } public void testRightHandOverride() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/rightHandOverride.jet"); } public void testNewInstanceExplicitConstructor() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("classes/newInstanceDefaultConstructor.jet"); // System.out.println(generateToText()); final Method method = generateFunction("test"); @@ -76,18 +93,22 @@ public class ClassGenTest extends CodegenTestCase { } public void testInnerClass() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/innerClass.jet"); } public void testInheritedInnerClass() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/inheritedInnerClass.jet"); } public void testInitializerBlock() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/initializerBlock.jet"); } public void testAbstractMethod() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("abstract class Foo { abstract fun x(): String; fun y(): Int = 0 }"); final ClassFileFactory codegens = generateClassesInFile(); @@ -97,34 +118,42 @@ public class ClassGenTest extends CodegenTestCase { } public void testInheritedMethod() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/inheritedMethod.jet"); } public void testInitializerBlockDImpl() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/initializerBlockDImpl.jet"); } public void testPropertyInInitializer() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/propertyInInitializer.jet"); } public void testOuterThis() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/outerThis.jet"); } public void testSecondaryConstructors() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/secondaryConstructors.jet"); } public void testExceptionConstructor() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/exceptionConstructor.jet"); } public void testSimpleBox() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/simpleBox.jet"); } public void testAbstractClass() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("abstract class SimpleClass() { }"); final Class aClass = createClassLoader(generateClassesInFile()).loadClass("SimpleClass"); @@ -132,15 +161,18 @@ public class ClassGenTest extends CodegenTestCase { } public void testClassObject() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/classObject.jet"); } public void testClassObjectMethod() throws Exception { -// todo to be implemented after removal of type info + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + // todo to be implemented after removal of type info // blackBoxFile("classes/classObjectMethod.jet"); } public void testClassObjectInterface() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("classes/classObjectInterface.jet"); final Method method = generateFunction(); Object result = method.invoke(null); @@ -148,26 +180,32 @@ public class ClassGenTest extends CodegenTestCase { } public void testOverloadBinaryOperator() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/overloadBinaryOperator.jet"); } public void testOverloadUnaryOperator() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/overloadUnaryOperator.jet"); } public void testOverloadPlusAssign() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/overloadPlusAssign.jet"); } public void testOverloadPlusAssignReturn() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/overloadPlusAssignReturn.jet"); } public void testOverloadPlusToPlusAssign() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/overloadPlusToPlusAssign.jet"); } public void testEnumClass() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("enum class Direction { NORTH; SOUTH; EAST; WEST }"); final Class direction = createClassLoader(generateClassesInFile()).loadClass("Direction"); // System.out.println(generateToText()); @@ -177,6 +215,7 @@ public class ClassGenTest extends CodegenTestCase { } public void testEnumConstantConstructors() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("enum class Color(val rgb: Int) { RED: Color(0xFF0000); GREEN: Color(0x00FF00); }"); final Class colorClass = createClassLoader(generateClassesInFile()).loadClass("Color"); final Field redField = colorClass.getField("RED"); @@ -186,21 +225,25 @@ public class ClassGenTest extends CodegenTestCase { } public void testClassObjFields() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("class A() { class object { val value = 10 } }\n" + "fun box() = if(A.value == 10) \"OK\" else \"fail\""); blackBox(); } public void testKt249() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt249.jet"); } public void testKt48 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt48.jet"); // System.out.println(generateToText()); } public void testKt309 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun box() = null"); final Method method = generateFunction("box"); assertEquals(method.getReturnType().getName(), "java.lang.Object"); @@ -208,65 +251,78 @@ public class ClassGenTest extends CodegenTestCase { } public void testKt343 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt343.jet"); // System.out.println(generateToText()); } public void testKt508 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("regressions/kt508.jet"); // System.out.println(generateToText()); blackBox(); } public void testKt504 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("regressions/kt504.jet"); // System.out.println(generateToText()); blackBox(); } public void testKt501 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt501.jet"); } public void testKt496 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt496.jet"); // System.out.println(generateToText()); } public void testKt500 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt500.jet"); } public void testKt694 () throws Exception { -// blackBoxFile("regressions/kt694.jet"); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + // blackBoxFile("regressions/kt694.jet"); } public void testKt285 () throws Exception { -// blackBoxFile("regressions/kt285.jet"); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + // blackBoxFile("regressions/kt285.jet"); } public void testKt707 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt707.jet"); } public void testKt857 () throws Exception { -// blackBoxFile("regressions/kt857.jet"); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + // blackBoxFile("regressions/kt857.jet"); } public void testKt903 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt903.jet"); } public void testKt940 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt940.kt"); } public void testKt1018 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1018.kt"); } public void testKt1120 () throws Exception { -// createEnvironmentWithFullJdk(); + createEnvironmentWithFullJdk(); // blackBoxFile("regressions/kt1120.kt"); } @@ -276,47 +332,58 @@ public class ClassGenTest extends CodegenTestCase { } public void testKt1134() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1134.kt"); } public void testKt1157() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1157.kt"); } public void testKt471() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt471.kt"); } public void testKt1213() throws Exception { -// blackBoxFile("regressions/kt1213.kt"); + createEnvironmentWithMockJdk(); + // blackBoxFile("regressions/kt1213.kt"); } public void testKt723() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt723.kt"); } public void testKt725() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt725.kt"); } public void testKt633() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt633.kt"); } public void testKt1345() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1345.kt"); } public void testKt1538() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1538.kt"); } public void testKt1759() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1759.kt"); } public void testResolveOrder() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("classes/resolveOrder.jet"); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java index d7a2fc81ee6..4b220b4b5c1 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ClosuresGenTest.java @@ -16,10 +16,19 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + /** * @author max */ public class ClosuresGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testSimplestClosure() throws Exception { blackBoxFile("classes/simplestClosure.jet"); // System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index e95269f3368..302d63f4d7a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; +import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.parsing.JetParsingTest; @@ -127,8 +128,9 @@ public abstract class CodegenTestCase extends JetLiteFixture { private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) { final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( myFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false)); + myEnvironment.getCompilerDependencies()); analyzeExhaust.throwIfError(); + AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); GenerationState state = new GenerationState(getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile)); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); return state; @@ -194,8 +196,7 @@ public abstract class CodegenTestCase extends JetLiteFixture { r = method; } - if (r == null) - throw new AssertionError(); + if (r == null) { throw new AssertionError(); } return r; } catch (Error e) { System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java index 2b254310060..0159244370e 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java @@ -16,24 +16,19 @@ package org.jetbrains.jet.codegen; -import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration; -import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; import org.jetbrains.jet.cli.common.messages.MessageCollector; -import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class CompileTextTest extends CodegenTestCase { public void testMe() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(); String text = "import org.jetbrains.jet.codegen.CompileTextTest; fun x() = CompileTextTest()"; - CompilerDependencies dependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false); - JetCoreEnvironment environment = JetCoreEnvironment.getCoreEnvironmentForJVM(CompileEnvironmentUtil.createMockDisposable(), dependencies); - CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration(environment, dependencies, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); + CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration( + myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); configuration.getEnvironment().addToClasspathFromClassLoader(getClass().getClassLoader()); ClassLoader classLoader = KotlinToJVMBytecodeCompiler.compileText(configuration, text); Class namespace = classLoader.loadClass("namespace"); diff --git a/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java index ed7c393f87a..095cbdf7b49 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ControlStructuresTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; @@ -31,6 +33,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testIf() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); @@ -40,6 +43,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testSingleBranchIf() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); @@ -61,6 +65,7 @@ public class ControlStructuresTest extends CodegenTestCase { } private void factorialTest(final String name) throws IllegalAccessException, InvocationTargetException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(name); // System.out.println(generateToText()); @@ -70,6 +75,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testContinue() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -78,6 +84,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testIfNoElse() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -86,6 +93,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testCondJumpOnStack() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("import java.lang.Boolean as jlBoolean; fun foo(a: String): Int = if (jlBoolean.parseBoolean(a)) 5 else 10"); final Method main = generateFunction(); assertEquals(5, main.invoke(null, "true")); @@ -93,6 +101,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testFor() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -101,6 +110,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testIfBlock() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -111,6 +121,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testForInArray() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -119,6 +130,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testForInRange() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun foo(sb: StringBuilder) { for(x in 1..4) sb.append(x) }"); final Method main = generateFunction(); StringBuilder stringBuilder = new StringBuilder(); @@ -127,6 +139,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testThrowCheckedException() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun foo() { throw Exception(); }"); final Method main = generateFunction(); boolean caught = false; @@ -141,6 +154,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testTryCatch() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -149,6 +163,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testTryFinally() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -168,30 +183,37 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testForUserType() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/forUserType.jet"); } public void testForIntArray() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/forIntArray.jet"); } public void testForPrimitiveIntArray() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/forPrimitiveIntArray.jet"); } public void testForNullableIntArray() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/forNullableIntArray.jet"); } public void testForIntRange() { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/forIntRange.jet"); } public void testKt237() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt237.jet"); } public void testCompareToNull() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun foo(a: String?, b: String?): Boolean = a == null && b !== null && null == a && null !== b"); String text = generateToText(); assertTrue(!text.contains("java/lang/Object.equals")); @@ -202,6 +224,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testCompareToNonnullableEq() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun foo(a: String?, b: String): Boolean = a == b || b == a"); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -210,6 +233,7 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testCompareToNonnullableNotEq() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun foo(a: String?, b: String): Boolean = a != b"); String text = generateToText(); // System.out.println(text); @@ -220,15 +244,18 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testKt299() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt299.jet"); } public void testKt416() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt416.jet"); // System.out.println(generateToText()); } public void testKt513() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt513.jet"); } @@ -238,31 +265,37 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testKt769() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt769.jet"); // System.out.println(generateToText()); } public void testKt773() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt773.jet"); // System.out.println(generateToText()); } public void testKt772() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt772.jet"); // System.out.println(generateToText()); } public void testKt870() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt870.jet"); // System.out.println(generateToText()); } public void testKt958() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt958.jet"); // System.out.println(generateToText()); } public void testQuicksort() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("controlStructures/quicksort.jet"); // System.out.println(generateToText()); } @@ -280,18 +313,22 @@ public class ControlStructuresTest extends CodegenTestCase { } public void testKt1076() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1076.kt"); } public void testKt998() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt998.kt"); } public void testKt628() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt628.kt"); } public void testKt1441() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1441.kt"); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java b/compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java index d582c5b65a2..7f3f5eefe2d 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ExtensionFunctionsTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Method; /** @@ -29,6 +31,7 @@ public class ExtensionFunctionsTest extends CodegenTestCase { } public void testSimple() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Method foo = generateFunction("foo"); final Character c = (Character) foo.invoke(null); @@ -36,6 +39,7 @@ public class ExtensionFunctionsTest extends CodegenTestCase { } public void testWhenFail() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); // System.out.println(generateToText()); Method foo = generateFunction("foo"); @@ -43,15 +47,18 @@ public class ExtensionFunctionsTest extends CodegenTestCase { } public void testVirtual() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("extensionFunctions/virtual.jet"); } public void testShared() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("extensionFunctions/shared.kt"); // System.out.println(generateToText()); } public void testKt475() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt475.jet"); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java index 1d2fbac51cd..60672485073 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -23,6 +25,12 @@ import java.lang.reflect.Method; * @author alex.tkachman */ public class FunctionGenTest extends CodegenTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testDefaultArgs() throws Exception { blackBoxFile("functions/defaultargs.jet"); // System.out.println(generateToText()); @@ -101,4 +109,8 @@ public class FunctionGenTest extends CodegenTestCase { public void testLocalFunction () throws InvocationTargetException, IllegalAccessException { blackBoxFile("functions/localFunction.kt"); } + + public void testInvoke() { + blackBoxFile("functions/invoke.kt"); + } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/JdkHeadersTest.java b/compiler/tests/org/jetbrains/jet/codegen/JdkHeadersTest.java new file mode 100644 index 00000000000..f70b569d66a --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/codegen/JdkHeadersTest.java @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.codegen; + +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + +/** + * Test correct code is generated for descriptors loaded as alt jdk headers + * + * @author Stepan Koltsov + */ +public class JdkHeadersTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.STDLIB); + } + + public void testArrayList() { + blackBoxFile("jdk-headers/arrayList.kt"); + } + + public void testHashMap() { + blackBoxFile("jdk-headers/hashMap.kt"); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java index 5b18e101b47..1e8791a1d59 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/NamespaceGenTest.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.codegen; import jet.IntRange; import jet.Tuple2; import jet.Tuple4; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.awt.*; import java.lang.reflect.InvocationTargetException; @@ -30,6 +31,13 @@ import java.util.Arrays; * @author yole */ public class NamespaceGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testPSVM() throws Exception { loadFile("PSVM.jet"); // System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java index ee83ac306d9..2803abd67eb 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ObjectGenTest.java @@ -16,11 +16,19 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + /** * @author yole * @author alex.tkachman */ public class ObjectGenTest extends CodegenTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testSimpleObject() throws Exception { blackBoxFile("objects/simpleObject.jet"); // System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java b/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java index 9c1e048c9b0..318de46aec8 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PatternMatchingTest.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.codegen; import jet.Tuple2; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.lang.reflect.Method; @@ -24,6 +25,13 @@ import java.lang.reflect.Method; * @author yole */ public class PatternMatchingTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + @Override protected String getPrefix() { return "patternMatching"; diff --git a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java index 37fe4d052ba..0db6d37fa2e 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PrimitiveTypesTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Method; /** @@ -23,6 +25,13 @@ import java.lang.reflect.Method; * @author alex.tkachman */ public class PrimitiveTypesTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testPlus() throws Exception { loadText("fun f(a: Int, b: Int): Int { return a + b }"); diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java index a5e7eb58dd3..c0ddbaffc4a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; @@ -31,6 +33,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testPrivateVal() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Class aClass = loadImplementationClass(generateClassesInFile(), "PrivateVal"); final Field[] fields = aClass.getDeclaredFields(); @@ -40,6 +43,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testPrivateVar() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Class aClass = loadImplementationClass(generateClassesInFile(), "PrivateVar"); final Object instance = aClass.newInstance(); @@ -50,6 +54,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testPublicVar() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("class PublicVar() { public var foo : Int = 0; }"); final Class aClass = loadImplementationClass(generateClassesInFile(), "PublicVar"); final Object instance = aClass.newInstance(); @@ -60,6 +65,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testAccessorsInInterface() { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("class AccessorsInInterface() { public var foo : Int = 0; }"); final Class aClass = loadClass("AccessorsInInterface", generateClassesInFile()); assertNotNull(findMethodByName(aClass, "getFoo")); @@ -67,6 +73,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testPrivatePropertyInNamespace() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("private val x = 239"); final Class nsClass = generateNamespaceClass(); final Field[] fields = nsClass.getDeclaredFields(); @@ -79,6 +86,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testFieldPropertyAccess() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile("properties/fieldPropertyAccess.jet"); // System.out.println(generateToText()); final Method method = generateFunction(); @@ -87,12 +95,14 @@ public class PropertyGenTest extends CodegenTestCase { } public void testFieldGetter() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("val now: Long get() = System.currentTimeMillis(); fun foo() = now"); final Method method = generateFunction("foo"); assertIsCurrentTime((Long) method.invoke(null)); } public void testFieldSetter() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Method method = generateFunction("append"); method.invoke(null, "IntelliJ "); @@ -104,6 +114,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testFieldSetterPlusEq() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Method method = generateFunction("append"); method.invoke(null, "IntelliJ "); @@ -112,6 +123,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testAccessorsWithoutBody() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("class AccessorsWithoutBody() { protected var foo: Int = 349\n get\n private set\n fun setter() { foo = 610; } } "); // System.out.println(generateToText()); final Class aClass = loadImplementationClass(generateClassesInFile(), "AccessorsWithoutBody"); @@ -129,6 +141,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testInitializersForNamespaceProperties() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("val x = System.currentTimeMillis()"); final Method method = generateFunction("getX"); method.setAccessible(true); @@ -136,6 +149,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testPropertyReceiverOnStack() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadFile(); final Class aClass = loadImplementationClass(generateClassesInFile(), "Evaluator"); final Constructor constructor = aClass.getConstructor(StringBuilder.class); @@ -147,6 +161,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testAbstractVal() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("abstract class Foo { public abstract val x: String }"); final ClassFileFactory codegens = generateClassesInFile(); final Class aClass = loadClass("Foo", codegens); @@ -154,6 +169,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testVolatileProperty() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("abstract class Foo { public volatile var x: String = \"\"; }"); // System.out.println(generateToText()); final ClassFileFactory codegens = generateClassesInFile(); @@ -163,15 +179,18 @@ public class PropertyGenTest extends CodegenTestCase { } public void testKt257 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt257.jet"); // System.out.println(generateToText()); } public void testKt613 () throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt613.jet"); } public void testKt160() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("internal val s = java.lang.Double.toString(1.0)"); final Method method = generateFunction("getS"); method.setAccessible(true); @@ -179,10 +198,12 @@ public class PropertyGenTest extends CodegenTestCase { } public void testKt1165() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1165.kt"); } public void testKt1168() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1168.kt"); } @@ -192,14 +213,17 @@ public class PropertyGenTest extends CodegenTestCase { } public void testKt1159() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1159.kt"); } public void testKt1417() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1417.kt"); } public void testKt1398() throws Exception { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt1398.kt"); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java b/compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java index 8a579bef218..fc1a4ccb5df 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/SafeRefTest.java @@ -16,7 +16,15 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + public class SafeRefTest extends CodegenTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void test247 () throws Exception { blackBoxFile("regressions/kt247.jet"); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/StringsTest.java b/compiler/tests/org/jetbrains/jet/codegen/StringsTest.java index 73793d9083e..50196c364e7 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/StringsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/StringsTest.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -25,6 +27,12 @@ import java.lang.reflect.Method; */ public class StringsTest extends CodegenTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testAnyToString () throws InvocationTargetException, IllegalAccessException { loadText("fun foo(x: Any) = x.toString()"); // System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java index 1f83ea3aeb8..1884873b80a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/SuperGenTest.java @@ -16,7 +16,16 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + public class SuperGenTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + public void testBasicProperty () { blackBoxFile("/super/basicproperty.jet"); // System.out.println(generateToText()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java index fd581894162..ff0dc1a0498 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java @@ -21,7 +21,6 @@ import gnu.trove.THashSet; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; -import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration; import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; @@ -32,8 +31,6 @@ import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.parsing.JetParsingTest; @@ -75,7 +72,6 @@ public class TestlibTest extends CodegenTestCase { private TestSuite doBuildSuite() { try { - CompilerDependencies compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false); File junitJar = new File("libraries/lib/junit-4.9.jar"); if (!junitJar.exists()) { @@ -84,14 +80,14 @@ public class TestlibTest extends CodegenTestCase { myEnvironment.addToClasspath(junitJar); - myEnvironment.addToClasspath(compilerDependencies.getRuntimeJar()); + myEnvironment.addToClasspath(myEnvironment.getCompilerDependencies().getRuntimeJar()); CoreLocalFileSystem localFileSystem = myEnvironment.getLocalFileSystem(); myEnvironment.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/stdlib/test")); myEnvironment.addSources(localFileSystem.findFileByPath(JetParsingTest.getTestDataDir() + "/../../libraries/kunit/src")); GenerationState generationState = KotlinToJVMBytecodeCompiler - .analyzeAndGenerate(new CompileEnvironmentConfiguration(myEnvironment, compilerDependencies, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR), false); + .analyzeAndGenerate(new CompileEnvironmentConfiguration(myEnvironment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR), false); if (generationState == null) { throw new RuntimeException("There were compilation errors"); diff --git a/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java b/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java index 1991e81b676..0fe37963fdc 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TraitsTest.java @@ -16,7 +16,16 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + public class TraitsTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + @Override protected String getPrefix() { return "traits"; diff --git a/compiler/tests/org/jetbrains/jet/codegen/TupleGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/TupleGenTest.java index 49c9e6afc25..b394def5fc6 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TupleGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TupleGenTest.java @@ -16,8 +16,11 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + public class TupleGenTest extends CodegenTestCase { public void testBasic() { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("/tuples/basic.jet"); // System.out.println(generateToText()); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java b/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java index 06e2cb575b1..e7dfe162c4a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TypeInfoTest.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.codegen; import jet.TypeCastException; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.lang.reflect.Method; @@ -25,6 +26,13 @@ import java.lang.reflect.Method; * @author alex.tkachman */ public class TypeInfoTest extends CodegenTestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); + } + @Override protected String getPrefix() { return "typeInfo"; diff --git a/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java index 6164d2dcada..37e4b680da1 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java @@ -16,16 +16,18 @@ package org.jetbrains.jet.codegen; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; + import java.lang.reflect.Array; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.Arrays; /** * @author alex.tkachman */ public class VarArgTest extends CodegenTestCase { public void testStringArray () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test(vararg ts: String) = ts"); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -34,6 +36,7 @@ public class VarArgTest extends CodegenTestCase { } public void testIntArray () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test(vararg ts: Int) = ts"); // System.out.println(generateToText()); final Method main = generateFunction(); @@ -42,6 +45,7 @@ public class VarArgTest extends CodegenTestCase { } public void testIntArrayKotlinNoArgs () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test() = testf(); fun testf(vararg ts: Int) = ts"); // System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -50,6 +54,7 @@ public class VarArgTest extends CodegenTestCase { } public void testIntArrayKotlin () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test() = testf(239, 7); fun testf(vararg ts: Int) = ts"); // System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -60,6 +65,7 @@ public class VarArgTest extends CodegenTestCase { } public void testNullableIntArrayKotlin () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test() = testf(239.toByte(), 7.toByte()); fun testf(vararg ts: Byte?) = ts"); // System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -70,6 +76,7 @@ public class VarArgTest extends CodegenTestCase { } public void testIntArrayKotlinObj () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test() = testf(\"239\"); fun testf(vararg ts: String) = ts"); // System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -79,6 +86,7 @@ public class VarArgTest extends CodegenTestCase { } public void testArrayT () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("fun test() = _array(2, 4); fun _array(vararg elements : T) = elements"); // System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -94,10 +102,12 @@ public class VarArgTest extends CodegenTestCase { } public void testKt797() { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); blackBoxFile("regressions/kt796_797.jet"); } public void testArrayAsVararg () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("private fun asList(vararg elems: String) = elems; fun test(ts: Array) = asList(*ts); "); //System.out.println(generateToText()); final Method main = generateFunction("test"); @@ -106,6 +116,7 @@ public class VarArgTest extends CodegenTestCase { } public void testArrayAsVararg2 () throws InvocationTargetException, IllegalAccessException { + createEnvironmentWithMockJdk(CompilerSpecialMode.JDK_HEADERS); loadText("private fun asList(vararg elems: String) = elems; fun test(ts1: Array, ts2: String) = asList(*ts1, ts2); "); System.out.println(generateToText()); final Method main = generateFunction("test"); diff --git a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java index fb299b9a079..464a2279dfd 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java @@ -41,6 +41,14 @@ import java.util.List; * @since 4/6/12 */ public class DescriptorRendererTest extends JetLiteFixture { + + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(); + } + + public void testGlobalProperties() throws IOException { doTest(); } @@ -72,7 +80,7 @@ public class DescriptorRendererTest extends JetLiteFixture { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); + myEnvironment.getCompilerDependencies()); final BindingContext bindingContext = analyzeExhaust.getBindingContext(); final List descriptors = new ArrayList(); psiFile.acceptChildren(new JetVisitorVoid() { diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index f2d236a2e83..00f7434ed38 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -78,9 +79,13 @@ public abstract class ExpectedResolveData { private final Map nameToDescriptor; private final Map nameToPsiElement; - public ExpectedResolveData(Map nameToDescriptor, Map nameToPsiElement) { + @NotNull + private final JetCoreEnvironment jetCoreEnvironment; + + public ExpectedResolveData(Map nameToDescriptor, Map nameToPsiElement, @NotNull JetCoreEnvironment environment) { this.nameToDescriptor = nameToDescriptor; this.nameToPsiElement = nameToPsiElement; + jetCoreEnvironment = environment; } public final JetFile createFileFromMarkedUpText(String fileName, String text) { @@ -143,7 +148,7 @@ public abstract class ExpectedResolveData { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); + jetCoreEnvironment.getCompilerDependencies()); BindingContext bindingContext = analyzeExhaust.getBindingContext(); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java index bc8bd8f7f54..3e736e690fd 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java @@ -20,6 +20,7 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import java.util.List; @@ -32,6 +33,9 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture { @Override protected void setUp() throws Exception { super.setUp(); + + createEnvironmentWithMockJdk(CompilerSpecialMode.STDLIB); + expectedResolveData = getExpectedResolveData(); } diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 6540ba315cd..f52d1fd7e28 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -24,7 +24,6 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import junit.framework.Test; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForTests; @@ -37,8 +36,6 @@ import org.jetbrains.jet.lang.resolve.FqName; 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.java.CompilerSpecialMode; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinder; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; @@ -103,7 +100,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { nameToDeclaration.put("java::java.lang.Number", java_lang_Number); nameToDeclaration.put("java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]); - return new ExpectedResolveData(nameToDescriptor, nameToDeclaration) { + return new ExpectedResolveData(nameToDescriptor, nameToDeclaration, myEnvironment) { @Override protected JetFile createJetFile(String fileName, String text) { return createCheckAndReturnPsiFile(fileName, text); @@ -127,7 +124,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { private PsiClass findClass(String qualifiedName) { Project project = getProject(); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true), project); + myEnvironment.getCompilerDependencies(), project); return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW); } diff --git a/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java b/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java index 548314b7cf9..7d7e5fa91a3 100644 --- a/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java +++ b/compiler/tests/org/jetbrains/jet/runtime/JetNpeTest.java @@ -22,6 +22,14 @@ import org.jetbrains.jet.codegen.CodegenTestCase; import java.lang.reflect.Method; public class JetNpeTest extends CodegenTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + createEnvironmentWithMockJdk(); + } + + + public void testStackTrace () { try { Intrinsics.throwNpe(); diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 1a2a064a398..b1e78c68ebf 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -45,6 +45,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); + super.createEnvironmentWithMockJdk(); tc.setUp(); } @@ -67,7 +68,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { assert aClass instanceof JetClass; AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); + myEnvironment.getCompilerDependencies()); DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass); WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING); assert classDescriptor instanceof ClassifierDescriptor; diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java index 104a46b7f2c..415265d1f7b 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java @@ -40,6 +40,7 @@ public class JetOverloadTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); + createEnvironmentWithMockJdk(); InjectorForTests injector = new InjectorForTests(getProject()); library = injector.getJetStandardLibrary(); descriptorResolver = injector.getDescriptorResolver(); diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index 12d663c8971..8f88357f684 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java @@ -40,6 +40,7 @@ public class JetOverridingTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); + createEnvironmentWithMockJdk(); InjectorForTests injector = new InjectorForTests(getProject()); library = injector.getJetStandardLibrary(); descriptorResolver = injector.getDescriptorResolver(); diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 400b00ff07d..e00f0a5ed0f 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -66,6 +66,9 @@ public class JetTypeCheckerTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); + + super.createEnvironmentWithMockJdk(); + library = JetStandardLibrary.getInstance(); classDefinitions = new ClassDefinitions(); @@ -587,7 +590,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true), getProject()); + myEnvironment.getCompilerDependencies(), getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); diff --git a/idea/src/org/jetbrains/jet/plugin/internal/resolvewindow/ResolveToolwindow.java b/idea/src/org/jetbrains/jet/plugin/internal/resolvewindow/ResolveToolwindow.java index d674edd60e0..0c456ff0f7b 100644 --- a/idea/src/org/jetbrains/jet/plugin/internal/resolvewindow/ResolveToolwindow.java +++ b/idea/src/org/jetbrains/jet/plugin/internal/resolvewindow/ResolveToolwindow.java @@ -192,9 +192,9 @@ public class ResolveToolwindow extends JPanel implements Disposable { StringBuilder result = new StringBuilder(); if (debugInfo != null) { - List> resolutionTasks = debugInfo.get(TASKS); - for (ResolutionTask resolutionTask : resolutionTasks) { - for (ResolvedCallImpl resolvedCall : resolutionTask.getResolvedCallMap().values()) { + List> resolutionTasks = debugInfo.get(TASKS); + for (ResolutionTask resolutionTask : resolutionTasks) { + for (ResolvedCallWithTrace resolvedCall : resolutionTask.getResolvedCalls()) { renderResolutionLogForCall(debugInfo, resolvedCall, result); } } @@ -212,7 +212,7 @@ public class ResolveToolwindow extends JPanel implements Disposable { return result.toString(); } - private void renderResolutionLogForCall(Data debugInfo, ResolvedCallImpl resolvedCall, StringBuilder result) { + private void renderResolutionLogForCall(Data debugInfo, ResolvedCallWithTrace resolvedCall, StringBuilder result) { result.append("Trying to call ").append(resolvedCall.getCandidateDescriptor()).append("\n"); StringBuilder errors = debugInfo.getByKey(ERRORS, resolvedCall); if (errors != null) { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java index 85a09258840..01186e92a35 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java @@ -21,6 +21,8 @@ import com.google.dart.compiler.backend.js.ast.JsExpression; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.calls.ResolutionCandidate; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; @@ -104,7 +106,8 @@ public final class CallBuilder { private CallTranslator finish() { if (resolvedCall == null) { assert descriptor != null; - resolvedCall = ResolvedCallImpl.create(ResolutionCandidate.create(descriptor)); + resolvedCall = ResolvedCallImpl.create(ResolutionCandidate.create(descriptor), + TemporaryBindingTrace.create(new BindingTraceContext())); //todo } if (descriptor == null) { descriptor = resolvedCall.getCandidateDescriptor().getOriginal(); diff --git a/lib/jsr305-1.3.9.jar b/lib/jsr305-1.3.9.jar new file mode 100644 index 00000000000..a9afc6619b4 Binary files /dev/null and b/lib/jsr305-1.3.9.jar differ diff --git a/libraries/docs/website/pom.xml b/libraries/docs/website/pom.xml index 0d854b4f4e5..f21ab1711a6 100644 --- a/libraries/docs/website/pom.xml +++ b/libraries/docs/website/pom.xml @@ -28,8 +28,8 @@ - ${project.basedir}/src/main/kotlin - ${project.basedir}/src/test/kotlin + src/main/kotlin + src/test/kotlin diff --git a/libraries/kotlin-jdbc/pom.xml b/libraries/kotlin-jdbc/pom.xml index 910f058726d..dd755a81bcd 100644 --- a/libraries/kotlin-jdbc/pom.xml +++ b/libraries/kotlin-jdbc/pom.xml @@ -29,8 +29,8 @@ - ${project.basedir}/src/main/kotlin - ${project.basedir}/src/test/kotlin + src/main/kotlin + src/test/kotlin diff --git a/libraries/kotlin-swing/pom.xml b/libraries/kotlin-swing/pom.xml index 4b128f347d6..eac98705786 100644 --- a/libraries/kotlin-swing/pom.xml +++ b/libraries/kotlin-swing/pom.xml @@ -23,8 +23,8 @@ - ${project.basedir}/src/main/kotlin - ${project.basedir}/src/test/kotlin + src/main/kotlin + src/test/kotlin diff --git a/libraries/kunit/pom.xml b/libraries/kunit/pom.xml index 575599798a3..d710ab52264 100644 --- a/libraries/kunit/pom.xml +++ b/libraries/kunit/pom.xml @@ -28,8 +28,8 @@ - ${project.basedir}/src/main/kotlin - ${project.basedir}/src/test/kotlin + src/main/kotlin + src/test/kotlin diff --git a/libraries/pom.xml b/libraries/pom.xml index 934bce360ce..03a07f15814 100644 --- a/libraries/pom.xml +++ b/libraries/pom.xml @@ -12,7 +12,7 @@ UTF-8 - ${project.basedir}/../../.. + ../../.. 3.3.1 dart-r3300 diff --git a/libraries/stdlib/pom.xml b/libraries/stdlib/pom.xml index 320f0dcb913..bb5e85d930c 100644 --- a/libraries/stdlib/pom.xml +++ b/libraries/stdlib/pom.xml @@ -22,8 +22,8 @@ - ${project.basedir}/src - ${project.basedir}/test + src + test diff --git a/libraries/stdlib/test/CollectionTest.kt b/libraries/stdlib/test/CollectionTest.kt index b3b86928ca7..2c35b16e951 100644 --- a/libraries/stdlib/test/CollectionTest.kt +++ b/libraries/stdlib/test/CollectionTest.kt @@ -320,7 +320,8 @@ class CollectionTest { assertEquals(0, ArrayList().count()) } - test fun last() { + //todo after KT-1873 the name might be returned to 'last' + test fun lastElement() { val data = arrayList("foo", "bar") assertEquals("bar", data.last()) assertEquals(25, arrayList(15, 19, 20, 25).last()) diff --git a/libraries/tools/kdoc/pom.xml b/libraries/tools/kdoc/pom.xml index 04a32bdca82..451cad9c400 100644 --- a/libraries/tools/kdoc/pom.xml +++ b/libraries/tools/kdoc/pom.xml @@ -35,8 +35,8 @@ - ${project.basedir}/src/main/kotlin - ${project.basedir}/src/test/kotlin + src/main/kotlin + src/test/kotlin diff --git a/libraries/tools/kotlin-maven-plugin/ReadMe.md b/libraries/tools/kotlin-maven-plugin/ReadMe.md deleted file mode 100644 index 88a32b84cf1..00000000000 --- a/libraries/tools/kotlin-maven-plugin/ReadMe.md +++ /dev/null @@ -1,4 +0,0 @@ -## NOTE - this is just an initial spike of some maven plugins - -Until this plugin is working, please use this maven plugin: -http://evgeny-goldin.com/wiki/Kotlin-maven-plugin \ No newline at end of file diff --git a/libraries/tools/runtime/pom.xml b/libraries/tools/runtime/pom.xml index f887a4724fc..090bd908eda 100644 --- a/libraries/tools/runtime/pom.xml +++ b/libraries/tools/runtime/pom.xml @@ -16,9 +16,33 @@ jar - ${project.basedir}/../../../runtime/src + target/copied-sources + + org.apache.maven.plugins + maven-antrun-plugin + 1.7 + + + + copy-sources + process-sources + + + + + + + + + + run + + + + + org.apache.maven.plugins maven-source-plugin diff --git a/update_dependencies.xml b/update_dependencies.xml index 6de46208e56..e7e9c20c8ca 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,24 +1,46 @@ - + - + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + - - - - - - @@ -26,22 +48,30 @@ - - - - - - - - - - + + + + + + + + + + + + + + + + + +