KT-852 Apply sure() call for expressions inside polyadic expression

src/org/jetbrains/jet/j2k/Converter.java

@@ -601,9 +601,9 @@ public class Converter {
 
   @NotNull
   public static List<String> createConversions(@NotNull PsiCallExpression expression) {
-    List<String> conversions = new LinkedList<String>();
     PsiExpressionList argumentList = expression.getArgumentList();
     PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{};
+    List<String> conversions = new LinkedList<String>();
     //noinspection UnusedDeclaration
     for (final PsiExpression a : arguments) {
       conversions.add("");
@@ -628,19 +628,41 @@ public class Converter {
     return conversions;
   }
 
+  @NotNull
+  public static List<String> createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) {
+    PsiExpression[] arguments = expression.getOperands();
+    int length = arguments.length;
+    List<String> conversions = new LinkedList<String>();
+
+    List<PsiType> expectedTypes = Collections.nCopies(length, expectedType);
+    List<PsiType> actualTypes = new LinkedList<PsiType>();
+
+    for (PsiExpression e : arguments)
+      actualTypes.add(e.getType());
+
+    assert actualTypes.size() == expectedTypes.size() : "The type list must have the same length";
+
+    for (int i = 0; i < actualTypes.size(); i++)
+      conversions.add(i, createConversionForExpression(arguments[i], expectedTypes.get(i)));
+
+    return conversions;
+  }
+
   @NotNull
   private static String createConversionForExpression(@Nullable PsiExpression expression, @NotNull PsiType expectedType) {
     String conversion = "";
     if (expression != null) {
       PsiType actualType = expression.getType();
-      if (actualType != null) {
-        if (Node.PRIMITIVE_TYPES.contains(actualType.getCanonicalText()) && (expression instanceof PsiReferenceExpression
-          && ((PsiReferenceExpression) expression).isQualified() || expression instanceof PsiMethodCallExpression)
-          && expressionToExpression(expression).toKotlin().contains("?."))
-          conversion += ".sure()";
+      boolean isPrimitiveTypeOrNull = actualType == null || Node.PRIMITIVE_TYPES.contains(actualType.getCanonicalText());
+      boolean isRef = (expression instanceof PsiReferenceExpression && ((PsiReferenceExpression) expression).isQualified() || expression instanceof PsiMethodCallExpression);
+      boolean containsQuestDot = expressionToExpression(expression).toKotlin().contains("?.");
+
+      if (isPrimitiveTypeOrNull && isRef && containsQuestDot)
+        conversion += ".sure()";
+
+      if (actualType != null)
         if (isConversionNeeded(actualType, expectedType))
           conversion += getPrimitiveTypeConversion(expectedType.getCanonicalText());
-      }
     }
     return conversion;
   }

src/org/jetbrains/jet/j2k/ast/BinaryExpression.java

@@ -1,6 +1,10 @@
 package org.jetbrains.jet.j2k.ast;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.j2k.util.AstUtil;
+
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * @author ignatov
@@ -9,16 +13,23 @@ public class BinaryExpression extends Expression {
   private final Expression myLeft;
   private final Expression myRight;
   private final String myOp;
+  private final List<String> myConversions;
 
   public BinaryExpression(Expression left, Expression right, String op) {
+    this(left, right, op, Arrays.asList("", ""));
+  }
+
+  public BinaryExpression(Expression left, Expression right, String op, List<String> conversions) {
     myLeft = left;
     myRight = right;
     myOp = op;
+    myConversions = conversions;
   }
 
   @NotNull
   @Override
   public String toKotlin() {
-    return "(" + myLeft.toKotlin() + SPACE + myOp + SPACE + myRight.toKotlin() + ")";
+    List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(Arrays.asList(myLeft, myRight)), myConversions);
+    return "(" + AstUtil.join(expressionsWithConversions, SPACE + myOp + SPACE) + ")";
   }
 }

src/org/jetbrains/jet/j2k/ast/PolyadicExpression.java

@@ -11,16 +11,19 @@ import java.util.List;
 public class PolyadicExpression extends Expression {
   private final List<Expression> myExpressions;
   private final String myToken;
+  private final List<String> myConversions;
 
-  public PolyadicExpression(List<Expression> expressions, String token) {
+  public PolyadicExpression(List<Expression> expressions, String token, List<String> conversions) {
     super();
     myExpressions = expressions;
     myToken = token;
+    myConversions = conversions;
   }
 
   @NotNull
   @Override
   public String toKotlin() {
-    return "(" + AstUtil.joinNodes(myExpressions, SPACE + myToken + SPACE) + ")";
+    List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myExpressions), myConversions);
+    return "(" + AstUtil.join(expressionsWithConversions, SPACE + myToken + SPACE) + ")";
   }
 }

src/org/jetbrains/jet/j2k/util/AstUtil.java

@@ -2,7 +2,6 @@ package org.jetbrains.jet.j2k.util;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.j2k.ast.Expression;
 import org.jetbrains.jet.j2k.ast.INode;
 
 import java.util.LinkedList;
@@ -57,10 +56,10 @@ public class AstUtil {
   }
 
   @NotNull
-  public static List<String> createListWithEmptyString(@NotNull final List<Expression> arguments) {
+  public static <T> List<String> createListWithEmptyString(@NotNull final List<T> arguments) {
     final List<String> conversions = new LinkedList<String>();
     //noinspection UnusedDeclaration
-    for (Expression argument : arguments) conversions.add("");
+    for (T argument : arguments) conversions.add("");
     return conversions;
   }
 

src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java

@@ -125,7 +125,8 @@ public class ExpressionVisitor extends StatementVisitor {
         new BinaryExpression(
           expressionToExpression(expression.getLOperand()),
           expressionToExpression(expression.getROperand()),
-          getOperatorString(expression.getOperationSign().getTokenType())
+          getOperatorString(expression.getOperationSign().getTokenType()),
+          createConversions(expression, PsiType.BOOLEAN)
         );
   }
 
@@ -449,7 +450,8 @@ public class ExpressionVisitor extends StatementVisitor {
     super.visitPolyadicExpression(expression);
     myResult = new PolyadicExpression(
       expressionsToExpressionList(expression.getOperands()),
-      getOperatorString(expression.getOperationTokenType())
+      getOperatorString(expression.getOperationTokenType()),
+      createConversions(expression, PsiType.BOOLEAN)
     );
   }
 }

testData/ast/issues/file/kt-809-string.jav

@@ -1,7 +1,7 @@
 package demo;
 
 class Container {
-  String myString = 1;
+  String myString = "1";
 }
 
 class One {

testData/ast/issues/file/kt-852.jav

@@ -0,0 +1,16 @@
+package demo;
+
+class Test {
+  String test() {
+    String s1 = "";
+    String s2 = "";
+    String s3 = "";
+    if (s1.isEmpty() && s2.isEmpty())
+      return "OK";
+
+    if (s1.isEmpty() && s2.isEmpty() && s3.isEmpty())
+      return "OOOK";
+
+    return "";
+  }
+}

testData/ast/issues/file/kt-852.kt

@@ -0,0 +1,13 @@
+package demo
+open class Test() {
+open fun test() : String? {
+var s1 : String? = ""
+var s2 : String? = ""
+var s3 : String? = ""
+if (((s1?.isEmpty()).sure() && (s2?.isEmpty()).sure()))
+return "OK"
+if (((s1?.isEmpty()).sure() && (s2?.isEmpty()).sure() && (s3?.isEmpty()).sure()))
+return "OOOK"
+return ""
+}
+}