DfaMemoryStateImpl (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- com.intellij.codeInspection.dataFlow.DfaMemoryStateImpl

All Implemented Interfaces:

DfaMemoryState

Direct Known Subclasses:

ExpressionTypeMemoryState, TrackingDfaMemoryState
```
public class DfaMemoryStateImpl
extends java.lang.Object
implements DfaMemoryState
```
Invariant: qualifiers of the variables used in myEqClasses or myVariableStates must be canonical variables where canonical variable is the minimal DfaVariableValue inside its eqClass, according to EqClass#CANONICAL_VARIABLE_COMPARATOR.

Constructor Summary

Constructors
Modifier Constructor and Description

protected DfaMemoryStateImpl(DfaMemoryStateImpl toCopy)

protected DfaMemoryStateImpl(DfaValueFactory factory)

Constructors
Modifier	Constructor and Description
`protected`	`DfaMemoryStateImpl(DfaMemoryStateImpl toCopy)`
`protected`	`DfaMemoryStateImpl(DfaValueFactory factory)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`afterMerge(DfaMemoryStateImpl other)` Custom logic to be implemented by subclasses
`boolean`	`applyCondition(DfaCondition dfaCond)`
`boolean`	`applyContractCondition(DfaCondition condition)`
`boolean`	`areEqual(DfaValue value1, DfaValue value2)` Returns true if given two values are known to be equal
`boolean`	`checkNotNullable(DfaValue value)`
`DfaMemoryStateImpl`	`createClosureState()`
`DfaMemoryStateImpl`	`createCopy()`
`protected com.intellij.codeInspection.dataFlow.DfaVariableState`	`createVariableState(DfaVariableValue var)`
`void`	`emptyStack()`
`boolean`	`equals(java.lang.Object obj)`
`protected DfType`	`filterDfTypeOnAssignment(DfaVariableValue var, DfType dfType)`
`void`	`flushFields()`
`void`	`flushVariable(DfaVariableValue variable)`
`protected void`	`flushVariable(DfaVariableValue variable, boolean shouldMarkFlushed)`
`LongRangeSet`	`getBinOpRange(DfaBinOpValue binOp)`
`DfType`	`getDfType(DfaValue value)`
`DfaValueFactory`	`getFactory()`
`PsiType`	`getPsiType(DfaValue value)`
`RelationType`	`getRelation(DfaValue left, DfaValue right)` Returns a relation between given values within this state, if known
`DfaValue`	`getStackValue(int offset)` Reads a value from the stack at given offset from the top without popping it
`DfType`	`getUnboxedDfType(DfaValue value)`
`int`	`hashCode()`
`boolean`	`isEmptyStack()`
`boolean`	`isEphemeral()`
`boolean`	`isNotNull(DfaValue dfaVar)`
`boolean`	`isNull(DfaValue dfaValue)`
`boolean`	`isSuperStateOf(DfaMemoryStateImpl that)` Returns true if current state describes all possible concrete program states described by `that` state.
`void`	`markEphemeral()` Ephemeral means a state that was created when considering a method contract and checking if one of its arguments is null.
`boolean`	`meetDfType(DfaValue value, DfType dfType)` Updates value dfType if it's compatible with current value state.
`DfaValue`	`peek()` Reads a value from the top of the stack without popping it
`DfaValue`	`pop()` Pops single value from the top of the stack and returns it
`void`	`push(DfaValue value)` Pushes given value to the stack
`void`	`setDfType(DfaValue value, DfType dfType)` Forcibly sets the supplied dfType to given value if given value state can be memoized.
`void`	`setVarValue(DfaVariableValue var, DfaValue value)`
`boolean`	`shouldCompareByEquals(DfaValue dfaLeft, DfaValue dfaRight)` Returns true if two given values should be compared by content, rather than by reference.
`java.lang.String`	`toString()`
`protected void`	`updateEquivalentVariables(DfaVariableValue dfaVar, com.intellij.codeInspection.dataFlow.DfaVariableState state)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - DfaMemoryStateImpl
```
protected DfaMemoryStateImpl(DfaValueFactory factory)
```
  - DfaMemoryStateImpl
```
protected DfaMemoryStateImpl(DfaMemoryStateImpl toCopy)
```
- Method Detail
  - getFactory
```
public DfaValueFactory getFactory()
```
  - createCopy
```
public DfaMemoryStateImpl createCopy()
```
    Specified by:
    
    createCopy in interface DfaMemoryState
  - createClosureState
```
public DfaMemoryStateImpl createClosureState()
```
    Specified by:
    
    createClosureState in interface DfaMemoryState
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - pop
```
public DfaValue pop()
```
    Description copied from interface: DfaMemoryState
    
    Pops single value from the top of the stack and returns it
    
    Specified by:
    
    pop in interface DfaMemoryState
    
    Returns:
    
    popped value
  - peek
```
public DfaValue peek()
```
    Description copied from interface: DfaMemoryState
    
    Reads a value from the top of the stack without popping it
    
    Specified by:
    
    peek in interface DfaMemoryState
    
    Returns:
    
    top of stack value
  - getStackValue
```
public DfaValue getStackValue(int offset)
```
    Description copied from interface: DfaMemoryState
    
    Reads a value from the stack at given offset from the top without popping it
    
    Specified by:
    
    getStackValue in interface DfaMemoryState
    
    Parameters:
    
    offset - value from the stack (0 = top of stack, 1 = the next one, etc.)
    
    Returns:
    
    stack value; null if stack does not deep enough
  - push
```
public void push(DfaValue value)
```
    Description copied from interface: DfaMemoryState
    
    Pushes given value to the stack
    
    Specified by:
    
    push in interface DfaMemoryState
    
    Parameters:
    
    value - to push
  - emptyStack
```
public void emptyStack()
```
    Specified by:
    
    emptyStack in interface DfaMemoryState
  - setVarValue
```
public void setVarValue(DfaVariableValue var,
                        DfaValue value)
```
    Specified by:
    
    setVarValue in interface DfaMemoryState
  - filterDfTypeOnAssignment
```
protected DfType filterDfTypeOnAssignment(DfaVariableValue var,
                                          DfType dfType)
```
  - isSuperStateOf
```
public boolean isSuperStateOf(DfaMemoryStateImpl that)
```
    Returns true if current state describes all possible concrete program states described by that state.
    
    Parameters:
    
    that - a sub-state candidate
    
    Returns:
    
    true if current state is a super-state of the supplied state.
  - shouldCompareByEquals
```
public boolean shouldCompareByEquals(DfaValue dfaLeft,
                                     DfaValue dfaRight)
```
    Description copied from interface: DfaMemoryState
    
    Returns true if two given values should be compared by content, rather than by reference.
    
    Specified by:
    
    shouldCompareByEquals in interface DfaMemoryState
    
    Parameters:
    
    dfaLeft - left value
    
    dfaRight - right value
    
    Returns:
    
    true if two given values should be compared by content, rather than by reference.
  - isNull
```
public boolean isNull(DfaValue dfaValue)
```
    Specified by:
    
    isNull in interface DfaMemoryState
  - isNotNull
```
public boolean isNotNull(DfaValue dfaVar)
```
    Specified by:
    
    isNotNull in interface DfaMemoryState
  - markEphemeral
```
public void markEphemeral()
```
    Description copied from interface: DfaMemoryState
    
    Ephemeral means a state that was created when considering a method contract and checking if one of its arguments is null. With explicit null check, that would result in any non-annotated variable being treated as nullable and producing possible NPE warnings later. With contracts, we don't want this. So the state where this variable is null is marked ephemeral and no NPE warnings are issued for such states.
    
    Specified by:
    
    markEphemeral in interface DfaMemoryState
  - isEphemeral
```
public boolean isEphemeral()
```
    Specified by:
    
    isEphemeral in interface DfaMemoryState
  - isEmptyStack
```
public boolean isEmptyStack()
```
    Specified by:
    
    isEmptyStack in interface DfaMemoryState
  - setDfType
```
public void setDfType(DfaValue value,
                      DfType dfType)
```
    Description copied from interface: DfaMemoryState
    
    Forcibly sets the supplied dfType to given value if given value state can be memoized. This is necessary to override some knowledge about the variable state. In most of the cases DfaMemoryState.meetDfType(DfaValue, DfType) should be used as it narrows existing type.
    
    Specified by:
    
    setDfType in interface DfaMemoryState
    
    Parameters:
    
    value - value to update.
    
    dfType - type to assign to value. Note that type might be adjusted, e.g. to be compatible with value declared PsiType.
  - meetDfType
```
public boolean meetDfType(DfaValue value,
                          DfType dfType)
```
    Description copied from interface: DfaMemoryState
    
    Updates value dfType if it's compatible with current value state. Depending on value passed and memory state implementation the new fact may or may not be memoized.
    
    Specified by:
    
    meetDfType in interface DfaMemoryState
    
    Parameters:
    
    value - value to update
    
    dfType - wanted type
    
    Returns:
    
    true if update was successful. If false was returned the memory state may be in inconsistent state.
  - applyContractCondition
```
public boolean applyContractCondition(DfaCondition condition)
```
    Specified by:
    
    applyContractCondition in interface DfaMemoryState
  - areEqual
```
public boolean areEqual(DfaValue value1,
                        DfaValue value2)
```
    Description copied from interface: DfaMemoryState
    
    Returns true if given two values are known to be equal
    
    Specified by:
    
    areEqual in interface DfaMemoryState
    
    Parameters:
    
    value1 - first value to check
    
    value2 - second value to check
    
    Returns:
    
    true if they are equal; false if not equal or not known
  - getRelation
```
public RelationType getRelation(DfaValue left,
                                DfaValue right)
```
    Description copied from interface: DfaMemoryState
    
    Returns a relation between given values within this state, if known
    
    Specified by:
    
    getRelation in interface DfaMemoryState
    
    Parameters:
    
    left - first value
    
    right - second value
    
    Returns:
    
    a relation (EQ, NE, GT, LT), or null if not known.
  - applyCondition
```
public boolean applyCondition(DfaCondition dfaCond)
```
    Specified by:
    
    applyCondition in interface DfaMemoryState
  - getPsiType
```
public PsiType getPsiType(DfaValue value)
```
    Specified by:
    
    getPsiType in interface DfaMemoryState
    
    Parameters:
    
    value - value to get the type of
    
    Returns:
    
    the PsiType of given value, could be more precise than the declared type. May return null if not known.
  - checkNotNullable
```
public boolean checkNotNullable(DfaValue value)
```
    Specified by:
    
    checkNotNullable in interface DfaMemoryState
  - getBinOpRange
```
public LongRangeSet getBinOpRange(DfaBinOpValue binOp)
```
  - getUnboxedDfType
```
public DfType getUnboxedDfType(DfaValue value)
```
    Specified by:
    
    getUnboxedDfType in interface DfaMemoryState
    
    Parameters:
    
    value - value to get the type of; if value is a primitive wrapper, it will be unboxed before fetching the DfType
    
    Returns:
    
    the DfType of the value within this memory state
  - getDfType
```
public DfType getDfType(DfaValue value)
```
    Specified by:
    
    getDfType in interface DfaMemoryState
    
    Parameters:
    
    value - value to get the type of
    
    Returns:
    
    the DfType of the value within this memory state
  - updateEquivalentVariables
```
protected void updateEquivalentVariables(DfaVariableValue dfaVar,
                                         com.intellij.codeInspection.dataFlow.DfaVariableState state)
```
  - createVariableState
```
protected com.intellij.codeInspection.dataFlow.DfaVariableState createVariableState(DfaVariableValue var)
```
  - flushFields
```
public void flushFields()
```
    Specified by:
    
    flushFields in interface DfaMemoryState
  - flushVariable
```
public void flushVariable(DfaVariableValue variable)
```
    Specified by:
    
    flushVariable in interface DfaMemoryState
  - flushVariable
```
protected void flushVariable(DfaVariableValue variable,
                             boolean shouldMarkFlushed)
```
  - afterMerge
```
protected void afterMerge(DfaMemoryStateImpl other)
```
    Custom logic to be implemented by subclasses
    
    Parameters:
    
    other - other memory start this one was merged with

Class DfaMemoryStateImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DfaMemoryStateImpl

DfaMemoryStateImpl

Method Detail

getFactory

createCopy

createClosureState

equals

hashCode

toString

pop

peek

getStackValue

push

emptyStack

setVarValue

filterDfTypeOnAssignment

isSuperStateOf

shouldCompareByEquals

isNull

isNotNull

markEphemeral

isEphemeral

isEmptyStack

setDfType

meetDfType

applyContractCondition

areEqual

getRelation

applyCondition

getPsiType

checkNotNullable

getBinOpRange

getUnboxedDfType

getDfType

updateEquivalentVariables

createVariableState

flushFields

flushVariable

flushVariable

afterMerge