Java CollectionUtils.isCollectionClassOrInterface方法代码示例

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
private static boolean isEmptyCollectionInitializer(PsiExpression initializer) {
  if (!(initializer instanceof PsiNewExpression)) {
    return false;
  }
  final PsiNewExpression newExpression = (PsiNewExpression)initializer;
  final PsiExpressionList argumentList = newExpression.getArgumentList();
  if (argumentList == null) {
    return false;
  }
  final PsiExpression[] arguments = argumentList.getExpressions();
  for (final PsiExpression argument : arguments) {
    final PsiType argumentType = argument.getType();
    if (argumentType == null) {
      return false;
    }
    if (CollectionUtils.isCollectionClassOrInterface(argumentType)) {
      return false;
    }
    if (argumentType instanceof PsiArrayType) {
      return false;
    }
  }
  return true;
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
private boolean checkVariable(PsiVariable variable, PsiElement context) {
  if (context == null) {
    return false;
  }
  final PsiType type = variable.getType();
  if (!CollectionUtils.isCollectionClassOrInterface(type)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssignedFrom(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsReturned(variable, context)) {
    return false;
  }
  return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context);
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
private boolean checkVariable(PsiVariable variable, PsiElement context) {
  if (context == null) {
    return false;
  }
  final PsiType type = variable.getType();
  if (!CollectionUtils.isCollectionClassOrInterface(type)) {
    return false;
  }
  if (VariableAccessUtils.variableIsAssignedFrom(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsReturned(variable, context)) {
    return false;
  }
  if (VariableAccessUtils.variableIsPassedAsMethodArgument(variable, context)) {
    return false;
  }
  return !VariableAccessUtils.variableIsUsedInArrayInitializer(variable, context);
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
@Override
public void visitField(@NotNull PsiField field) {
  super.visitField(field);
  if (!field.hasModifierProperty(PsiModifier.PUBLIC)) {
    return;
  }
  if (!field.hasModifierProperty(PsiModifier.STATIC)) {
    return;
  }
  final PsiType type = field.getType();
  if (!CollectionUtils.isCollectionClassOrInterface(type)) {
    return;
  }
  registerFieldError(field);
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
@Override
public void visitField(@NotNull PsiField field) {
  if (!field.hasModifierProperty(PsiModifier.STATIC)) {
    return;
  }
  final PsiType type = field.getType();
  if (!CollectionUtils.isCollectionClassOrInterface(type)) {
    return;
  }
  if (!m_ignoreWeakCollections ||
      CollectionUtils.isWeakCollectionClass(type)) {
    return;
  }
  registerFieldError(field);
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression call) {
  super.visitMethodCallExpression(call);
  final PsiReferenceExpression methodExpression =
    call.getMethodExpression();
  @NonNls final String methodName = methodExpression.getReferenceName();
  if ("equals".equals(methodName)) {
    return; // object method
  }
  final PsiExpression qualifier =
    methodExpression.getQualifierExpression();
  if (!(qualifier instanceof PsiReferenceExpression)) {
    return;
  }
  final PsiElement referent = ((PsiReference)qualifier).resolve();
  if (!(referent instanceof PsiVariable)) {
    return;
  }
  final PsiExpressionList argumentList = call.getArgumentList();
  PsiExpression selfArgument = null;
  final PsiExpression[] arguments = argumentList.getExpressions();
  for (PsiExpression argument : arguments) {
    if (EquivalenceChecker.expressionsAreEquivalent(qualifier, argument)) {
      selfArgument = argument;
    }
  }
  if (selfArgument == null) {
    return;
  }
  final PsiType qualifierType = qualifier.getType();
  if (!InheritanceUtil.isInheritor(qualifierType, CommonClassNames.JAVA_UTIL_COLLECTION) &&
      !InheritanceUtil.isInheritor(qualifierType, CommonClassNames.JAVA_UTIL_MAP)) {
    return;
  }
  final PsiMethod method = call.resolveMethod();
  if (method == null) {
    return;
  }
  final PsiClass aClass = method.getContainingClass();
  if (!CollectionUtils.isCollectionClassOrInterface(aClass)) {
    return;
  }
  registerError(selfArgument, methodName);
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
@Override
public void visitLiteralExpression(@NotNull PsiLiteralExpression value) {
  super.visitLiteralExpression(value);
  final String text = value.getText();
  if (!PsiKeyword.NULL.equals(text)) {
    return;
  }
  PsiElement parent = value.getParent();
  while (parent instanceof PsiParenthesizedExpression ||
         parent instanceof PsiConditionalExpression ||
         parent instanceof PsiTypeCastExpression) {
    parent = parent.getParent();
  }
  if (!(parent instanceof PsiReturnStatement)) {
    return;
  }
  final PsiElement element = PsiTreeUtil.getParentOfType(value, PsiMethod.class, PsiLambdaExpression.class);
  final PsiMethod method;
  final PsiType returnType;
  if (element instanceof PsiMethod) {
    method = (PsiMethod)element;
    returnType = method.getReturnType();
  } 
  else if (element instanceof PsiLambdaExpression) {
    final PsiType functionalInterfaceType = ((PsiLambdaExpression)element).getFunctionalInterfaceType();
    method = LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceType);
    returnType = LambdaUtil.getFunctionalInterfaceReturnType(functionalInterfaceType);
  } 
  else {
    return;
  }
  if (method == null || returnType == null) {
    return;
  }

  if (m_ignorePrivateMethods && method.hasModifierProperty(PsiModifier.PRIVATE)) {
    return;
  }

  final boolean isArray = returnType.getArrayDimensions() > 0;
  final NullableNotNullManager nullableNotNullManager = NullableNotNullManager.getInstance(method.getProject());
  if (nullableNotNullManager.isNullable(method, false)) {
    return;
  }
  if (CollectionUtils.isCollectionClassOrInterface(returnType)) {
    if (m_reportCollectionMethods) {
      registerError(value, value);
    }
  }
  else if (isArray) {
    if (m_reportArrayMethods) {
      registerError(value, value);
    }
  }
  else {
    if (m_reportObjectMethods) {
      registerError(value, value);
    }
  }
}
 

import com.siyeh.ig.psiutils.CollectionUtils; //导入方法依赖的package包/类
@Override
public void visitLiteralExpression(
  @NotNull PsiLiteralExpression value) {
  super.visitLiteralExpression(value);
  final String text = value.getText();
  if (!PsiKeyword.NULL.equals(text)) {
    return;
  }
  PsiElement parent = value.getParent();
  while (parent instanceof PsiParenthesizedExpression ||
         parent instanceof PsiConditionalExpression ||
         parent instanceof PsiTypeCastExpression) {
    parent = parent.getParent();
  }
  if (!(parent instanceof PsiReturnStatement)) {
    return;
  }
  final PsiMethod method =
    PsiTreeUtil.getParentOfType(value, PsiMethod.class);
  if (method == null) {
    return;
  }
  if (m_ignorePrivateMethods &&
      method.hasModifierProperty(PsiModifier.PRIVATE)) {
    return;
  }
  final PsiType returnType = method.getReturnType();
  if (returnType == null) {
    return;
  }
  final boolean isArray = returnType.getArrayDimensions() > 0;
  final NullableNotNullManager nullableNotNullManager =
    NullableNotNullManager.getInstance(method.getProject());
  if (nullableNotNullManager.isNullable(method, false)) {
    return;
  }
  if (CollectionUtils.isCollectionClassOrInterface(returnType)) {
    if (m_reportCollectionMethods) {
      registerError(value, value);
    }
  }
  else if (isArray) {
    if (m_reportArrayMethods) {
      registerError(value, value);
    }
  }
  else {
    if (m_reportObjectMethods) {
      registerError(value, value);
    }
  }
}