Enum DataflowKind 

pub enum DataflowKind {
    Definition,
    Use,
    Mutation,
    Return,
    Param,
    Yield,
    ComprehensionVar,
    LambdaParam,
    Global,
    Nonlocal,
    NestedParam,
    ClosureCapture,
    Goroutine,
    ChannelSend,
    ChannelReceive,
    Defer,
    TypeAssertion,
    Panic,
    Recover,
    ErrorAssign,
    ErrorCheck,
    NamedReturnModify,
    ChannelMake,
    ChannelCloseDfg,
    SelectReceive,
    SelectSend,
    MutexLock,
    MutexUnlock,
    WaitGroupAdd,
    WaitGroupDone,
    WaitGroupWait,
    OnceDo,
    ContextDone,
    ContextErr,
    ContextValue,
    PoolGet,
    PoolPut,
}

Kind of data flow.

Variants

Definition

Variable is defined

Use

Variable is read

Mutation

Variable is mutated

Return

Value is returned

Param

Function parameter

Yield

Value is yielded from generator

ComprehensionVar

Comprehension-scoped variable (does not leak to outer scope in Python 3)

LambdaParam

Lambda parameter (scoped to lambda body)

Global

BUG-017 FIX: Variable declared as global (references module-level scope)

Nonlocal

BUG-017 FIX: Variable declared as nonlocal (references enclosing function scope)

NestedParam

Nested function parameter (scoped to nested function body, used for closure analysis)

ClosureCapture

Closure capture: use of outer variable from within nested function

Goroutine

Go: Variable captured/used in goroutine (go func() {…})

ChannelSend

Go: Channel send operation (ch <- val)

ChannelReceive

Go: Channel receive operation (val := <-ch)

Defer

Go: Deferred call (defer f())

TypeAssertion

Go: Type assertion (x.(Type))

Panic

Go: Panic call (panic(err))

Recover

Go: Recover call in deferred function (recover())

ErrorAssign

Go: Error value assigned (err := …)

ErrorCheck

Go: Error check (if err != nil)

NamedReturnModify

Go: Named return value modified in defer

ChannelMake

Go: Channel creation (make(chan T) or make(chan T, size))

ChannelCloseDfg

Go: Channel close operation (close(ch))

SelectReceive

Go: Select statement receive (case val := <-ch:)

SelectSend

Go: Select statement send (case ch <- val:)

MutexLock

Go: Mutex lock (mu.Lock() or mu.RLock())

MutexUnlock

Go: Mutex unlock (mu.Unlock() or mu.RUnlock())

WaitGroupAdd

Go: WaitGroup.Add() operation

WaitGroupDone

Go: WaitGroup.Done() operation

WaitGroupWait

Go: WaitGroup.Wait() synchronization point

OnceDo

Go: sync.Once.Do() call

ContextDone

Go: Context.Done() check for cancellation

ContextErr

Go: Context.Err() check for cancellation reason

ContextValue

Go: Context.Value() retrieval

PoolGet

Go: sync.Pool.Get()

PoolPut

Go: sync.Pool.Put()

Trait Implementations

impl Clone for DataflowKind

fn clone(&self) -> DataflowKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataflowKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataflowKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DataflowKind

fn eq(&self, other: &DataflowKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DataflowKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DataflowKind

impl Eq for DataflowKind

impl StructuralPartialEq for DataflowKind