plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/SetterWriter.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jetbrains.plugins.groovy.refactoring.convertToJava;

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrGdkMethod;

/**
 * @author Max Medvedev
 */
public class SetterWriter {
  private static final Logger LOG = Logger.getInstance(SetterWriter.class);

  private final StringBuilder myBuffer;
  private final PsiClass myClass;
  private final PsiMethod mySetter;
  private final String myName;
  private final ClassNameProvider myClassNameProvider;
  private final ExpressionContext myContext;

  public SetterWriter(@NotNull StringBuilder builder,
                      @NotNull PsiClass psiClass,
                      @NotNull PsiMethod setter,
                      @NotNull String name,
                      @NotNull ClassNameProvider classNameProvider,
                      @NotNull ExpressionContext context) {
    myBuffer = builder;
    myClass = psiClass;
    myClassNameProvider = classNameProvider;
    myContext = context;
    myName = name;

    if (setter instanceof PsiCompiledElement) setter = (PsiMethod)((PsiCompiledElement)setter).getMirror();
    mySetter = setter;
  }


  public void write() {
    final boolean isStatic = mySetter.hasModifierProperty(PsiModifier.STATIC);

    final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myContext.project);

    PsiParameter[] parameters = mySetter.getParameterList().getParameters();
    PsiParameter parameter = parameters[parameters.length - 1];
    final PsiType parameterType = myContext.typeProvider.getParameterType(parameter);

    myBuffer.append("private static ");
    processTypeParameters(parameterType);

    myBuffer.append(myName);

    if (!(parameterType instanceof PsiPrimitiveType)) {
      parameter = factory.createParameter(parameter.getName(), "Value", null);
    }


    PsiParameter[] actual = inferActualParameters(isStatic, parameters, parameter);
    final GroovyPsiElement place = createStubMethod(actual);
    GenerationUtil.writeParameterList(myBuffer, actual, myClassNameProvider, myContext);
    writeBody(isStatic, parameters, parameter, place);
  }

  private void writeBody(boolean aStatic,
                         @NotNull PsiParameter[] parameters,
                         @NotNull PsiParameter parameter, final GroovyPsiElement place) {
    //method body
    myBuffer.append("{\n");

    //arg initialization
    myContext.myUsedVarNames.add("propOwner");
    final GrExpression[] args = generateArguments(parameters, place);

    new ExpressionGenerator(myBuffer, myContext).invokeMethodOn(
      mySetter,
      aStatic ? null : GroovyPsiElementFactory.getInstance(myContext.project).createExpressionFromText("propOwner", place),
      args,
      GrNamedArgument.EMPTY_ARRAY,
      GrClosableBlock.EMPTY_ARRAY,
      PsiSubstitutor.EMPTY,
      place
    );
    myBuffer.append(";\n");
    myBuffer.append("return ").append(parameter.getName()).append(";\n");
    myBuffer.append("}\n");
  }

  @NotNull
  private GrExpression[] generateArguments(@NotNull PsiParameter[] parameters, @NotNull GroovyPsiElement place) {
    final GrExpression[] args = new GrExpression[parameters.length];
    for (int i = 0; i < parameters.length; i++) {
      args[i] = GroovyPsiElementFactory.getInstance(myContext.project).createExpressionFromText(parameters[i].getName(), place);
      myContext.myUsedVarNames.add(parameters[i].getName());
    }
    return args;
  }

  private GroovyPsiElement createStubMethod(@NotNull PsiParameter[] parameters) {
    StringBuilder methodText = new StringBuilder("def ").append(myName).append('(');
    for (PsiParameter parameter : parameters) {
      methodText.append(parameter.getType().getCanonicalText()).append(' ').append(parameter.getName()).append(',');
    }
    if (parameters.length > 0) methodText.deleteCharAt(methodText.length() - 1);
    methodText.append("){}");
    return GroovyPsiElementFactory.getInstance(myContext.project).createMethodFromText(methodText.toString(), mySetter);
  }

  @NotNull
  private PsiParameter[] inferActualParameters(boolean aStatic,
                                               @NotNull PsiParameter[] parameters,
                                               @NotNull PsiParameter parameter) {
    //parameters
    parameters[parameters.length - 1] = parameter;
    PsiParameter[] actual;
    if (aStatic) {
      actual = parameters;
    }
    else {
      final String typeText;
      final PsiClass containingClass = mySetter.getContainingClass();
      if (containingClass == null) {
        if (mySetter instanceof GrGdkMethod) {
          typeText = ((GrGdkMethod)mySetter).getStaticMethod().getParameterList().getParameters()[0].getType().getCanonicalText();
        }
        else {
          typeText = CommonClassNames.JAVA_LANG_OBJECT;
        }
      }
      else {
        typeText = containingClass.getQualifiedName();
      }

      final GrParameter propOwner = GroovyPsiElementFactory.getInstance(myContext.project).createParameter("propOwner", typeText, null);

      actual = new PsiParameter[parameters.length + 1];
      actual[0] = propOwner;
      System.arraycopy(parameters, 0, actual, 1, parameters.length);
    }
    return actual;
  }

  private void processTypeParameters(PsiType parameterType) {
    //type parameters
    if (mySetter.hasTypeParameters()) {
      GenerationUtil.writeTypeParameters(myBuffer, mySetter, myClassNameProvider);
    }

    if (parameterType instanceof PsiPrimitiveType) {
      myBuffer.append(parameterType.getCanonicalText()).append(' ');
    }
    else {
      if (mySetter.hasTypeParameters()) {
        myBuffer.delete(myBuffer.length() - 1, myBuffer.length());
        //builder.removeFromTheEnd(1);
        myBuffer.append(", ");
      }
      else {
        myBuffer.append('<');
      }
      myBuffer.append("Value");
      if (!parameterType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
        myBuffer.append(" extends ");
        TypeWriter.writeType(myBuffer, parameterType, myClass, myClassNameProvider);
      }
      myBuffer.append('>');
      myBuffer.append("Value ");
    }
  }
}