diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt index a81569ac9fc..a513b7b90fc 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightMethodForDeclaration.kt @@ -41,6 +41,7 @@ import com.intellij.psi.PsiTypeParameter import org.jetbrains.jet.lang.psi.JetClassOrObject import com.intellij.psi.impl.light.LightTypeParameterListBuilder import com.intellij.psi.search.SearchScope +import org.jetbrains.jet.utils.* public class KotlinLightMethodForDeclaration( manager: PsiManager, override val delegate: PsiMethod, override val origin: JetDeclaration, containingClass: PsiClass @@ -51,7 +52,7 @@ public class KotlinLightMethodForDeclaration( cacheManager.createCachedValue({ val parameterBuilder = LightParameterListBuilder(getManager(), JetLanguage.INSTANCE) - for ((index, parameter) in delegate.getParameterList().getParameters().withIndices()) { + for ((index, parameter) in delegate.getParameterList().getParameters().withIndices_tmp()) { parameterBuilder.addParameter(KotlinLightParameter(parameter, index, this)) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 03874431a6d..4a80a6a82da 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -127,7 +127,7 @@ public class LazyJavaClassMemberScope( val methods = jClass.getMethods() val result = ArrayList(methods.size()) - for ((index, method) in methods.withIndices()) { + for ((index, method) in methods.withIndices_tmp()) { assert(method.getValueParameters().isEmpty(), "Annotation method can't have parameters: " + method) val jReturnType = method.getReturnType() ?: throw AssertionError("Annotation method has no return type: " + method) diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt index 65df1bbc6f2..f7d325b0bc3 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt @@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils import org.jetbrains.jet.utils.Printer import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor import org.jetbrains.jet.lang.resolve.java.structure.JavaPropertyInitializerEvaluator +import org.jetbrains.jet.utils.* public abstract class LazyJavaMemberScope( protected val c: LazyJavaResolverContextWithTypes, @@ -166,7 +167,7 @@ public abstract class LazyJavaMemberScope( function: FunctionDescriptor, jValueParameters: List ): List { - return jValueParameters.withIndices().map { + return jValueParameters.withIndices_tmp().map_tmp { pair -> val (index, javaParameter) = pair diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt index 0fa9b038148..2bce5ea4712 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter import org.jetbrains.jet.lang.resolve.java.structure.JavaClass import org.jetbrains.kotlin.util.sure +import org.jetbrains.jet.utils.* import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaTypeParameterDescriptor import org.jetbrains.jet.lang.resolve.scopes.JetScope import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner @@ -194,7 +195,7 @@ class LazyJavaTypeResolver( return typeParameters.map { p -> TypeProjectionImpl(ErrorUtils.createErrorType(p.getName().asString())) } } var howTheProjectionIsUsed = if (attr.howThisTypeIsUsed == SUPERTYPE) SUPERTYPE_ARGUMENT else TYPE_ARGUMENT - return javaType.getTypeArguments().withIndices().map { + return javaType.getTypeArguments().withIndices_tmp().map_tmp { javaTypeParameter -> val (i, t) = javaTypeParameter val parameter = if (i >= typeParameters.size) diff --git a/core/util.runtime/src/org/jetbrains/jet/utils/Compatibility.kt b/core/util.runtime/src/org/jetbrains/jet/utils/Compatibility.kt new file mode 100644 index 00000000000..cda7ce880b2 --- /dev/null +++ b/core/util.runtime/src/org/jetbrains/jet/utils/Compatibility.kt @@ -0,0 +1,87 @@ +package org.jetbrains.jet.utils + +import java.util.ArrayList +import kotlin.support.AbstractIterator + +//TODO: Remove after updating to new stdlib +[deprecated("use streams instead")] +fun Iterable.firstOrNull_tmp() : T? { + val iterator = this.iterator() + return if (iterator.hasNext()) iterator.next() else null +} + +[deprecated("use streams instead")] +public inline fun Map.filter_tmp(predicate: (Map.Entry)->Boolean) : List> { + return filterTo_tmp(ArrayList>(), predicate) +} + +[deprecated("use streams instead")] +public inline fun >> Map.filterTo_tmp(collection: C, predicate: (Map.Entry) -> Boolean) : C { + for (element in this) if (predicate(element)) collection.add(element) + return collection +} + +[deprecated("use streams instead")] +public fun Iterator.zip_tmp(iterator: Iterator): Iterator> = PairIterator_tmp(this, iterator) +[deprecated("use streams instead")] +public fun Iterable.zip_tmp(second: Iterable): Iterable> { + val list = ArrayList>() + for (item in iterator().zip_tmp(second.iterator())) { + list.add(item) + } + return list +} + +[deprecated("use streams instead")] +public fun Iterator.map_tmp(transform : (T) -> R) : Iterator { + return MapIterator_tmp(this, transform) +} + +[deprecated("use streams instead")] +class MapIterator_tmp(val iterator : Iterator, val transform: (T) -> R) : AbstractIterator() { + override protected fun computeNext() : Unit { + if (iterator.hasNext()) { + setNext((transform)(iterator.next())) + } else { + done() + } + } +} + +[deprecated("use streams instead")] +public fun Iterable.withIndices_tmp() : Iterator> { + return IndexIterator_tmp(iterator()) +} + +[deprecated("use streams instead")] +public fun Array.withIndices_tmp() : Iterator> { + return IndexIterator_tmp(iterator()) +} + +[deprecated("use streams instead")] +class IndexIterator_tmp(val iterator : Iterator): Iterator> { + private var index : Int = 0 + + override fun next(): Pair { + return Pair(index++, iterator.next()) + } + + override fun hasNext(): Boolean { + return iterator.hasNext() + } +} + +[deprecated("use streams instead")] +public class PairIterator_tmp( + val iterator1 : Iterator, val iterator2 : Iterator +): AbstractIterator>() { + protected override fun computeNext() { + if (iterator1.hasNext() && iterator2.hasNext()) { + setNext(Pair(iterator1.next(), iterator2.next())) + } + else { + done() + } + } +} + diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt index 723d492fdce..f99c6bdb235 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt @@ -60,6 +60,8 @@ import org.jetbrains.jet.lang.psi.JetTypeReference import com.intellij.util.containers.ContainerUtil import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils import org.jetbrains.jet.plugin.imports.* +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor +import org.jetbrains.jet.utils.* //NOTE: this class is based on CopyPasteReferenceProcessor and JavaCopyPasteReferenceProcessor public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor { @@ -340,9 +342,9 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor> { +private fun zip(first: IntArray, second: IntArray): Iterable> { assert(first.size == second.size) - return first.iterator().zip(second.iterator()) + return first.toList().zip_tmp(second.toList()) } private fun PsiElement.isInCopiedArea(fileCopiedFrom: JetFile, startOffsets: IntArray, endOffsets: IntArray): Boolean { diff --git a/idea/src/org/jetbrains/jet/plugin/completion/SmartCompletion.kt b/idea/src/org/jetbrains/jet/plugin/completion/SmartCompletion.kt index 0c0c58a7cc4..c9d64c600f9 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/SmartCompletion.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/SmartCompletion.kt @@ -32,6 +32,7 @@ import com.intellij.psi.PsiDocumentManager import com.intellij.openapi.application.ApplicationManager import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import org.jetbrains.jet.plugin.codeInsight.ShortenReferences +import org.jetbrains.jet.utils.* trait SmartCompletionData{ fun accepts(descriptor: DeclarationDescriptor): Boolean @@ -287,8 +288,8 @@ private fun processDataFlowInfo(dataFlowInfo: DataFlowInfo?, receiver: JetExpres } val nullabilityInfo: Map = dataFlowInfo.getCompleteNullabilityInfo() - val notNullVariables = nullabilityInfo.iterator() - .filter { it.getValue() == Nullability.NOT_NULL } + val notNullVariables = nullabilityInfo + .filter_tmp { it.getValue() == Nullability.NOT_NULL } .map { dataFlowValueToVariable(it.getKey()) } .filterNotNullTo(HashSet()) @@ -408,4 +409,4 @@ private fun MutableCollection.addAll(iterator: Iterator) { } } -private fun String?.isNullOrEmpty() = this == null || this.isEmpty() \ No newline at end of file +private fun String?.isNullOrEmpty() = this == null || this.isEmpty() diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt index 85840c770e0..01610cb1c65 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceExplicitFunctionLiteralParamWithItIntention.kt @@ -30,8 +30,8 @@ import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor import org.jetbrains.jet.lang.resolve.BindingContextUtils import org.jetbrains.jet.plugin.references.JetReference -import org.jetbrains.jet.plugin.codeInsight.firstOrNull import org.jetbrains.jet.lang.descriptors.VariableDescriptor +import org.jetbrains.jet.utils.firstOrNull_tmp public class ReplaceExplicitFunctionLiteralParamWithItIntention() : PsiElementBaseIntentionAction() { override fun invoke(project: Project, editor: Editor, element: PsiElement) { @@ -75,7 +75,7 @@ public class ReplaceExplicitFunctionLiteralParamWithItIntention() : PsiElementBa } is JetSimpleNameExpression -> { val reference = expression.getReference() as JetReference? - val variableDescriptor = reference?.resolveToDescriptors()?.firstOrNull() as? VariableDescriptor? + val variableDescriptor = reference?.resolveToDescriptors()?.firstOrNull_tmp() as? VariableDescriptor? if (variableDescriptor != null) { val containingDescriptor = variableDescriptor.getContainingDeclaration() if (containingDescriptor is AnonymousFunctionDescriptor) { diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt index 1df55961d2b..b907b32a6fd 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/ReplaceItWithExplicitFunctionLiteralParamIntention.kt @@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor import org.jetbrains.jet.lang.resolve.BindingContextUtils import org.jetbrains.jet.lang.psi.JetFunctionLiteral import org.jetbrains.jet.plugin.references.JetReference -import org.jetbrains.jet.plugin.codeInsight.firstOrNull +import org.jetbrains.jet.utils.firstOrNull_tmp public class ReplaceItWithExplicitFunctionLiteralParamIntention() : PsiElementBaseIntentionAction() { override fun invoke(project: Project, editor: Editor, element: PsiElement) { @@ -64,7 +64,7 @@ public class ReplaceItWithExplicitFunctionLiteralParamIntention() : PsiElementBa val bindingContext = AnalyzerFacadeWithCache.getContextForElement(simpleNameExpression) val reference = simpleNameExpression.getReference() as JetReference? - val simpleNameTarget = reference?.resolveToDescriptors()?.firstOrNull() as? ValueParameterDescriptor? + val simpleNameTarget = reference?.resolveToDescriptors()?.firstOrNull_tmp() as? ValueParameterDescriptor? if (simpleNameTarget == null || bindingContext.get(BindingContext.AUTO_CREATED_IT, simpleNameTarget) != true) { return false } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/branchedTransformationUtils.kt b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/branchedTransformationUtils.kt index 5d1452b1d8b..6b14e32117d 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/branchedTransformationUtils.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/branchedTransformationUtils.kt @@ -27,6 +27,7 @@ import com.intellij.psi.util.PsiTreeUtil import com.intellij.psi.PsiWhiteSpace import java.util.Collections import com.intellij.util.containers.ContainerUtil +import org.jetbrains.jet.utils.* public val TRANSFORM_WITHOUT_CHECK: String = "Expression must be checked before applying transformation" @@ -325,17 +326,17 @@ public fun JetWhenExpression.canMergeWithNext(): Boolean { fun checkConditions(e1: JetWhenEntry, e2: JetWhenEntry): Boolean { if (e1.isElse() != e2.isElse()) return false - val conditions1 = e1.getConditions() - val conditions2 = e2.getConditions() + val conditions1 = e1.getConditions().toList() + val conditions2 = e2.getConditions().toList() return conditions1.size == conditions2.size && - (conditions1.iterator() zip conditions2.iterator()).all { pair -> JetPsiMatcher.checkElementMatch(pair.first, pair.second)} + (conditions1 zip_tmp conditions2).all { pair -> JetPsiMatcher.checkElementMatch(pair.first, pair.second)} } fun JetWhenEntry.declarationNames(): Set = getExpression()?.blockExpressionsOrSingle() - ?.filterIsInstance(javaClass()) + ?.filter { it is JetNamedDeclaration } ?.map { decl -> decl.getName() } - ?.filterNotNull()?.toHashSet() ?: Collections.emptySet() + ?.filterNotNull()?.toSet() ?: Collections.emptySet() fun checkBodies(e1: JetWhenEntry, e2: JetWhenEntry): Boolean { if (ContainerUtil.intersects(e1.declarationNames(), e2.declarationNames())) return false @@ -353,7 +354,7 @@ public fun JetWhenExpression.canMergeWithNext(): Boolean { val entries1 = getEntries() val entries2 = sibling.getEntries() - return entries1.size == entries2.size && (entries1.iterator() zip entries2.iterator()).all { pair -> + return entries1.size == entries2.size && (entries1 zip_tmp entries2).all { pair -> checkConditions(pair.first, pair.second) && checkBodies(pair.first, pair.second) } } @@ -373,7 +374,7 @@ public fun JetWhenExpression.mergeWithNext() { } val sibling = PsiTreeUtil.skipSiblingsForward(this, javaClass()) as JetWhenExpression - for ((entry1, entry2) in getEntries().iterator() zip sibling.getEntries().iterator()) { + for ((entry1, entry2) in getEntries() zip_tmp sibling.getEntries()) { entry1.getExpression() mergeWith entry2.getExpression() } diff --git a/idea/src/org/jetbrains/jet/plugin/util/JetPsiPrecedences.kt b/idea/src/org/jetbrains/jet/plugin/util/JetPsiPrecedences.kt index bfe018c2ebd..1e600e01137 100644 --- a/idea/src/org/jetbrains/jet/plugin/util/JetPsiPrecedences.kt +++ b/idea/src/org/jetbrains/jet/plugin/util/JetPsiPrecedences.kt @@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.parsing.JetExpressionParsing import java.util.HashMap import org.jetbrains.jet.lang.parsing.JetExpressionParsing.Precedence.* import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.utils.* public object JetPsiPrecedences { @@ -30,7 +31,7 @@ public object JetPsiPrecedences { private val precedence: Map { val builder = HashMap() - for ((i, record) in JetExpressionParsing.Precedence.values().withIndices()) { + for ((i, record) in JetExpressionParsing.Precedence.values().withIndices_tmp()) { for (elementType in record.getOperations().getTypes()) { builder[elementType] = i }