From d4b816ef5672bcd35f4e95185ab4fd1d241b3a15 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 3 May 2012 17:56:45 +0400 Subject: [PATCH] KT-1743 Analyze immutable local variables and parameters which are captured in closure #KT-1743 fixed --- .../jetbrains/jet/codegen/JetTypeMapper.java | 2 +- .../expressions/ExpressionTypingUtils.java | 2 +- .../UninitializedOrReassignedVariables.jet | 2 +- idea/testData/checker/infos/Autocasts.jet | 28 +++++++++---------- 4 files changed, 17 insertions(+), 17 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 68bf1345e79..d52036b4171 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -943,7 +943,7 @@ public class JetTypeMapper { } else if (descriptor instanceof VariableDescriptor) { Boolean aBoolean = bindingContext.get(BindingContext.MUST_BE_WRAPPED_IN_A_REF, (VariableDescriptor) descriptor); - if (aBoolean != null && aBoolean) { + if (aBoolean != null && aBoolean && ((VariableDescriptor) descriptor).isVar()) { JetType outType = ((VariableDescriptor) descriptor).getType(); return StackValue.sharedTypeForType(mapType(outType, MapTypeMode.VALUE)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 63a39a71045..8a582199333 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -134,7 +134,7 @@ public class ExpressionTypingUtils { public static void checkWrappingInRef(JetSimpleNameExpression expression, ExpressionTypingContext context) { VariableDescriptor variable = BindingContextUtils.extractVariableDescriptorIfAny(context.trace.getBindingContext(), expression, true); - if (variable != null && variable.isVar()) { + if (variable != null) { DeclarationDescriptor containingDeclaration = variable.getContainingDeclaration(); if (context.scope.getContainingDeclaration() != containingDeclaration && containingDeclaration instanceof CallableDescriptor) { context.trace.record(MUST_BE_WRAPPED_IN_A_REF, variable); diff --git a/compiler/testData/diagnostics/tests/UninitializedOrReassignedVariables.jet b/compiler/testData/diagnostics/tests/UninitializedOrReassignedVariables.jet index 5f5177eebdd..115c131f135 100644 --- a/compiler/testData/diagnostics/tests/UninitializedOrReassignedVariables.jet +++ b/compiler/testData/diagnostics/tests/UninitializedOrReassignedVariables.jet @@ -328,7 +328,7 @@ fun func() { val a = object { val x = b { - b = 4 + b = 4 $b = 3 } } diff --git a/idea/testData/checker/infos/Autocasts.jet b/idea/testData/checker/infos/Autocasts.jet index 75c9df003e7..656518e9b3d 100644 --- a/idea/testData/checker/infos/Autocasts.jet +++ b/idea/testData/checker/infos/Autocasts.jet @@ -184,31 +184,31 @@ fun vars(a: Any?) { b = a } } -fun tuples(a: Any?) { - if (a != null) { - val s: #(Any, String) = #(a, a) +fun tuples(a: Any?) { + if (a != null) { + val s: #(Any, String) = #(a, a) } - if (a is String) { - val s: #(Any, String) = #(a, a) + if (a is String) { + val s: #(Any, String) = #(a, a) } fun illegalTupleReturnType(): #(Any, String) = #(a, a) - if (a is String) { - fun legalTupleReturnType(): #(Any, String) = #(a, a) + if (a is String) { + fun legalTupleReturnType(): #(Any, String) = #(a, a) } val illegalFunctionLiteral: Function0 = { a } val illegalReturnValueInFunctionLiteral: Function0 = { (): Int -> a } - if (a is Int) { - val legalFunctionLiteral: Function0 = { a } - val alsoLegalFunctionLiteral: Function0 = { (): Int -> a } + if (a is Int) { + val legalFunctionLiteral: Function0 = { a } + val alsoLegalFunctionLiteral: Function0 = { (): Int -> a } } } -fun returnFunctionLiteralBlock(a: Any?): Function0 { - if (a is Int) return { a } +fun returnFunctionLiteralBlock(a: Any?): Function0 { + if (a is Int) return { a } else return { 1 } } -fun returnFunctionLiteral(a: Any?): Function0 = - if (a is Int) { (): Int -> a } +fun returnFunctionLiteral(a: Any?): Function0 = + if (a is Int) { (): Int -> a } else { () -> 1 } fun illegalTupleReturnType(a: Any): #(Any, String) = #(a, a)