KT-1052: Add support for function calls (and, or, xor, not) on Boolean

js/js.tests/test/org/jetbrains/k2js/test/semantics/MiscTest.java

@@ -56,4 +56,8 @@ public final class MiscTest extends AbstractExpressionTest {
 
         }
     }
+
+    public void testKt1052() throws Exception {
+        checkFooBoxIsTrue("KT1052.kt");
+    }
 }

js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/Intrinsics.java

@@ -17,15 +17,17 @@
 package org.jetbrains.k2js.translate.intrinsic;
 
 import com.google.common.collect.Lists;
+import com.google.dart.compiler.backend.js.ast.JsBinaryOperator;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
-import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 import org.jetbrains.jet.lexer.JetToken;
+import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.k2js.translate.intrinsic.array.ArrayGetIntrinsic;
 import org.jetbrains.k2js.translate.intrinsic.array.ArraySetIntrinsic;
 import org.jetbrains.k2js.translate.intrinsic.primitive.*;
@@ -79,12 +81,27 @@ public final class Intrinsics {
         declareStringIntrinsics();
         declareTuplesIntrinsics();
         declareArrayIntrinsics();
+        declareBooleanIntrinsics();
         FunctionDescriptor intToDouble = getFunctionByName(library.getInt().getDefaultType().getMemberScope(), "toDouble");
         functionIntrinsics.put(intToDouble, ReturnReceiverIntrinsic.INSTANCE);
         FunctionDescriptor toStringFunction = getFunctionByName(library.getLibraryScope(), "toString");
         functionIntrinsics.put(toStringFunction, new BuiltInFunctionIntrinsic("toString"));
     }
 
+    private void declareBooleanIntrinsics() {
+        FunctionDescriptor andFunction = getFunctionByName(library.getBoolean().getDefaultType().getMemberScope(), "and");
+        functionIntrinsics.put(andFunction, PrimitiveBinaryOperationIntrinsic.newInstance(JetTokens.ANDAND));
+
+        FunctionDescriptor orFunction = getFunctionByName(library.getBoolean().getDefaultType().getMemberScope(), "or");
+        functionIntrinsics.put(orFunction, PrimitiveBinaryOperationIntrinsic.newInstance(JetTokens.OROR));
+
+        FunctionDescriptor notFunction = getFunctionByName(library.getBoolean().getDefaultType().getMemberScope(), "not");
+        functionIntrinsics.put(notFunction, PrimitiveUnaryOperationIntrinsic.newInstance(JetTokens.EXCL));
+
+        FunctionDescriptor xorFunction = getFunctionByName(library.getBoolean().getDefaultType().getMemberScope(), "xor");
+        functionIntrinsics.put(xorFunction, PrimitiveBinaryOperationIntrinsic.newInstance(JsBinaryOperator.BIT_XOR));
+    }
+
     @NotNull
     public Intrinsic getLengthPropertyIntrinsic() {
         return lengthPropertyIntrinsic;

js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/primitive/PrimitiveBinaryOperationIntrinsic.java

@@ -39,6 +39,12 @@ public final class PrimitiveBinaryOperationIntrinsic implements Intrinsic {
         return new PrimitiveBinaryOperationIntrinsic(operator);
     }
 
+    @NotNull
+    public static PrimitiveBinaryOperationIntrinsic newInstance(@NotNull JsBinaryOperator operator) {
+        return new PrimitiveBinaryOperationIntrinsic(operator);
+    }
+
+
     @NotNull
     private final JsBinaryOperator operator;
 

js/js.translator/testFiles/expression/misc/cases/KT1052.kt

@@ -0,0 +1,52 @@
+package foo
+
+fun box() : Boolean {
+
+    if (!true.and(true)) {
+        return false;
+    }
+    if (false.and(true)) {
+        return false;
+    }
+
+    if (!true.or(false)) {
+        return false;
+    }
+
+
+    if (false.or(false)) {
+        return false;
+    }
+
+
+    if (!true.or(true)) {
+        return false;
+    }
+
+
+    if (false.and(false)) {
+        return false;
+    }
+
+    if (false.xor(false)) {
+        return false;
+    }
+    if (!true.xor(false)) {
+            return false;
+        }
+
+    if (true.xor(true)) {
+            return false;
+        }
+
+        if (true.not()) {
+            return false;
+
+        }
+
+        if (!false.not()) {
+            return false;
+        }
+
+        return true;
+}