refactoring intrinsics

translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java

@@ -23,7 +23,6 @@ public final class StringTemplateTranslator extends AbstractTranslator {
         return (new StringTemplateTranslator(expression, context).translate());
     }
 
-
     @NotNull
     private final JetStringTemplateExpression expression;
 

translator/src/org/jetbrains/k2js/translate/intrinsic/IntrinsicDeclarationVisitor.java

@@ -1,39 +0,0 @@
-package org.jetbrains.k2js.translate.intrinsic;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-
-/**
- * @author Talanov Pavel
- */
-public final class IntrinsicDeclarationVisitor extends DeclarationDescriptorVisitor<Void, Void> {
-
-    @NotNull
-    private final Intrinsics intrinsics;
-
-    /*package*/ IntrinsicDeclarationVisitor(@NotNull Intrinsics intrinsics) {
-        this.intrinsics = intrinsics;
-    }
-
-    @Override
-    public Void visitClassDescriptor(@NotNull ClassDescriptor descriptor, @Nullable Void nothing) {
-        for (DeclarationDescriptor memberDescriptor :
-                descriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
-            //noinspection NullableProblems
-            memberDescriptor.accept(this, null);
-        }
-        return null;
-    }
-
-    @Override
-    public Void visitFunctionDescriptor(@NotNull FunctionDescriptor descriptor, @Nullable Void nothing) {
-        if (!intrinsics.isIntrinsic(descriptor)) {
-            intrinsics.declareOperatorIntrinsic(descriptor);
-        }
-        return null;
-    }
-}

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

@@ -1,7 +1,10 @@
 package org.jetbrains.k2js.translate.intrinsic;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lexer.JetToken;
@@ -50,7 +53,7 @@ public final class Intrinsics {
     }
 
     private void declareOperatorIntrinsics() {
-        IntrinsicDeclarationVisitor visitor = new IntrinsicDeclarationVisitor(this);
+        IntrinsicDeclarationVisitor visitor = new IntrinsicDeclarationVisitor();
         for (DeclarationDescriptor descriptor : library.getLibraryScope().getAllDescriptors()) {
             //noinspection NullableProblems
             descriptor.accept(visitor, null);
@@ -69,56 +72,6 @@ public final class Intrinsics {
         functionIntrinsics.put(setFunction, ArraySetIntrinsic.INSTANCE);
     }
 
-    /*package*/ void declareOperatorIntrinsic(@NotNull FunctionDescriptor descriptor) {
-        addCompareToIntrinsics(descriptor);
-        addEqualsIntrinsics(descriptor);
-        addUnaryIntrinsics(descriptor);
-        addBinaryIntrinsics(descriptor);
-        addRangeToIntrinsics(descriptor);
-    }
-
-    private void addRangeToIntrinsics(@NotNull FunctionDescriptor descriptor) {
-        String functionName = descriptor.getName();
-        if (functionName.equals("rangeTo")) {
-            functionIntrinsics.put(descriptor, PrimitiveRangeToIntrinsic.newInstance());
-        }
-    }
-
-    private void addCompareToIntrinsics(@NotNull FunctionDescriptor descriptor) {
-        String functionName = descriptor.getName();
-        if (functionName.equals(COMPARE_TO)) {
-            compareToIntrinsics.put(descriptor, PrimitiveCompareToIntrinsic.newInstance());
-        }
-    }
-
-    private void addEqualsIntrinsics(@NotNull FunctionDescriptor descriptor) {
-        String functionName = descriptor.getName();
-        if (functionName.equals(EQUALS)) {
-            equalsIntrinsics.put(descriptor, PrimitiveEqualsIntrinsic.newInstance());
-        }
-    }
-
-    private void addUnaryIntrinsics(@NotNull FunctionDescriptor descriptor) {
-        String functionName = descriptor.getName();
-        JetToken token = UNARY_OPERATION_NAMES.inverse().get(functionName);
-        if (token == null) return;
-        boolean isUnary = !DescriptorUtils.hasParameters(descriptor);
-        if (!isUnary) return;
-        functionIntrinsics.put(descriptor, PrimitiveUnaryOperationIntrinsic.newInstance(token));
-    }
-
-    //TODO: refactor
-    private void addBinaryIntrinsics(@NotNull FunctionDescriptor descriptor) {
-        String functionName = descriptor.getName();
-        boolean isUnary = !DescriptorUtils.hasParameters(descriptor);
-        if (isUnary) return;
-        JetToken token = BINARY_OPERATION_NAMES.inverse().get(functionName);
-        if (token == null) return;
-        //TODO: implement contains intrinsic
-        if (!OperatorTable.hasCorrespondingBinaryOperator(token)) return;
-        functionIntrinsics.put(descriptor, PrimitiveBinaryOperationIntrinsic.newInstance(token));
-    }
-
     public boolean isIntrinsic(@NotNull DeclarationDescriptor descriptor) {
         //NOTE: that if we want to add other intrinsics we have to modify this method
         if (descriptor instanceof FunctionDescriptor) {
@@ -144,4 +97,72 @@ public final class Intrinsics {
     public EqualsIntrinsic getEqualsIntrinsic(@NotNull FunctionDescriptor descriptor) {
         return equalsIntrinsics.get(descriptor.getOriginal());
     }
+
+    private final class IntrinsicDeclarationVisitor extends DeclarationDescriptorVisitor<Void, Void> {
+
+        @Override
+        public Void visitClassDescriptor(@NotNull ClassDescriptor descriptor, @Nullable Void nothing) {
+            for (DeclarationDescriptor memberDescriptor :
+                    descriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
+                //noinspection NullableProblems
+                memberDescriptor.accept(this, null);
+            }
+            return null;
+        }
+
+        @Override
+        public Void visitFunctionDescriptor(@NotNull FunctionDescriptor descriptor, @Nullable Void nothing) {
+            if (!isIntrinsic(descriptor)) {
+                declareOperatorIntrinsic(descriptor);
+            }
+            return null;
+        }
+
+
+        /*package*/ void declareOperatorIntrinsic(@NotNull FunctionDescriptor descriptor) {
+            tryResolveAsEqualsCompareToOrRangeToIntrinsic(descriptor);
+            tryResolveAsUnaryIntrinsics(descriptor);
+            tryResolveAsBinaryIntrinsics(descriptor);
+        }
+
+        private void tryResolveAsEqualsCompareToOrRangeToIntrinsic(@NotNull FunctionDescriptor descriptor) {
+            String functionName = descriptor.getName();
+            if (functionName.equals(COMPARE_TO)) {
+                compareToIntrinsics.put(descriptor, PrimitiveCompareToIntrinsic.newInstance());
+            }
+            if (functionName.equals(EQUALS)) {
+                equalsIntrinsics.put(descriptor, PrimitiveEqualsIntrinsic.newInstance());
+            }
+            if (functionName.equals("rangeTo")) {
+                functionIntrinsics.put(descriptor, PrimitiveRangeToIntrinsic.newInstance());
+            }
+        }
+
+        private void tryResolveAsUnaryIntrinsics(@NotNull FunctionDescriptor descriptor) {
+            String functionName = descriptor.getName();
+            JetToken token = UNARY_OPERATION_NAMES.inverse().get(functionName);
+
+            if (token == null) return;
+            if (!isUnaryOperation(descriptor)) return;
+
+            functionIntrinsics.put(descriptor, PrimitiveUnaryOperationIntrinsic.newInstance(token));
+        }
+
+        private void tryResolveAsBinaryIntrinsics(@NotNull FunctionDescriptor descriptor) {
+            String functionName = descriptor.getName();
+
+            if (isUnaryOperation(descriptor)) return;
+
+            JetToken token = BINARY_OPERATION_NAMES.inverse().get(functionName);
+            if (token == null) return;
+
+            if (!OperatorTable.hasCorrespondingBinaryOperator(token)) return;
+            functionIntrinsics.put(descriptor, PrimitiveBinaryOperationIntrinsic.newInstance(token));
+        }
+
+        private boolean isUnaryOperation(@NotNull FunctionDescriptor descriptor) {
+            return !DescriptorUtils.hasParameters(descriptor);
+        }
+    }
+
 }

translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java

@@ -37,6 +37,12 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
         return (new BinaryOperationTranslator(expression, context).translate());
     }
 
+    @NotNull
+    private final JetBinaryExpression expression;
+
+    @Nullable
+    private final FunctionDescriptor operationDescriptor;
+
     private BinaryOperationTranslator(@NotNull JetBinaryExpression expression,
                                       @NotNull TranslationContext context) {
         super(context);
@@ -45,12 +51,6 @@ public final class BinaryOperationTranslator extends AbstractTranslator {
                 getFunctionDescriptorForOperationExpression(context().bindingContext(), expression);
     }
 
-    @NotNull
-    private final JetBinaryExpression expression;
-
-    @Nullable
-    private final FunctionDescriptor operationDescriptor;
-
     @NotNull
     private JsExpression translate() {
         if (isAssignmentOperator(expression)) {

translator/src/org/jetbrains/k2js/translate/operation/CompareToTranslator.java

@@ -45,9 +45,6 @@ public final class CompareToTranslator extends AbstractTranslator {
     @NotNull
     private final JetBinaryExpression expression;
 
-    @NotNull
-    private final JetToken operationToken;
-
     @NotNull
     private final FunctionDescriptor descriptor;
 
@@ -59,8 +56,7 @@ public final class CompareToTranslator extends AbstractTranslator {
                 getFunctionDescriptorForOperationExpression(context.bindingContext(), expression);
         assert functionDescriptor != null : "CompareTo should always have a descriptor";
         this.descriptor = functionDescriptor;
-        this.operationToken = getOperationToken(expression);
+        assert (OperatorConventions.COMPARISON_OPERATIONS.contains(getOperationToken(expression)));
-        assert (OperatorConventions.COMPARISON_OPERATIONS.contains(operationToken));
     }
 
     @NotNull
@@ -73,7 +69,7 @@ public final class CompareToTranslator extends AbstractTranslator {
 
     @NotNull
     private JsExpression overloadedCompareTo() {
-        JsBinaryOperator correspondingOperator = OperatorTable.getBinaryOperator(operationToken);
+        JsBinaryOperator correspondingOperator = OperatorTable.getBinaryOperator(getOperationToken(expression));
         JsExpression methodCall = CallTranslator.translate(expression, context());
         return new JsBinaryOperation(correspondingOperator, methodCall, TranslationUtils.zeroLiteral(context()));
     }