Java DfaTypeValue类代码示例

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Nullable
public DfaVariableState withInstanceofValue(DfaTypeValue dfaType) {
  if (dfaType.getDfaType().getPsiType() instanceof PsiPrimitiveType) return this;

  if (checkInstanceofValue(dfaType.getDfaType())) {
    DfaVariableState result = dfaType.isNullable() ? withNullability(Nullness.NULLABLE) : this;
    List<DfaPsiType> moreGeneric = ContainerUtil.newArrayList();
    for (DfaPsiType alreadyInstanceof : myInstanceofValues) {
      if (dfaType.getDfaType().isAssignableFrom(alreadyInstanceof)) {
        return result;
      }
      if (alreadyInstanceof.isAssignableFrom(dfaType.getDfaType())) {
        moreGeneric.add(alreadyInstanceof);
      }
    }

    HashSet<DfaPsiType> newInstanceof = ContainerUtil.newHashSet(myInstanceofValues);
    newInstanceof.removeAll(moreGeneric);
    newInstanceof.add(dfaType.getDfaType());
    result = createCopy(newInstanceof, myNotInstanceofValues, result.myNullability);
    return result;
  }

  return null;
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Nullable
public DfaVariableState withNotInstanceofValue(DfaTypeValue dfaType) {
  if (myNotInstanceofValues.contains(dfaType.getDfaType())) return this;

  for (DfaPsiType dfaTypeValue : myInstanceofValues) {
    if (dfaType.getDfaType().isAssignableFrom(dfaTypeValue)) return null;
  }

  List<DfaPsiType> moreSpecific = ContainerUtil.newArrayList();
  for (DfaPsiType alreadyNotInstanceof : myNotInstanceofValues) {
    if (alreadyNotInstanceof.isAssignableFrom(dfaType.getDfaType())) {
      return this;
    }
    if (dfaType.getDfaType().isAssignableFrom(alreadyNotInstanceof)) {
      moreSpecific.add(alreadyNotInstanceof);
    }
  }

  HashSet<DfaPsiType> newNotInstanceof = ContainerUtil.newHashSet(myNotInstanceofValues);
  newNotInstanceof.removeAll(moreSpecific);
  newNotInstanceof.add(dfaType.getDfaType());
  return createCopy(myInstanceofValues, newNotInstanceof, myNullability);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@NotNull
private List<DfaTypeValue> allCaughtTypes(PsiParameter param)
{
	List<PsiType> psiTypes;
	PsiType type = param.getType();
	if(type instanceof PsiDisjunctionType)
	{
		psiTypes = ((PsiDisjunctionType) type).getDisjunctions();
	}
	else
	{
		psiTypes = Collections.singletonList(type);
	}
	List<DfaValue> result = psiTypes.stream().map(it -> myRunner.getFactory().createTypeValue(it, Nullness.NOT_NULL)).collect(Collectors.toList());
	return ContainerUtil.<DfaValue, DfaTypeValue>mapNotNull(result, dfaValue -> dfaValue instanceof DfaTypeValue ? (DfaTypeValue) dfaValue : null);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
/**
 * Returns DfaValue describing the return value of this contract
 *
 * @param factory       factory to create values
 * @param defaultResult default result value for the called method
 * @return a DfaValue describing the return value of this contract
 */
@NotNull
DfaValue getDfaReturnValue(DfaValueFactory factory, DfaValue defaultResult)
{
	switch(getReturnValue())
	{
		case NULL_VALUE:
			return factory.getConstFactory().getNull();
		case NOT_NULL_VALUE:
			return defaultResult instanceof DfaTypeValue ? ((DfaTypeValue) defaultResult).withNullness(Nullness.NOT_NULL) : DfaUnknownValue.getInstance();
		case TRUE_VALUE:
			return factory.getConstFactory().getTrue();
		case FALSE_VALUE:
			return factory.getConstFactory().getFalse();
		case THROW_EXCEPTION:
			return factory.getConstFactory().getContractFail();
		default:
			return defaultResult;
	}
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Override
public DfaInstructionState[] visitTypeCast(TypeCastInstruction instruction, DataFlowRunner runner, DfaMemoryState memState)
{
	final DfaValueFactory factory = runner.getFactory();
	DfaValue dfaExpr = factory.createValue(instruction.getCasted());
	if(dfaExpr != null)
	{
		DfaTypeValue dfaType = (DfaTypeValue) factory.createTypeValue(instruction.getCastTo(), Nullness.UNKNOWN);
		DfaRelationValue dfaInstanceof = factory.getRelationFactory().createRelation(dfaExpr, RelationType.IS, dfaType);
		if(dfaInstanceof != null && !memState.applyInstanceofOrNull(dfaInstanceof))
		{
			onInstructionProducesCCE(instruction);
		}
	}

	if(instruction.getCastTo() instanceof PsiPrimitiveType)
	{
		memState.push(runner.getFactory().getBoxedFactory().createUnboxed(memState.pop()));
	}

	return nextInstruction(instruction, runner, memState);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Override
public DfaInstructionState[] visitCheckNotNull(CheckNotNullInstruction instruction, DataFlowRunner runner, DfaMemoryState memState)
{
	if(!checkNotNullable(memState, memState.peek(), instruction.getProblem(), instruction.getExpression()))
	{
		DfaValue arg = memState.peek();
		if(arg instanceof DfaVariableValue)
		{
			DfaVariableValue var = (DfaVariableValue) arg;
			memState.setVarValue(var, runner.getFactory().createTypeValue(var.getVariableType(), Nullness.NOT_NULL));
		}
		else if(arg instanceof DfaTypeValue)
		{
			memState.pop();
			memState.push(((DfaTypeValue) arg).withNullness(Nullness.NOT_NULL));
		}
		else if(memState.isNull(arg) && instruction.getProblem() == NullabilityProblem.nullableFunctionReturn)
		{
			memState.pop();
			memState.push(runner.getFactory().createTypeValue(PsiType.VOID, Nullness.NOT_NULL));
		}
	}
	return super.visitCheckNotNull(instruction, runner, memState);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
private void handleInstanceof(InstanceofInstruction instruction, DfaValue dfaRight, DfaValue dfaLeft)
{
	if(dfaLeft instanceof DfaTypeValue && dfaRight instanceof DfaTypeValue)
	{
		if(!((DfaTypeValue) dfaLeft).isNotNull())
		{
			myCanBeNullInInstanceof.add(instruction);
		}

		if(((DfaTypeValue) dfaRight).getDfaType().isAssignableFrom(((DfaTypeValue) dfaLeft).getDfaType()))
		{
			return;
		}
	}
	myUsefulInstanceofs.add(instruction);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Nullable
@Override
Boolean fromDfaValue(DfaValue value)
{
	if(value instanceof DfaConstValue)
	{
		return ((DfaConstValue) value).getValue() == null;
	}
	if(value instanceof DfaBoxedValue || value instanceof DfaUnboxedValue || value instanceof DfaRangeValue)
	{
		return false;
	}
	if(value instanceof DfaTypeValue)
	{
		return NullnessUtil.toBoolean(((DfaTypeValue) value).getNullness());
	}
	return null;
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
public boolean setInstanceofValue(DfaTypeValue dfaType) {
  if (dfaType.isNullable()) {
    myNullability = Nullness.NULLABLE;
  }

  if (dfaType.getType() instanceof PsiPrimitiveType) return true;

  if (checkInstanceofValue(dfaType)) {
    myInstanceofValues.add(dfaType);
    return true;
  }

  return false;
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
public boolean addNotInstanceofValue(DfaTypeValue dfaType) {
  if (myNotInstanceofValues.contains(dfaType)) return true;

  for (DfaTypeValue dfaTypeValue : myInstanceofValues) {
    if (dfaType.isAssignableFrom(dfaTypeValue)) return false;
  }

  myNotInstanceofValues.add(dfaType);
  return true;
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@NotNull
private List<DfaInstructionState> processCatches(Trap.TryCatch tryCatch, DfaValue thrownValue, FList<Trap> traps)
{
	List<DfaInstructionState> result = new ArrayList<>();
	for(Map.Entry<PsiCatchSection, ControlFlow.ControlFlowOffset> entry : tryCatch.getClauses().entrySet())
	{
		PsiCatchSection catchSection = entry.getKey();
		ControlFlow.ControlFlowOffset jumpOffset = entry.getValue();

		PsiParameter param = catchSection.getParameter();
		if(param == null)
		{
			continue;
		}

		if(throwableState == null)
		{
			throwableState = initVariableState(param, thrownValue);
		}

		for(DfaTypeValue caughtType : allCaughtTypes(param))
		{
			DfaVariableState varState = throwableState.withInstanceofValue(caughtType);
			if(varState != null)
			{
				result.add(new DfaInstructionState(myRunner.getInstruction(jumpOffset.getInstructionOffset()), stateForCatchClause(param, varState)));
			}

			throwableState = throwableState.withNotInstanceofValue(caughtType);

			if(throwableState == null)
			{
				return result;
			}
		}
	}
	return ContainerUtil.concat(result, iteration(traps));
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@NotNull
private DfaVariableState initVariableState(PsiParameter param, DfaValue throwable)
{
	DfaVariableValue sampleVar = ((DfaMemoryStateImpl) myState).getFactory().getVarFactory().createVariableValue(param, false);
	DfaVariableState varState = ((DfaMemoryStateImpl) myState).createVariableState(sampleVar).withFact(DfaFactType.CAN_BE_NULL, false);
	if(throwable instanceof DfaTypeValue)
	{
		return Objects.requireNonNull(varState.withInstanceofValue((DfaTypeValue) throwable));
	}
	else
	{
		return varState;
	}
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Nullable
DfaVariableState withInstanceofValue(@NotNull DfaTypeValue dfaType)
{
	if(dfaType.getDfaType().getPsiType() instanceof PsiPrimitiveType)
	{
		return this;
	}

	if(checkInstanceofValue(dfaType.getDfaType()))
	{
		DfaVariableState result = dfaType.isNullable() ? withFact(DfaFactType.CAN_BE_NULL, true) : this;
		List<DfaPsiType> moreGeneric = ContainerUtil.newArrayList();
		for(DfaPsiType alreadyInstanceof : myInstanceofValues)
		{
			if(dfaType.getDfaType().isAssignableFrom(alreadyInstanceof))
			{
				return result;
			}
			if(alreadyInstanceof.isAssignableFrom(dfaType.getDfaType()))
			{
				moreGeneric.add(alreadyInstanceof);
			}
		}

		HashSet<DfaPsiType> newInstanceof = ContainerUtil.newHashSet(myInstanceofValues);
		newInstanceof.removeAll(moreGeneric);
		newInstanceof.add(dfaType.getDfaType());
		result = createCopy(newInstanceof, myNotInstanceofValues, result.myFactMap);
		return result;
	}

	return null;
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
@Nullable
DfaVariableState withNotInstanceofValue(@NotNull DfaTypeValue dfaType)
{
	if(myNotInstanceofValues.contains(dfaType.getDfaType()))
	{
		return this;
	}

	for(DfaPsiType dfaTypeValue : myInstanceofValues)
	{
		if(dfaType.getDfaType().isAssignableFrom(dfaTypeValue))
		{
			return null;
		}
	}

	List<DfaPsiType> moreSpecific = ContainerUtil.newArrayList();
	for(DfaPsiType alreadyNotInstanceof : myNotInstanceofValues)
	{
		if(alreadyNotInstanceof.isAssignableFrom(dfaType.getDfaType()))
		{
			return this;
		}
		if(dfaType.getDfaType().isAssignableFrom(alreadyNotInstanceof))
		{
			moreSpecific.add(alreadyNotInstanceof);
		}
	}

	HashSet<DfaPsiType> newNotInstanceof = ContainerUtil.newHashSet(myNotInstanceofValues);
	newNotInstanceof.removeAll(moreSpecific);
	newNotInstanceof.add(dfaType.getDfaType());
	return createCopy(myInstanceofValues, newNotInstanceof, myFactMap);
}
 

import com.intellij.codeInspection.dataFlow.value.DfaTypeValue; //导入依赖的package包/类
public DfaVariableState(@NotNull DfaVariableValue dfaVar) {
  myInstanceofValues = new HashSet<DfaTypeValue>();
  myNotInstanceofValues = new HashSet<DfaTypeValue>();

  myNullability = dfaVar.getInherentNullability();
}