path: root/plugins/typeMigration/src/com/intellij/refactoring/typeMigration/rules/AtomicConversionRule.java

/*
 * User: anna
 * Date: 18-Aug-2009
 */
package com.intellij.refactoring.typeMigration.rules;

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.Comparing;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiDiamondTypeUtil;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiUtil;
import com.intellij.psi.util.TypeConversionUtil;
import com.intellij.refactoring.typeMigration.TypeConversionDescriptor;
import com.intellij.refactoring.typeMigration.TypeConversionDescriptorBase;
import com.intellij.refactoring.typeMigration.TypeMigrationLabeler;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.concurrent.atomic.*;

public class AtomicConversionRule extends TypeConversionRule {
  private static final Logger LOG = Logger.getInstance("#" + AtomicConversionRule.class.getName());


  @Override
  public TypeConversionDescriptorBase findConversion(PsiType from,
                                                 PsiType to,
                                                 PsiMember member,
                                                 PsiExpression context,
                                                 TypeMigrationLabeler labeler) {
    if (to instanceof PsiClassType && isAtomicTypeMigration(from, (PsiClassType)to, context)) {
      return findDirectConversion(context, to, from);
    }
    else if (from instanceof PsiClassType && isAtomicTypeMigration(to, (PsiClassType)from, context)) {
      return findReverseConversion(context);
    }
    return null;
  }

  private static boolean isAtomicTypeMigration(PsiType from, PsiClassType to, PsiExpression context) {
    if (from == PsiType.INT && to.getCanonicalText().equals(AtomicInteger.class.getName())) {
      return true;
    }
    if (from.equals(PsiType.INT.createArrayType()) && to.getCanonicalText().equals(AtomicIntegerArray.class.getName())) {
      return true;
    }
    if (from == PsiType.LONG && to.getCanonicalText().equals(AtomicLong.class.getName())) {
      return true;
    }
    if (from.equals(PsiType.LONG.createArrayType()) && to.getCanonicalText().equals(AtomicLongArray.class.getName())) {
      return true;
    }
    if (from == PsiType.BOOLEAN && to.getCanonicalText().equals(AtomicBoolean.class.getName())) {
      return true;
    }
    final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(to);
    final PsiClass atomicClass = resolveResult.getElement();

    if (atomicClass != null) {
      final String typeQualifiedName = atomicClass.getQualifiedName();
      if (!Comparing.strEqual(typeQualifiedName, AtomicReference.class.getName()) &&
          !Comparing.strEqual(typeQualifiedName, AtomicReferenceArray.class.getName())) {
        return false;
      }
      final PsiTypeParameter[] typeParameters = atomicClass.getTypeParameters();
      if (typeParameters.length != 1) return false;
      final PsiType toTypeParameterValue = resolveResult.getSubstitutor().substitute(typeParameters[0]);
      if (toTypeParameterValue != null) {
        if (from.getDeepComponentType() instanceof PsiPrimitiveType) {
          final PsiPrimitiveType unboxedInitialType = PsiPrimitiveType.getUnboxedType(toTypeParameterValue);
          if (unboxedInitialType != null) {
            return TypeConversionUtil.areTypesConvertible(from.getDeepComponentType(), unboxedInitialType);
          }
        }
        else {
          return TypeConversionUtil.isAssignable(from.getDeepComponentType(), PsiUtil.captureToplevelWildcards(toTypeParameterValue, context));
        }
      }
    }
    return false;
  }

  @Nullable
  public static TypeConversionDescriptor findDirectConversion(PsiElement context, PsiType to, PsiType from) {
    final PsiClass toTypeClass = PsiUtil.resolveClassInType(to);
    LOG.assertTrue(toTypeClass != null);
    final String qualifiedName = toTypeClass.getQualifiedName();
    if (qualifiedName != null) {
      if (qualifiedName.equals(AtomicInteger.class.getName()) || qualifiedName.equals(AtomicLong.class.getName())) {

        if (context instanceof PsiPostfixExpression) {
          final IElementType operationSign = ((PsiPostfixExpression)context).getOperationTokenType();
          if (operationSign == JavaTokenType.MINUSMINUS) {
            return new TypeConversionDescriptor("$qualifier$--", "$qualifier$.getAndDecrement()");
          }
          if (operationSign == JavaTokenType.PLUSPLUS) {
            return new TypeConversionDescriptor("$qualifier$++", "$qualifier$.getAndIncrement()");
          }

        }
        else if (context instanceof PsiPrefixExpression) {
          final IElementType operationSign = ((PsiPrefixExpression)context).getOperationTokenType();
          if (operationSign == JavaTokenType.MINUSMINUS) {
            return new TypeConversionDescriptor("--$qualifier$", "$qualifier$.decrementAndGet()");
          }
          if (operationSign == JavaTokenType.PLUSPLUS) {
            return new TypeConversionDescriptor("++$qualifier$", "$qualifier$.incrementAndGet()");
          }

        }
        else if (context instanceof PsiAssignmentExpression) {
          final PsiJavaToken signToken = ((PsiAssignmentExpression)context).getOperationSign();
          final IElementType operationSign = signToken.getTokenType();
          final String sign = signToken.getText();
          if (operationSign == JavaTokenType.PLUSEQ || operationSign == JavaTokenType.MINUSEQ) {
            return new TypeConversionDescriptor("$qualifier$ " + sign + " $val$", "$qualifier$.getAndAdd(" +
                                                                                  (operationSign == JavaTokenType.MINUSEQ ? "-" : "") +
                                                                                  "($val$))");
          }
        }
      }
      else if (qualifiedName.equals(AtomicIntegerArray.class.getName()) || qualifiedName.equals(AtomicLongArray.class.getName())) {
        PsiElement parentExpression = context.getParent();
        if (parentExpression instanceof PsiPostfixExpression) {
          final IElementType operationSign = ((PsiPostfixExpression)parentExpression).getOperationTokenType();
          if (operationSign == JavaTokenType.MINUSMINUS) {
            return new TypeConversionDescriptor("$qualifier$[$idx$]--", "$qualifier$.getAndDecrement($idx$)",
                                                (PsiExpression)parentExpression);
          }
          if (operationSign == JavaTokenType.PLUSPLUS) {
            return new TypeConversionDescriptor("$qualifier$[$idx$]++", "$qualifier$.getAndIncrement($idx$)",
                                                (PsiExpression)parentExpression);
          }

        }
        else if (parentExpression instanceof PsiPrefixExpression) {
          final IElementType operationSign = ((PsiPrefixExpression)parentExpression).getOperationTokenType();
          if (operationSign == JavaTokenType.MINUSMINUS) {
            return new TypeConversionDescriptor("--$qualifier$[$idx$]", "$qualifier$.decrementAndGet($idx$)",
                                                (PsiExpression)parentExpression);
          }
          if (operationSign == JavaTokenType.PLUSPLUS) {
            return new TypeConversionDescriptor("++$qualifier$[$idx$]", "$qualifier$.incrementAndGet($idx$)",
                                                (PsiExpression)parentExpression);
          }

        }
        else if (parentExpression instanceof PsiAssignmentExpression) {
          final PsiJavaToken signToken = ((PsiAssignmentExpression)parentExpression).getOperationSign();
          final IElementType operationSign = signToken.getTokenType();
          final String sign = signToken.getText();
          if (operationSign == JavaTokenType.PLUSEQ || operationSign == JavaTokenType.MINUSEQ) {
            return new TypeConversionDescriptor("$qualifier$[$idx$] " + sign + " $val$", "$qualifier$.getAndAdd($idx$, " +
                                                                                         (operationSign == JavaTokenType.MINUSEQ
                                                                                          ? "-"
                                                                                          : "") +
                                                                                         "($val$))", (PsiExpression)parentExpression);
          }
        }
      }
    }
    return from instanceof PsiArrayType
           ? findDirectConversionForAtomicReferenceArray(context, to, from)
           : findDirectConversionForAtomicReference(context, to, from);
  }

  @Nullable
  private static TypeConversionDescriptor findDirectConversionForAtomicReference(PsiElement context, PsiType to, PsiType from) {
    final PsiElement parent = context.getParent();
    if (parent instanceof PsiAssignmentExpression) {
      final IElementType operationSign = ((PsiAssignmentExpression)parent).getOperationTokenType();
      if (operationSign == JavaTokenType.EQ) {
        return new TypeConversionDescriptor("$qualifier$ = $val$", "$qualifier$.set($val$)", (PsiAssignmentExpression)parent);
      }
    }

    if (context instanceof PsiReferenceExpression) {
      final PsiExpression qualifierExpression = ((PsiReferenceExpression)context).getQualifierExpression();
      final PsiExpression expression = context.getParent() instanceof PsiMethodCallExpression && qualifierExpression != null
                                       ? qualifierExpression
                                       : (PsiExpression)context;
      return new TypeConversionDescriptor("$qualifier$", "$qualifier$.get()", expression);
    }
    else if (context instanceof PsiAssignmentExpression) {
      final PsiJavaToken signToken = ((PsiAssignmentExpression)context).getOperationSign();
      final IElementType operationSign = signToken.getTokenType();
      final String sign = signToken.getText();
      if (parent instanceof PsiExpressionStatement) {
        if (operationSign == JavaTokenType.EQ) {
          final PsiExpression lExpression = ((PsiAssignmentExpression)context).getLExpression();
          if (lExpression instanceof PsiReferenceExpression) {
            final PsiElement element = ((PsiReferenceExpression)lExpression).resolve();
            if (element instanceof PsiVariable && ((PsiVariable)element).hasModifierProperty(PsiModifier.FINAL)) {
              return wrapWithNewExpression(to, from, ((PsiAssignmentExpression)context).getRExpression(), element);
            }
          }
          return new TypeConversionDescriptor("$qualifier$ = $val$", "$qualifier$.set($val$)");
        }
        else {
          return new TypeConversionDescriptor("$qualifier$" + sign + "$val$", "$qualifier$.set(" +
                                                                              getBoxedWrapper(from, to, "$qualifier$.get() " +
                                                                                                        sign.charAt(0) +
                                                                                                        " $val$") +
                                                                              ")");
        }
      } //else should be a conflict
    }
    else if (context instanceof PsiPostfixExpression) {
      final String sign = ((PsiPostfixExpression)context).getOperationSign().getText();
      return new TypeConversionDescriptor("$qualifier$" + sign, "$qualifier$.getAndSet(" +
                                                                getBoxedWrapper(from, to, "$qualifier$.get() " + sign.charAt(0) + " 1") +
                                                                ")");
    }
    else if (context instanceof PsiPrefixExpression) {
      final PsiJavaToken operationSign = ((PsiPrefixExpression)context).getOperationSign();
      if (operationSign.getTokenType() == JavaTokenType.EXCL) {
        return new TypeConversionDescriptor("!$qualifier$", "!$qualifier$.get()");
      }
      final String sign = operationSign.getText();
      return new TypeConversionDescriptor(sign + "$qualifier$", "$qualifier$.set(" +  //todo reject?
                                                                getBoxedWrapper(from, to, "$qualifier$.get() " + sign.charAt(0) + " 1") +
                                                                ")");
    } else if (context instanceof PsiBinaryExpression) {
      final String sign = ((PsiBinaryExpression)context).getOperationSign().getText();
      return new TypeConversionDescriptor("$qualifier$" + sign + "$val$", "$qualifier$.get() " + sign + " $val$");
    }

    if (parent instanceof PsiVariable) {
      return wrapWithNewExpression(to, from, null, parent);
    }
    return null;
  }

  public static TypeConversionDescriptor wrapWithNewExpression(PsiType to, PsiType from, @Nullable PsiExpression expression, PsiElement context) {
    final String typeText = PsiDiamondTypeUtil.getCollapsedType(to, context);
    final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(to);
    final PsiClass atomicClass = resolveResult.getElement();
    LOG.assertTrue(atomicClass != null);
    final PsiTypeParameter[] typeParameters = atomicClass.getTypeParameters();
    if (typeParameters.length == 1) {
      final PsiType initial = resolveResult.getSubstitutor().substitute(typeParameters[0]);
      final PsiPrimitiveType unboxedInitialType = PsiPrimitiveType.getUnboxedType(initial);
      if (unboxedInitialType != null) {
        LOG.assertTrue(initial != null);
        if (from instanceof PsiPrimitiveType) {
          final PsiClassType boxedFromType = ((PsiPrimitiveType)from).getBoxedType(atomicClass);
          LOG.assertTrue(boxedFromType != null);
          if (!TypeConversionUtil.isAssignable(initial, boxedFromType)) {
            return new TypeConversionDescriptor("$val$", "new " + typeText + "((" + unboxedInitialType.getCanonicalText() + ")$val$)", expression);
          }
        }
      }
    }
    return new TypeConversionDescriptor("$val$", "new " + typeText + "($val$)", expression);
  }

  @Nullable
  private static TypeConversionDescriptor findDirectConversionForAtomicReferenceArray(PsiElement context, PsiType to, PsiType from) {
    LOG.assertTrue(from instanceof PsiArrayType);
    from = ((PsiArrayType)from).getComponentType();
    final PsiElement parent = context.getParent();
    final PsiElement parentParent = parent.getParent();

    if (parent instanceof PsiAssignmentExpression) {
      final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)parent;
      final IElementType operationSign = assignmentExpression.getOperationTokenType();
      final String sign = assignmentExpression.getOperationSign().getText();
      if (context instanceof PsiArrayAccessExpression) {
        if (parentParent instanceof PsiExpressionStatement) {
          if (assignmentExpression.getLExpression() == context) {
            if (operationSign == JavaTokenType.EQ) {
              return new TypeConversionDescriptor("$qualifier$[$idx$] = $val$", "$qualifier$.set($idx$, $val$)", assignmentExpression);
            }
            else {
              return new TypeConversionDescriptor("$qualifier$[$idx$]" + sign + "$val$",
                                                  "$qualifier$.set($idx$, " + getBoxedWrapper(from, to, "$qualifier$.get($idx$) " + sign.charAt(0) + " $val$") + ")",
                                                  assignmentExpression);
            }
          }
        } //else should be a conflict
      }
      else {
        final PsiExpression rExpression = assignmentExpression.getRExpression();
        if (rExpression == context && operationSign == JavaTokenType.EQ) {   //array = new T[l];
          return wrapWithNewExpression(to, from, rExpression, context);
        }
      }
    } else if (parent instanceof PsiVariable) {
      if (((PsiVariable)parent).getInitializer() == context) {
        return wrapWithNewExpression(to, from, (PsiExpression)context, context);
      }
    }

    if (parentParent instanceof PsiExpressionStatement) {
      if (parent instanceof PsiPostfixExpression) {
        final String sign = ((PsiPostfixExpression)parent).getOperationSign().getText();
        return new TypeConversionDescriptor("$qualifier$[$idx$]" + sign, "$qualifier$.getAndSet($idx$, " +
                                                                         getBoxedWrapper(from, to,
                                                                                         "$qualifier$.get($idx$) " + sign.charAt(0) + " 1") +
                                                                         ")", (PsiExpression)parent);
      }
      else if (parent instanceof PsiPrefixExpression) {
        final String sign = ((PsiPrefixExpression)parent).getOperationSign().getText();
        return new TypeConversionDescriptor(sign + "$qualifier$[$idx$]", "$qualifier$.set($idx$, " +
                                                                         getBoxedWrapper(from, to,
                                                                                         "$qualifier$.get($idx$) " + sign.charAt(0) + " 1") +
                                                                         ")", (PsiExpression)parent);
      }
      else if (parent instanceof PsiBinaryExpression) {
        final String sign = ((PsiBinaryExpression)parent).getOperationSign().getText();
        return new TypeConversionDescriptor("$qualifier$[$idx$]" + sign + "$val$", "$qualifier$.set($idx$, " +
                                                                                   getBoxedWrapper(from, to, "$qualifier$.get($idx$) " +
                                                                                                             sign +
                                                                                                             " $val$)") +
                                                                                   ")", (PsiExpression)parent);
      }
    }

    if (context instanceof PsiArrayAccessExpression) {
      return new TypeConversionDescriptor("$qualifier$[$idx$]", "$qualifier$.get($idx$)", (PsiExpression)context);
    }
    return null;
  }

  private static String getBoxedWrapper(final PsiType from, final PsiType to, @NotNull String arg) {
    final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(to);
    final PsiClass atomicClass = resolveResult.getElement();
    LOG.assertTrue(atomicClass != null);
    final PsiTypeParameter[] typeParameters = atomicClass.getTypeParameters();
    if (typeParameters.length == 1) {
      final PsiSubstitutor substitutor = resolveResult.getSubstitutor();
      LOG.assertTrue(substitutor.isValid());
      final PsiType initial = substitutor.substitute(typeParameters[0]);
      final PsiPrimitiveType unboxedInitialType = PsiPrimitiveType.getUnboxedType(initial);
      if (unboxedInitialType != null) {
        LOG.assertTrue(initial != null);
        if (from instanceof PsiPrimitiveType) {
          final PsiClassType boxedFromType = ((PsiPrimitiveType)from).getBoxedType(atomicClass);
          LOG.assertTrue(boxedFromType != null);
          return "new " + initial.getPresentableText() + "((" + unboxedInitialType.getCanonicalText() + ")(" + arg + "))";
        }
      }
    }
    return arg;
  }

  @Nullable
  private static TypeConversionDescriptor findReverseConversion(PsiElement context) {
    if (context instanceof PsiReferenceExpression) {
      if (context.getParent() instanceof PsiMethodCallExpression) {
        return findReverseConversionForMethodCall(context);
      }
    }
    else if (context instanceof PsiNewExpression) {
      return new TypeConversionDescriptor("new $type$($qualifier$)", "$qualifier$");
    }
    else if (context instanceof PsiMethodCallExpression) {
      return findReverseConversionForMethodCall(((PsiMethodCallExpression)context).getMethodExpression());
    }
    return null;
  }

  @Nullable
  private static TypeConversionDescriptor findReverseConversionForMethodCall(PsiElement context) {
    final PsiElement resolved = ((PsiReferenceExpression)context).resolve();
    if (resolved instanceof PsiMethod) {
      final PsiMethod method = (PsiMethod)resolved;
      final int parametersCount = method.getParameterList().getParametersCount();
      final String resolvedName = method.getName();
      if (Comparing.strEqual(resolvedName, "get")) {
        return parametersCount == 0 ?
               new TypeConversionDescriptor("$qualifier$.get()", "$qualifier$") :
               new TypeConversionDescriptor("$qualifier$.get($idx$)", "$qualifier$[$idx$]");
      }
      else if (Comparing.strEqual(resolvedName, "set")) {
        return parametersCount == 1 ?
               new TypeConversionDescriptor("$qualifier$.set($val$)", "$qualifier$ = $val$") :
               new TypeConversionDescriptor("$qualifier$.set($idx$, $val$)", "$qualifier$[$idx$] = $val$");
      }
      else if (Comparing.strEqual(resolvedName, "addAndGet")) {
        return parametersCount == 1 ?
               new TypeConversionDescriptor("$qualifier$.addAndGet($delta$)", "$qualifier$ + $delta$") :
               new TypeConversionDescriptor("$qualifier$.addAndGet($idx$, $delta$)", "$qualifier$[$idx$] + $delta$");
      }
      else if (Comparing.strEqual(resolvedName, "incrementAndGet")) {
        return parametersCount == 0 ?
               new TypeConversionDescriptor("$qualifier$.incrementAndGet()", "++$qualifier$") :
               new TypeConversionDescriptor("$qualifier$.incrementAndGet($idx$)", "++$qualifier$[$idx$]");
      }
      else if (Comparing.strEqual(resolvedName, "decrementAndGet")) {
        return parametersCount == 0 ?
               new TypeConversionDescriptor("$qualifier$.decrementAndGet()", "--$qualifier$") :
               new TypeConversionDescriptor("$qualifier$.decrementAndGet($idx$)", "--$qualifier$[$idx$]");
      }
      else if (Comparing.strEqual(resolvedName, "getAndIncrement")) {
        return parametersCount == 0 ?
               new TypeConversionDescriptor("$qualifier$.getAndIncrement()", "$qualifier$++") :
               new TypeConversionDescriptor("$qualifier$.getAndIncrement($idx$)", "$qualifier$[$idx$]++");
      }
      else if (Comparing.strEqual(resolvedName, "getAndDecrement")) {
        return parametersCount == 0 ?
               new TypeConversionDescriptor("$qualifier$.getAndDecrement()", "$qualifier$--") :
               new TypeConversionDescriptor("$qualifier$.getAndDecrement($idx$)", "$qualifier$[$idx$]--");
      }
      else if (Comparing.strEqual(resolvedName, "getAndAdd")) {
        return parametersCount == 1?
               new TypeConversionDescriptor("$qualifier$.getAndAdd($val$)", "$qualifier$ += $val$") :
               new TypeConversionDescriptor("$qualifier$.getAndAdd($idx$, $val$)", "$qualifier$[$idx$] += $val$");
      }
      else if (Comparing.strEqual(resolvedName, "getAndSet")) {
        return parametersCount == 1 ?
               new TypeConversionDescriptor("$qualifier$.getAndSet($val$)", "$qualifier$ = $val$") :
               new TypeConversionDescriptor("$qualifier$.getAndSet($idx$, $val$)", "$qualifier$[$idx$] = $val$");
      }
    }
    return null;
  }

}