Java 类com.intellij.psi.PsiParameter 实例源码

private boolean checkMethodSignature(PsiMethod method) {
    // subscribe() calls that have no return type are custom Observers whose error handling we cannot check
    if (PsiType.VOID.equals(method.getReturnType())) {
        return false;
    }
    int argCount = method.getParameterList().getParametersCount();
    // when more than one argument is given, there is usually one error callback included
    if (argCount > 1) {
        return false;
    }
    // no arguments, no error handling
    if (argCount == 0) {
        return true;
    }
    // if we have only one argument, check that it's not a BiConsumer
    PsiParameter parameter = method.getParameterList().getParameters()[0];
    return !"io.reactivex.functions.BiConsumer".equals(parameter.getType().getCanonicalText());
}

private PsiElement findExtensionMethodNavigationElement( PsiClass extClass, PsiMethod plantedMethod )
{
  PsiMethod[] found = extClass.findMethodsByName( plantedMethod.getName(), false );
  outer:
  for( PsiMethod m : found )
  {
    PsiParameter[] extParams = m.getParameterList().getParameters();
    PsiParameter[] plantedParams = plantedMethod.getParameterList().getParameters();
    if( extParams.length - 1 == plantedParams.length )
    {
      for( int i = 1; i < extParams.length; i++ )
      {
        PsiParameter extParam = extParams[i];
        PsiParameter plantedParam = plantedParams[i - 1];
        PsiType extErased = TypeConversionUtil.erasure( extParam.getType() );
        PsiType plantedErased = TypeConversionUtil.erasure( plantedParam.getType() );
        if( !extErased.toString().equals( plantedErased.toString() ) )
        {
          continue outer;
        }
      }
      return m.getNavigationElement();
    }
  }
  return null;
}

@Nullable
public PsiType inferType( PsiTypeElement typeElement )
{
  PsiType psiType = null;

  final PsiElement parent = typeElement.getParent();
  if( (parent instanceof PsiLocalVariable && isVar( (PsiLocalVariable)parent )) ||
      (parent instanceof PsiParameter && isVarForEach( (PsiParameter)parent )) )
  {

    if( parent instanceof PsiLocalVariable )
    {
      psiType = processLocalVariableInitializer( ((PsiLocalVariable)parent).getInitializer() );
    }
    else
    {
      psiType = processForeach( ((PsiParameter)parent).getDeclarationScope() );
    }

    if( null == psiType )
    {
      psiType = PsiType.getJavaLangObject( typeElement.getManager(), GlobalSearchScope.allScope( typeElement.getProject() ) );
    }
  }
  return psiType;
}

void check(@NonNull PsiMethod method) {
    if (mClass != null &&
            !mClassFields.isEmpty()) {

        // メソッド引数に boolean のパラメータがある場合のみ対象とする
        Map<String, PsiParameter> parameters = new HashMap<>();
        PsiParameter[] params = method.getParameterList().getParameters();
        for (PsiParameter param : params) {
            if (param.getType() != PsiType.BOOLEAN) continue;
            parameters.put(param.getName(), param);
        }
        if (parameters.isEmpty()) return;

        mMethod = method;
        mFlagMethodParameters.clear();
        mFlagMethodParameters.putAll(parameters);
        mFlagLogic = null;
    }
}

private static void seekChildren(PsiElement element, PsiIdentifier target, Find find) {
    for (PsiElement child : element.getChildren()) {
        if (child instanceof PsiLocalVariable) {
            PsiLocalVariable localVariable = (PsiLocalVariable) child;
            if (isSameName(target, localVariable.getNameIdentifier())) {
                find.findLocalVariable = localVariable;
                return;
            }
        }
        if (child instanceof PsiParameter) {
            PsiParameter parameter = (PsiParameter) child;
            if (isSameName(target, parameter.getNameIdentifier())) {
                find.findParameter = parameter;
                return;
            }
        }
        seekChildren(child, target, find);
        if (!find.isEmpty()) return;
    }
}

@Override
public void generateFieldInitialization(@NotNull StringBuilder buffer,
                                        @NotNull PsiField[] fields,
                                        @NotNull PsiParameter[] parameters) {
  for (int i = 0, length = fields.length; i < length; i++) {
    String fieldName = fields[i].getName();
    String paramName = parameters[i].getName();
    if (fieldName.equals(paramName)) {
      buffer.append("this.");
    }
    buffer.append(fieldName);
    buffer.append("=");
    buffer.append(paramName);
    buffer.append(";\n");
  }
}

@Override
public void apply(Editor editor, JavaSmartEnterProcessor processor, PsiElement psiElement) throws IncorrectOperationException {
  if (psiElement instanceof PsiParameterList) {
    String text = psiElement.getText();
    if (StringUtil.startsWithChar(text, '(') && !StringUtil.endsWithChar(text, ')')) {
      PsiParameter[] params = ((PsiParameterList)psiElement).getParameters();
      int offset;
      if (params.length == 0) {
        offset = psiElement.getTextRange().getStartOffset() + 1;
      }
      else {
        offset = params[params.length - 1].getTextRange().getEndOffset();
      }
      editor.getDocument().insertString(offset, ")");
    }
  }
}

private void appendAccessors(final Set<PsiParameter> params, boolean isGetter) {
  final PsiElement element = getElement();
  if (element != null) {
    for (PsiParameter parameter : params) {
      final IntroduceParameterObjectProcessor.ParameterChunk parameterChunk =
        IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(parameter, parameters);
      LOGGER.assertTrue(parameterChunk != null);
      final PsiField field = parameterChunk.getField();
      if (field != null) {
        element.add(isGetter
                    ? GenerateMembersUtil.generateGetterPrototype(field)
                    : GenerateMembersUtil.generateSetterPrototype(field));
      }

    }
  }
}

private void appendConflicts(StringBuffer buf, final Set<PsiParameter> paramsNeeding) {
  if (!paramsNeeding.isEmpty()) {
    buf.append(paramsNeeding == paramsNeedingGetters ? "Getters" : "Setters");
    buf.append(" for the following fields are required:\n");
    buf.append(StringUtil.join(paramsNeeding, new Function<PsiParameter, String>() {
      public String fun(PsiParameter psiParameter) {
        final IntroduceParameterObjectProcessor.ParameterChunk chunk =
          IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(psiParameter, parameters);
        if (chunk != null) {
          final PsiField field = chunk.getField();
          if (field != null) {
            return field.getName();
          }
        }
        return psiParameter.getName();
      }
    }, ", "));
    buf.append(".\n");
  }
}

public AutomaticParametersRenamer(PsiParameter param, String newParamName) {
  final PsiElement scope = param.getDeclarationScope();
  if (scope instanceof PsiMethod) {
    final PsiMethod method = (PsiMethod)scope;
    final int parameterIndex = method.getParameterList().getParameterIndex(param);
    if (parameterIndex < 0) return;
    for (PsiMethod overrider : OverridingMethodsSearch.search(method)) {
      final PsiParameter[] parameters = overrider.getParameterList().getParameters();
      if (parameterIndex >= parameters.length) continue;
      final PsiParameter inheritedParam = parameters[parameterIndex];
      if (!Comparing.strEqual(inheritedParam.getName(), newParamName)) {
        myElements.add(inheritedParam);
        suggestAllNames(inheritedParam.getName(), newParamName);
      }
    }
  }
}

public IntroduceParameterSettingsUI(PsiLocalVariable onLocalVariable,
                                    PsiExpression onExpression,
                                    PsiMethod methodToReplaceIn,
                                    TIntArrayList parametersToRemove) {
  myHasInitializer = onLocalVariable != null && onLocalVariable.getInitializer() != null;
  myIsInvokedOnDeclaration = onExpression == null;
  final PsiParameter[] parameters = methodToReplaceIn.getParameterList().getParameters();
  myParametersToRemove = new PsiParameter[parameters.length];
  myParametersToRemoveChecked = new boolean[parameters.length];
  parametersToRemove.forEach(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      myParametersToRemove[paramNum] = parameters[paramNum];
      return true;
    }
  });
  myIsLocalVariable = onLocalVariable != null;
}

public MethodJavaDocHelper(PsiMethod method) {
  myMethod = method;
  myDocComment = myMethod.getDocComment();
  if (myDocComment == null) {
    myDoCorrectJavaDoc = false;
    return;
  }
  final PsiParameter[] parameters = myMethod.getParameterList().getParameters();
  if (parameters.length != 0) {
    final PsiDocTag[] paramTags = myDocComment.findTagsByName("param");
    if (paramTags.length > 0) {
      myDoCorrectJavaDoc = true;
    } else {
      myDoCorrectJavaDoc = false;
    }
  } else {
    myDoCorrectJavaDoc = true;
  }
}

public static String fillMethodParameters(final PsiMethod method, @Nullable final TIntObjectHashMap<SubLookupElement> replaceElements) {
  final TIntObjectHashMap<SubLookupElement> notNullReplaceElements = replaceElements == null ?
      new TIntObjectHashMap<SubLookupElement>(0) :
      replaceElements;

  final PsiParameter[] parameters = method.getParameterList().getParameters();
  final StringBuilder sb = new StringBuilder();
  for (int i = 0; i < parameters.length; i++) {
    if (i != 0) {
      sb.append(", ");
    }
    final PsiParameter parameter = parameters[i];
    final SubLookupElement replaceElement = notNullReplaceElements.get(i);
    if (replaceElement != null) {
      sb.append(replaceElement.getInsertString());
    } else {
      sb.append(parameter.getName());
    }
  }
  return sb.toString();
}

private static MatchResult matchParameters(final PsiMethod method, final ChainCompletionContext context, final Set<String> additionalExcludedNames) {
  int matched = 0;
  int unMatched = 0;
  boolean hasTarget = false;
  for (final PsiParameter parameter : method.getParameterList().getParameters()) {
    final PsiType type = parameter.getType();
    final String canonicalText = type.getCanonicalText();
    if (context.contains(canonicalText) || type instanceof PsiPrimitiveType) {
      matched++;
    }
    else {
      unMatched++;
    }
    if (context.getTarget().getClassQName().equals(canonicalText) || additionalExcludedNames.contains(canonicalText)) {
      hasTarget = true;
    }
  }
  return new MatchResult(matched, unMatched, hasTarget);
}

@Override
public void visitMethod(@NotNull PsiMethod method) {
  final PsiParameterList parameterList = method.getParameterList();
  if (parameterList.getParametersCount() == 0) {
    return;
  }
  final Query<MethodSignatureBackedByPsiMethod> query =
    SuperMethodsSearch.search(
      method, method.getContainingClass(), true, false);
  final MethodSignatureBackedByPsiMethod methodSignature =
    query.findFirst();
  if (methodSignature == null) {
    return;
  }
  final PsiMethod superMethod = methodSignature.getMethod();
  final PsiParameter[] parameters = parameterList.getParameters();
  checkParameters(superMethod, parameters);
}

@Override
public void visitCatchSection(PsiCatchSection section) {
  super.visitCatchSection(section);
  final PsiParameter parameter = section.getParameter();
  if (parameter == null) {
    return;
  }
  final PsiTypeElement typeElement = parameter.getTypeElement();
  if (typeElement == null) {
    return;
  }
  final PsiTypeElement[] childTypeElements = PsiTreeUtil.getChildrenOfType(typeElement, PsiTypeElement.class);
  if (childTypeElements != null) {
    for (PsiTypeElement childTypeElement : childTypeElements) {
      checkTypeElement(childTypeElement);
    }
  }
  else {
    checkTypeElement(typeElement);
  }
}

@Override
protected void check(@NotNull GrControlFlowOwner owner, @NotNull ProblemsHolder problemsHolder) {
  Instruction[] flow = owner.getControlFlow();
  ReadWriteVariableInstruction[] reads = ControlFlowBuilderUtil.getReadsWithoutPriorWrites(flow, true);
  for (ReadWriteVariableInstruction read : reads) {
    PsiElement element = read.getElement();
    if (element instanceof GroovyPsiElement && !(element instanceof GrClosableBlock)) {
      String name = read.getVariableName();
      GroovyPsiElement property = ResolveUtil.resolveProperty((GroovyPsiElement)element, name);
      if (property != null &&
          !(property instanceof PsiParameter) &&
          !(property instanceof PsiField) &&
          PsiTreeUtil.isAncestor(owner, property, false) &&
          !(myIgnoreBooleanExpressions && isBooleanCheck(element))
        ) {
        problemsHolder.registerProblem(element, GroovyInspectionBundle.message("unassigned.access.tooltip", name));
      }
    }
  }
}

@Override
public void generateFieldInitialization(@NotNull StringBuilder buffer,
                                        @NotNull PsiField[] fields,
                                        @NotNull PsiParameter[] parameters) {
  for (int i = 0, length = fields.length; i < length; i++) {
    String fieldName = fields[i].getName();
    String paramName = parameters[i].getName();
    if (fieldName.equals(paramName)) {
      buffer.append("this.");
    }
    buffer.append(fieldName);
    buffer.append("=");
    buffer.append(paramName);
    buffer.append("\n");
  }
}

public static Result searchForVarsToWrap(GroovyPsiElement root, Result analyzedVars, ExpressionContext context) {
  LocalVarAnalyzer visitor = new LocalVarAnalyzer();
  root.accept(visitor);

  Map<PsiVariable, String> varToName = analyzedVars == null ? new HashMap<PsiVariable, String>() : analyzedVars.varToName;
  Set<PsiVariable> toWrap = analyzedVars == null ? new HashSet<PsiVariable>() : analyzedVars.toWrap;
  Set<PsiVariable> toMakeFinal = analyzedVars == null ? new HashSet<PsiVariable>() : analyzedVars.toMakeFinal;
  for (PsiVariable v : visitor.touched) {
    if (visitor.rewritten.contains(v)) {
      toWrap.add(v);
      if (v instanceof PsiParameter) {
        varToName.put(v, GenerationUtil.suggestVarName(v.getType(), root, context));
      }
      else {
        varToName.put(v, v.getName());
      }
    }
    else {
      toMakeFinal.add(v);
      varToName.put(v, v.getName());
    }
  }
  return analyzedVars == null ? new Result(toMakeFinal, toWrap, varToName) : analyzedVars;
}

private boolean hasParameterName(PsiParameter psiParameter) {
  PsiModifierList modifierList = psiParameter.getModifierList();
  if (modifierList == null) {
    return false;
  }

  PsiAnnotation annotation = modifierList.findAnnotation("javax.inject.Named");
  if (annotation != null) {
    return true;
  }

  annotation = modifierList.findAnnotation(GctConstants.APP_ENGINE_ANNOTATION_NAMED);
  if (annotation != null) {
    return true;
  }

  return false;
}

private void initializePsiMethod(String methodName, String httpMethodValue, String pathValue) {
  PsiAnnotationMemberValue mockAnnotationMemberValue1 = mock(PsiAnnotationMemberValue.class);
  when(mockAnnotationMemberValue1.getText()).thenReturn(httpMethodValue);

  PsiAnnotationMemberValue mockAnnotationMemberValue2 = mock(PsiAnnotationMemberValue.class);
  when(mockAnnotationMemberValue2.getText()).thenReturn(pathValue);

  PsiAnnotation mockAnnotation = mock(PsiAnnotation.class);
  when(mockAnnotation.getQualifiedName())
      .thenReturn(GctConstants.APP_ENGINE_ANNOTATION_API_METHOD);
  when(mockAnnotation.findAttributeValue("httpMethod")).thenReturn(mockAnnotationMemberValue1);
  when(mockAnnotation.findAttributeValue("path")).thenReturn(mockAnnotationMemberValue2);
  PsiAnnotation[] mockAnnotationsArray = {mockAnnotation};

  PsiModifierList mockModifierList = mock(PsiModifierList.class);
  when(mockModifierList.getAnnotations()).thenReturn(mockAnnotationsArray);

  mockPsiMethod = mock(PsiMethod.class);
  when(mockPsiMethod.getModifierList()).thenReturn(mockModifierList);
  when(mockPsiMethod.getName()).thenReturn(methodName);
  when(mockPsiMethod.getContainingClass()).thenReturn(mockPsiClass);

  PsiParameterList mockParameterList = mock(PsiParameterList.class);
  when(mockParameterList.getParameters()).thenReturn(new PsiParameter[0]);
  when(mockPsiMethod.getParameterList()).thenReturn(mockParameterList);
}

/**
 * Tests that the NamedResourceInspection's quick fix flagged with {@link
 * NamedResourceError#MISSING_NAME} for an @Named annotation with a {@link PsiParameter} parent
 * updates the query name to to the name of the {@link PsiParameter}.
 */
public void testQuickFix_noQueryNameSpecifiedWithParameter() {
  Project myProject = myFixture.getProject();
  PsiParameter parameter =
      JavaPsiFacade.getInstance(myProject)
          .getElementFactory()
          .createParameterFromText("@javax.inject.Named() String foobar", null);
  PsiAnnotation[] annotationsList = parameter.getModifierList().getAnnotations();
  assert (annotationsList.length == 1);
  NamedResourceInspection.MissingNameQuickFix myQuickFix =
      new NamedResourceInspection().new MissingNameQuickFix();
  MockProblemDescriptor problemDescriptor =
      new MockProblemDescriptor(annotationsList[0], "", ProblemHighlightType.ERROR);

  myQuickFix.applyFix(myProject, problemDescriptor);
  assertEquals("@javax.inject.Named(\"foobar\")", annotationsList[0].getText());
}

@Override
protected Collection<DfaMemoryState> createInitialStates(@NotNull PsiElement psiBlock, InstructionVisitor visitor) {
  final Collection<DfaMemoryState> initialStates = super.createInitialStates(psiBlock, visitor);
  if (initialStates == null) {
    return null;
  }

  final PsiElement parent = psiBlock.getParent();
  if (parent instanceof PsiMethod) {
    PsiMethod method = (PsiMethod)parent;

    //todo move out from generic runner
    for (PsiParameter parameter : method.getParameterList().getParameters()) {
      if (NullableNotNullManager.isNotNull(parameter)) {
        final DfaVariableValue value = getFactory().getVarFactory().createVariableValue(parameter, false);
        for (final DfaMemoryState initialState : initialStates) {
          initialState.applyNotNull(value);
        }
      }
    }
  }
  return initialStates;
}

public static String fillMethodParameters(final PsiMethod method, @Nullable final TIntObjectHashMap<SubLookupElement> replaceElements) {
  final TIntObjectHashMap<SubLookupElement> notNullReplaceElements = replaceElements == null ?
      new TIntObjectHashMap<SubLookupElement>(0) :
      replaceElements;

  final PsiParameter[] parameters = method.getParameterList().getParameters();
  final StringBuilder sb = new StringBuilder();
  for (int i = 0; i < parameters.length; i++) {
    if (i != 0) {
      sb.append(", ");
    }
    final PsiParameter parameter = parameters[i];
    final SubLookupElement replaceElement = notNullReplaceElements.get(i);
    if (replaceElement != null) {
      sb.append(replaceElement.getInsertString());
    } else {
      sb.append(parameter.getName());
    }
  }
  return sb.toString();
}

public static boolean checkParametersForTypesQNames(final PsiMethod[] psiMethods, final Set<String> excludedTypesQNames) {
  if (psiMethods.length == 0) {
    return true;
  }
  for (final PsiMethod method : psiMethods) {
    boolean hasTargetInParams = false;
    for (final PsiParameter param : method.getParameterList().getParameters()) {
      final String paramType = param.getType().getCanonicalText();
      if (excludedTypesQNames.contains(paramType)) {
        hasTargetInParams = true;
        break;
      }
    }
    if (!hasTargetInParams) {
      return true;
    }
  }
  return false;
}

@Override
public void generateFieldInitialization(@NotNull StringBuilder buffer,
                                        @NotNull PsiField[] fields,
                                        @NotNull PsiParameter[] parameters) {
  for (int i = 0, length = fields.length; i < length; i++) {
    String fieldName = fields[i].getName();
    String paramName = parameters[i].getName();
    if (fieldName.equals(paramName)) {
      buffer.append("this.");
    }
    buffer.append(fieldName);
    buffer.append("=");
    buffer.append(paramName);
    buffer.append(";\n");
  }
}

@Nullable
@Override
protected PsiParameter[] getParams(PsiElement element) {
  final PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class);
  final PsiParameter[] parameters = method.getParameterList().getParameters();
  final ParameterClassMember[] members = new ParameterClassMember[parameters.length];
  for (int i = 0; i < members.length; i++) {
    members[i] = new ParameterClassMember(parameters[i]);
  }
  final MemberChooser<ParameterClassMember> chooser = new MemberChooser<ParameterClassMember>(members, false, true, element.getProject());
  chooser.selectElements(members);
  chooser.setTitle("Choose " + (method.isConstructor() ? "Constructor" : "Method") + " Parameters");
  chooser.show();
  if (chooser.isOK()) {
    final List<ParameterClassMember> elements = chooser.getSelectedElements();
    if (elements != null) {
      PsiParameter[] params = new PsiParameter[elements.size()];
      for (int i = 0; i < params.length; i++) {
        params[i] = elements.get(i).getParameter();
      }
      return params;
    }
  }
  return null;
}

@Override
public void apply(Editor editor, JavaSmartEnterProcessor processor, PsiElement psiElement) throws IncorrectOperationException {
  if (psiElement instanceof PsiParameterList) {
    String text = psiElement.getText();
    if (StringUtil.startsWithChar(text, '(') && !StringUtil.endsWithChar(text, ')')) {
      PsiParameter[] params = ((PsiParameterList)psiElement).getParameters();
      int offset;
      if (params.length == 0) {
        offset = psiElement.getTextRange().getStartOffset() + 1;
      }
      else {
        offset = params[params.length - 1].getTextRange().getEndOffset();
      }
      editor.getDocument().insertString(offset, ")");
    }
  }
}

private void appendAccessors(final Set<PsiParameter> params, boolean isGetter) {
  final PsiElement element = getElement();
  if (element != null) {
    for (PsiParameter parameter : params) {
      final IntroduceParameterObjectProcessor.ParameterChunk parameterChunk =
        IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(parameter, parameters);
      LOGGER.assertTrue(parameterChunk != null);
      final PsiField field = parameterChunk.getField();
      if (field != null) {
        element.add(isGetter
                    ? GenerateMembersUtil.generateGetterPrototype(field)
                    : GenerateMembersUtil.generateSetterPrototype(field));
      }

    }
  }
}

private void appendConflicts(StringBuffer buf, final Set<PsiParameter> paramsNeeding) {
  if (!paramsNeeding.isEmpty()) {
    buf.append(paramsNeeding == paramsNeedingGetters ? "Getters" : "Setters");
    buf.append(" for the following fields are required:\n");
    buf.append(StringUtil.join(paramsNeeding, new Function<PsiParameter, String>() {
      public String fun(PsiParameter psiParameter) {
        final IntroduceParameterObjectProcessor.ParameterChunk chunk =
          IntroduceParameterObjectProcessor.ParameterChunk.getChunkByParameter(psiParameter, parameters);
        if (chunk != null) {
          final PsiField field = chunk.getField();
          if (field != null) {
            return field.getName();
          }
        }
        return psiParameter.getName();
      }
    }, ", "));
    buf.append(".\n");
  }
}

public AutomaticParametersRenamer(PsiParameter param, String newParamName) {
  final PsiElement scope = param.getDeclarationScope();
  if (scope instanceof PsiMethod) {
    final PsiMethod method = (PsiMethod)scope;
    final int parameterIndex = method.getParameterList().getParameterIndex(param);
    if (parameterIndex < 0) return;
    for (PsiMethod overrider : OverridingMethodsSearch.search(method)) {
      final PsiParameter[] parameters = overrider.getParameterList().getParameters();
      if (parameterIndex >= parameters.length) continue;
      final PsiParameter inheritedParam = parameters[parameterIndex];
      if (!Comparing.strEqual(inheritedParam.getName(), newParamName)) {
        myElements.add(inheritedParam);
        suggestAllNames(inheritedParam.getName(), newParamName);
      }
    }
  }
}

public IntroduceParameterSettingsUI(PsiLocalVariable onLocalVariable,
                                    PsiExpression onExpression,
                                    PsiMethod methodToReplaceIn,
                                    TIntArrayList parametersToRemove) {
  myHasInitializer = onLocalVariable != null && onLocalVariable.getInitializer() != null;
  myIsInvokedOnDeclaration = onExpression == null;
  final PsiParameter[] parameters = methodToReplaceIn.getParameterList().getParameters();
  myParametersToRemove = new PsiParameter[parameters.length];
  myParametersToRemoveChecked = new boolean[parameters.length];
  parametersToRemove.forEach(new TIntProcedure() {
    public boolean execute(final int paramNum) {
      myParametersToRemove[paramNum] = parameters[paramNum];
      return true;
    }
  });
  myIsLocalVariable = onLocalVariable != null;
}

public MethodJavaDocHelper(PsiMethod method) {
  myMethod = method;
  myDocComment = myMethod.getDocComment();
  if (myDocComment == null) {
    myDoCorrectJavaDoc = false;
    return;
  }
  final PsiParameter[] parameters = myMethod.getParameterList().getParameters();
  if (parameters.length != 0) {
    final PsiDocTag[] paramTags = myDocComment.findTagsByName("param");
    if (paramTags.length > 0) {
      myDoCorrectJavaDoc = true;
    } else {
      myDoCorrectJavaDoc = false;
    }
  } else {
    myDoCorrectJavaDoc = true;
  }
}

@Override
public void visitMethod(@NotNull PsiMethod method) {
  final PsiParameterList parameterList = method.getParameterList();
  if (parameterList.getParametersCount() == 0) {
    return;
  }
  final Query<MethodSignatureBackedByPsiMethod> query =
    SuperMethodsSearch.search(
      method, method.getContainingClass(), true, false);
  final MethodSignatureBackedByPsiMethod methodSignature =
    query.findFirst();
  if (methodSignature == null) {
    return;
  }
  final PsiMethod superMethod = methodSignature.getMethod();
  final PsiParameter[] parameters = parameterList.getParameters();
  checkParameters(superMethod, parameters);
}

@Override
public void visitCatchSection(PsiCatchSection section) {
  super.visitCatchSection(section);
  final PsiParameter parameter = section.getParameter();
  if (parameter == null) {
    return;
  }
  final PsiTypeElement typeElement = parameter.getTypeElement();
  if (typeElement == null) {
    return;
  }
  final PsiTypeElement[] childTypeElements = PsiTreeUtil.getChildrenOfType(typeElement, PsiTypeElement.class);
  if (childTypeElements != null) {
    for (PsiTypeElement childTypeElement : childTypeElements) {
      checkTypeElement(childTypeElement);
    }
  }
  else {
    checkTypeElement(typeElement);
  }
}

@Override
public void visitParameter(@NotNull PsiParameter parameter) {
  super.visitParameter(parameter);

  if (parameter.getDeclarationScope() instanceof PsiCatchSection) {
    return;
  }
  final PsiTypeElement typeElement = parameter.getTypeElement();
  if (typeElement == null) {
    return;
  }
  if (!ConcreteClassUtil.typeIsConcreteClass(typeElement,
                                             ignoreAbstractClasses)) {
    return;
  }
  final String variableName = parameter.getName();
  registerError(typeElement, variableName);
}

protected void check(GrControlFlowOwner owner, ProblemsHolder problemsHolder) {
  Instruction[] flow = owner.getControlFlow();
  ReadWriteVariableInstruction[] reads = ControlFlowBuilderUtil.getReadsWithoutPriorWrites(flow, true);
  for (ReadWriteVariableInstruction read : reads) {
    PsiElement element = read.getElement();
    if (element instanceof GroovyPsiElement) {
      String name = read.getVariableName();
      GroovyPsiElement property = ResolveUtil.resolveProperty((GroovyPsiElement)element, name);
      if (property != null &&
          !(property instanceof PsiParameter) &&
          !(property instanceof PsiField) &&
          PsiTreeUtil.isAncestor(owner, property, false) &&
          !GppTypeConverter.hasTypedContext(element) &&
          !(myIgnoreBooleanExpressions && isBooleanCheck(element))
        ) {
        problemsHolder.registerProblem(element, GroovyInspectionBundle.message("unassigned.access.tooltip", name));
      }
    }
  }
}

@Override
public void generateFieldInitialization(@NotNull StringBuilder buffer,
                                        @NotNull PsiField[] fields,
                                        @NotNull PsiParameter[] parameters) {
  for (int i = 0, length = fields.length; i < length; i++) {
    String fieldName = fields[i].getName();
    String paramName = parameters[i].getName();
    if (fieldName.equals(paramName)) {
      buffer.append("this.");
    }
    buffer.append(fieldName);
    buffer.append("=");
    buffer.append(paramName);
    buffer.append("\n");
  }
}

public static Result searchForVarsToWrap(GroovyPsiElement root, Result analyzedVars, ExpressionContext context) {
  LocalVarAnalyzer visitor = new LocalVarAnalyzer();
  root.accept(visitor);

  Map<PsiVariable, String> varToName = analyzedVars == null ? new HashMap<PsiVariable, String>() : analyzedVars.varToName;
  Set<PsiVariable> toWrap = analyzedVars == null ? new HashSet<PsiVariable>() : analyzedVars.toWrap;
  Set<PsiVariable> toMakeFinal = analyzedVars == null ? new HashSet<PsiVariable>() : analyzedVars.toMakeFinal;
  for (PsiVariable v : visitor.touched) {
    if (visitor.rewritten.contains(v)) {
      toWrap.add(v);
      if (v instanceof PsiParameter) {
        varToName.put(v, GenerationUtil.suggestVarName(v.getType(), root, context));
      }
      else {
        varToName.put(v, v.getName());
      }
    }
    else {
      toMakeFinal.add(v);
      varToName.put(v, v.getName());
    }
  }
  return analyzedVars == null ? new Result(toMakeFinal, toWrap, varToName) : analyzedVars;
}

/**
 * Finds and removes a given method
 * @param methodName
 * @param arguments
 */
private void findAndRemoveMethod(String methodName, String... arguments) {
  // Maybe there's an easier way to do this with mClass.findMethodBySignature(), but I'm not an expert on Psi*
  PsiMethod[] methods = psiClass.findMethodsByName(methodName, false);

  for (PsiMethod method : methods) {
    PsiParameterList parameterList = method.getParameterList();

    if (parameterList.getParametersCount() == arguments.length) {
      boolean shouldDelete = true;

      PsiParameter[] parameters = parameterList.getParameters();

      for (int i = 0; i < arguments.length; i++) {
        if (!parameters[i].getType().getCanonicalText().equals(arguments[i])) {
          shouldDelete = false;
        }
      }

      if (shouldDelete) {
        method.delete();
      }
    }
  }
}