Java Nullness.UNKNOWN屬性代碼示例

private Nullness calcInherentNullability() {
  PsiMethod accessMethod = myAccessMethod;
  Nullness nullability = DfaPsiUtil.getElementNullability(getVariableType(), accessMethod);
  if (nullability != Nullness.UNKNOWN) {
    return nullability;
  }

  PsiVariable var = getPsiVariable();
  nullability = DfaPsiUtil.getElementNullability(getVariableType(), var);
  if (nullability != Nullness.UNKNOWN) {
    return nullability;
  }

  if (var != null) {
    if (DfaPsiUtil.isNullableInitialized(var, true)) {
      return Nullness.NULLABLE;
    }
    if (DfaPsiUtil.isNullableInitialized(var, false)) {
      return Nullness.NOT_NULL;
    }
  }

  return Nullness.UNKNOWN;
}
 

@NotNull
private static Nullness extractNullityFromWhenValue(PsiAnnotation nonNull)
{
	PsiAnnotationMemberValue when = nonNull.findAttributeValue("when");
	if(when instanceof PsiReferenceExpression)
	{
		String refName = ((PsiReferenceExpression) when).getReferenceName();
		if("ALWAYS".equals(refName))
		{
			return Nullness.NOT_NULL;
		}
		if("MAYBE".equals(refName) || "NEVER".equals(refName))
		{
			return Nullness.NULLABLE;
		}
	}
	return Nullness.UNKNOWN;
}
 

private static Nullness getFieldInitializerNullness(@NotNull PsiExpression expression) {
  if (expression.textMatches(PsiKeyword.NULL)) return Nullness.NULLABLE;
  if (expression instanceof PsiNewExpression || expression instanceof PsiLiteralExpression || expression instanceof PsiPolyadicExpression) return Nullness.NOT_NULL;
  if (expression instanceof PsiReferenceExpression) {
    PsiElement target = ((PsiReferenceExpression)expression).resolve();
    return DfaPsiUtil.getElementNullability(null, (PsiModifierListOwner)target);
  }
  if (expression instanceof PsiMethodCallExpression) {
    PsiMethod method = ((PsiMethodCallExpression)expression).resolveMethod();
    return method != null ? DfaPsiUtil.getElementNullability(null, method) : Nullness.UNKNOWN;
  }
  return Nullness.UNKNOWN;
}
 

@NotNull
public Nullness suggestNullabilityForNonAnnotatedMember(@NotNull PsiModifierListOwner member)
{
	if(myUnknownMembersAreNullable && MEMBER_OR_METHOD_PARAMETER.accepts(member) && AnnotationUtil.getSuperAnnotationOwners(member).isEmpty())
	{
		return Nullness.NULLABLE;
	}

	return Nullness.UNKNOWN;
}
 

public MethodCallInstruction(@NotNull PsiExpression context, MethodType methodType, @Nullable PsiType resultType)
{
	myContext = context;
	myContracts = Collections.emptyList();
	myMethodType = methodType;
	myArgCount = 0;
	myType = resultType;
	myShouldFlushFields = false;
	myPrecalculatedReturnValue = null;
	myTargetMethod = null;
	myVarArgCall = false;
	myArgRequiredNullability = EMPTY_NULLNESS_ARRAY;
	myReturnNullability = Nullness.UNKNOWN;
}
 

private static Nullness getNickNamedNullability(@NotNull PsiClass psiClass)
{
	if(AnnotationUtil.findAnnotation(psiClass, TYPE_QUALIFIER_NICKNAME) == null)
	{
		return Nullness.UNKNOWN;
	}

	PsiAnnotation nonNull = AnnotationUtil.findAnnotation(psiClass, JAVAX_ANNOTATION_NONNULL);
	return nonNull != null ? extractNullityFromWhenValue(nonNull) : Nullness.UNKNOWN;
}
 

private Nullness calcInherentNullability() {
  PsiModifierListOwner var = getPsiVariable();
  Nullness nullability = DfaPsiUtil.getElementNullability(getVariableType(), var);
  if (nullability != Nullness.UNKNOWN) {
    return nullability;
  }

  Nullness defaultNullability = myFactory.isUnknownMembersAreNullable() && MEMBER_OR_METHOD_PARAMETER.accepts(var) ? Nullness.NULLABLE : Nullness.UNKNOWN;

  if (var instanceof PsiParameter && var.getParent() instanceof PsiForeachStatement) {
    PsiExpression iteratedValue = ((PsiForeachStatement)var.getParent()).getIteratedValue();
    if (iteratedValue != null) {
      PsiType itemType = JavaGenericsUtil.getCollectionItemType(iteratedValue);
      if (itemType != null) {
        return DfaPsiUtil.getElementNullability(itemType, var);
      }
    }
  }

  if (var instanceof PsiField && DfaPsiUtil.isFinalField((PsiVariable)var) && myFactory.isHonorFieldInitializers()) {
    List<PsiExpression> initializers = DfaPsiUtil.findAllConstructorInitializers((PsiField)var);
    if (initializers.isEmpty()) {
      return defaultNullability;
    }

    boolean hasUnknowns = false;
    for (PsiExpression expression : initializers) {
      Nullness nullness = getFieldInitializerNullness(expression);
      if (nullness == Nullness.NULLABLE) {
        return Nullness.NULLABLE;
      }
      if (nullness == Nullness.UNKNOWN) {
        hasUnknowns = true;
      }
    }
    
    if (hasUnknowns) {
      if (DfaPsiUtil.isInitializedNotNull((PsiField)var)) {
        return Nullness.NOT_NULL;
      }
      return defaultNullability;
    }
    
    return Nullness.NOT_NULL;
  }

  return defaultNullability;
}
 

@NotNull
private static Nullness checkNullness(final PsiElement element) {
  // null
  PsiElement value = element;
  if (value instanceof PsiExpression) {
    value = PsiUtil.deparenthesizeExpression((PsiExpression)value);
  }
  if (value instanceof PsiLiteralExpression) {
    return ((PsiLiteralExpression)value).getValue() == null ? Nullness.NULLABLE : Nullness.NOT_NULL;
  }

  // not null
  if (value instanceof PsiNewExpression) return Nullness.NOT_NULL;
  if (value instanceof PsiThisExpression) return Nullness.NOT_NULL;
  if (value instanceof PsiMethodCallExpression) {
    PsiMethod method = ((PsiMethodCallExpression)value).resolveMethod();
    if (method != null && NullableNotNullManager.isNotNull(method)) return Nullness.NOT_NULL;
    if (method != null && NullableNotNullManager.isNullable(method)) return Nullness.NULLABLE;
  }
  if (value instanceof PsiPolyadicExpression && ((PsiPolyadicExpression)value).getOperationTokenType() == JavaTokenType.PLUS) {
    return Nullness.NOT_NULL; // "xxx" + var
  }

  // unfortunately have to resolve here, since there can be no subnodes
  PsiElement context = value;
  if (value instanceof PsiReference) {
    PsiElement resolved = ((PsiReference)value).resolve();
    if (resolved instanceof PsiCompiledElement) {
      resolved = resolved.getNavigationElement();
    }
    value = resolved;
  }
  if (value instanceof PsiParameter && ((PsiParameter)value).getDeclarationScope() instanceof PsiCatchSection) {
    // exception thrown is always not null
    return Nullness.NOT_NULL;
  }

  if (value instanceof PsiLocalVariable || value instanceof PsiParameter) {
    Nullness result = DfaUtil.checkNullness((PsiVariable)value, context);
    if (result != Nullness.UNKNOWN) {
      return result;
    }
  }

  if (value instanceof PsiModifierListOwner) {
    if (NullableNotNullManager.isNotNull((PsiModifierListOwner)value)) return Nullness.NOT_NULL;
    if (NullableNotNullManager.isNullable((PsiModifierListOwner)value)) return Nullness.NULLABLE;
  }

  if (value instanceof PsiEnumConstant) return Nullness.NOT_NULL;
  return Nullness.UNKNOWN;
}