DfaMemoryState (Unofficial IntelliJ Community Edition API docs)

All Known Implementing Classes:

DfaMemoryStateImpl, ExpressionTypeMemoryState, TrackingDfaMemoryState
```
public interface DfaMemoryState
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`applyCondition(DfaCondition dfaCond)`
`boolean`	`applyContractCondition(DfaCondition dfaCond)`
`boolean`	`areEqual(DfaValue value1, DfaValue value2)` Returns true if given two values are known to be equal
`boolean`	`checkNotNullable(DfaValue value)`
`DfaMemoryState`	`createClosureState()`
`DfaMemoryState`	`createCopy()`
`void`	`emptyStack()`
`void`	`flushFields()`
`void`	`flushVariable(DfaVariableValue variable)`
`DfType`	`getDfType(DfaValue value)`
`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)`
`boolean`	`isEmptyStack()`
`boolean`	`isEphemeral()`
`boolean`	`isNotNull(DfaValue dfaVar)`
`boolean`	`isNull(DfaValue dfaVar)`
`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.

- Method Detail
  - createCopy
```
DfaMemoryState createCopy()
```
  - createClosureState
```
DfaMemoryState createClosureState()
```
  - pop
```
DfaValue pop()
```
    Pops single value from the top of the stack and returns it
    
    Returns:
    
    popped value
    
    Throws:
    
    java.util.EmptyStackException - if stack is empty
  - peek
```
DfaValue peek()
```
    Reads a value from the top of the stack without popping it
    
    Returns:
    
    top of stack value
    
    Throws:
    
    java.util.EmptyStackException - if stack is empty
  - getStackValue
```
DfaValue getStackValue(int offset)
```
    Reads a value from the stack at given offset from the top without popping it
    
    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
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if offset is negative
  - push
```
void push(DfaValue value)
```
    Pushes given value to the stack
    
    Parameters:
    
    value - to push
  - emptyStack
```
void emptyStack()
```
  - setVarValue
```
void setVarValue(DfaVariableValue var,
                 DfaValue value)
```
  - getRelation
```
RelationType getRelation(DfaValue left,
                         DfaValue right)
```
    Returns a relation between given values within this state, if known
    
    Parameters:
    
    left - first value
    
    right - second value
    
    Returns:
    
    a relation (EQ, NE, GT, LT), or null if not known.
  - applyCondition
```
boolean applyCondition(DfaCondition dfaCond)
```
  - areEqual
```
boolean areEqual(DfaValue value1,
                 DfaValue value2)
```
    Returns true if given two values are known to be equal
    
    Parameters:
    
    value1 - first value to check
    
    value2 - second value to check
    
    Returns:
    
    true if they are equal; false if not equal or not known
  - applyContractCondition
```
boolean applyContractCondition(DfaCondition dfaCond)
```
  - meetDfType
```
boolean meetDfType(DfaValue value,
                   DfType dfType)
```
    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.
    
    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.
  - setDfType
```
void setDfType(DfaValue value,
               DfType dfType)
```
    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 meetDfType(DfaValue, DfType) should be used as it narrows existing type.
    
    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.
  - getDfType
```
DfType getDfType(DfaValue value)
```
    Parameters:
    
    value - value to get the type of
    
    Returns:
    
    the DfType of the value within this memory state
  - getUnboxedDfType
```
DfType getUnboxedDfType(DfaValue value)
```
    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
  - getPsiType
```
PsiType getPsiType(DfaValue value)
```
    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.
  - flushFields
```
void flushFields()
```
  - flushVariable
```
void flushVariable(DfaVariableValue variable)
```
  - isNull
```
boolean isNull(DfaValue dfaVar)
```
  - checkNotNullable
```
boolean checkNotNullable(DfaValue value)
```
  - isNotNull
```
boolean isNotNull(DfaValue dfaVar)
```
  - markEphemeral
```
void markEphemeral()
```
    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.
  - isEphemeral
```
boolean isEphemeral()
```
  - isEmptyStack
```
boolean isEmptyStack()
```
  - shouldCompareByEquals
```
boolean shouldCompareByEquals(DfaValue dfaLeft,
                              DfaValue dfaRight)
```
    Returns true if two given values should be compared by content, rather than by reference.
    
    Parameters:
    
    dfaLeft - left value
    
    dfaRight - right value
    
    Returns:
    
    true if two given values should be compared by content, rather than by reference.

Interface DfaMemoryState

Method Summary

Method Detail

createCopy

createClosureState

pop

peek

getStackValue

push

emptyStack

setVarValue

getRelation

applyCondition

areEqual

applyContractCondition

meetDfType

setDfType

getDfType

getUnboxedDfType

getPsiType

flushFields

flushVariable

isNull

checkNotNullable

isNotNull

markEphemeral

isEphemeral

isEmptyStack

shouldCompareByEquals