From 5b1d6052d5707ce44eca143cae37742be0dd9b4a Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Sun, 23 Oct 2011 15:20:54 +0200 Subject: [PATCH] small bug-fix --- .../jet/codegen/ExpressionCodegen.java | 6 +- .../codegen/ImplementationBodyCodegen.java | 5 +- .../lang/types/expressions/LabelResolver.java | 6 ++ examples/src/collections/IIterator.kt | 71 ++++++++++++++++++- 4 files changed, 82 insertions(+), 6 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index baddde3e04c..775027e40c6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -598,8 +598,10 @@ public class ExpressionCodegen extends JetVisitor { } for (DeclarationDescriptor descriptor : closureCodegen.closure.keySet()) { - final Type sharedVarType = getSharedVarType(descriptor); - consArgTypes.add(sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType())); + Type sharedVarType = getSharedVarType(descriptor); + if(sharedVarType == null) + sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType()); + consArgTypes.add(sharedVarType); final EnclosedValueDescriptor valueDescriptor = closureCodegen.closure.get(descriptor); valueDescriptor.getOuterValue().put(sharedVarType, v); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 5dd9bf9f711..97ea22a1428 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -342,7 +342,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Map closure = context.closure.closure; int k = 0; for (DeclarationDescriptor varDescr : closure.keySet()) { - final Type sharedVarType = context.closure.exprContext.getSharedVarType(varDescr); + Type sharedVarType = context.closure.exprContext.getSharedVarType(varDescr); + if(sharedVarType == null) { + sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) varDescr).getOutType()); + } iv.load(0, JetTypeMapper.TYPE_OBJECT); iv.load(firstClosureIndex + k, StackValue.refType(sharedVarType)); iv.putfield(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$" + (k+1), sharedVarType.getDescriptor()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java index bcf5b82dcd3..faec5d1a359 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java @@ -119,6 +119,12 @@ public class LabelResolver { else if (declarationDescriptor instanceof FunctionDescriptor) { FunctionDescriptor functionDescriptor = (FunctionDescriptor) declarationDescriptor; thisReceiver = functionDescriptor.getReceiverParameter(); + if(!thisReceiver.exists()) { + DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration(); + if(containingDeclaration instanceof ClassDescriptor) { + thisReceiver = ((ClassDescriptor)containingDeclaration).getImplicitReceiver(); + } + } } else { throw new UnsupportedOperationException(); // TODO diff --git a/examples/src/collections/IIterator.kt b/examples/src/collections/IIterator.kt index 0acccda5f47..5677a6fc407 100644 --- a/examples/src/collections/IIterator.kt +++ b/examples/src/collections/IIterator.kt @@ -1,18 +1,83 @@ namespace jet.collections.iterator +import java.util.NoSuchElementException + trait IIterator { fun next() : T val hasNext : Boolean + inline fun foldLeft(init: R, operation: fun(accumulated: R, element: T) : R) : R { + while(hasNext) + init = operation(init, next()) + return init + } + + inline fun foldLeft(init: R, operation: fun(accumulated: R, index: Int, element: T) : R) : R { + var k = 0 + while(hasNext) + init = operation(init, k++, next()) + return init + } + inline fun foreach(operation: fun(element: T) : Unit) = while(hasNext) operation(next()) + inline fun foreach(operation: fun(index: Int, element: T) : Unit) : Unit { + var k = 0 + while(hasNext) + operation(k++, next()) + } + inline fun map(transform: fun(element: T) : R) : IIterator { - val that = this return object : IIterator { - override fun next() : R = transform(that.next()) + override fun next() : R = transform(this@map.next()) override val hasNext : Boolean - get() = that.hasNext + get() = this@map.hasNext + } + } + + inline fun plus(other: IIterator) : IIterator = + object : IIterator { + override fun next() : T = if(this@plus.hasNext) this@plus.next() else other.next() + + override val hasNext : Boolean + get() = this@plus.hasNext || other.hasNext + } + + inline fun filter(condition: fun(element: T) : Boolean) : IIterator { + return object : IIterator { + private var _next : T = null + private var _lookedAhead : Boolean = false + private var _hasNext : Boolean = false + + private fun lookAhead() : Boolean { + if(!_lookedAhead) { + _lookedAhead = true + while(this@filter.hasNext) { + _next = this@filter.next() + if(condition(_next)) { + _hasNext = true + return true + } + } + } + return _hasNext + } + + override fun next() : T { + lookAhead() + _lookedAhead = false + if(_hasNext) { + val res = _next + _next = null + _hasNext = false + return res + } + throw NoSuchElementException() + } + + override val hasNext : Boolean + get() = lookAhead() } } /*