Java PsiParameter类代码示例

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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());
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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;
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
@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;
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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;
    }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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;
    }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
@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");
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
@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, ")");
    }
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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));
      }

    }
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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");
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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);
      }
    }
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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;
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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;
  }
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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();
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
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);
}
 

import com.intellij.psi.PsiParameter; //导入依赖的package包/类
@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);
}