annotation

type AffiliationPair ¶

type AffiliationPair struct {
	ImplementingMethod *types.Func
	InterfaceMethod    *types.Func
}

An AffiliationPair is the atomic object of the affiliations mechanism: a pair consisting of an interface method and an implementing method

type ArgFldPass ¶

type ArgFldPass struct {
	*TriggerIfNonNil
	IsPassed bool
}

ArgFldPass is when a struct field value (A.f) flows to a point where it is passed to a function with a param of the same struct type (A)

func (f *ArgFldPass) Copy() ConsumingAnnotationTrigger

func (f *ArgFldPass) Repr() fmt.Stringer

func (a ArgFldPass) String() string

type ArgFldPassRepr ¶

type ArgFldPassRepr struct {
	FieldName     string
	FuncName      string
	ParamNum      int
	RecvName      string
	IsPassed      bool
	AssignmentStr string
}

ArgFldPassRepr is a fmt.Stringer storing the needed information to compactly encode a ArgFldPass

func (f ArgFldPassRepr) String() string

type ArgLocAndVal ¶

type ArgLocAndVal struct {
	Location token.Position
	Val      Val
}

ArgLocAndVal pairs the code location of the argument expression and the annotation value.

type ArgPass ¶

type ArgPass struct {
	*TriggerIfNonNil
}

ArgPass is when a value flows to a point where it is passed as an argument to a function. This consumer trigger can be used on top of two different sites: ParamAnnotationKey & CallSiteParamAnnotationKey. ParamAnnotationKey is the parameter site in the function declaration; CallSiteParamAnnotationKey is the argument site in the call expression. CallSiteParamAnnotationKey is specifically used for functions with contracts since we need to duplicate the sites for context sensitivity.

func (a *ArgPass) Copy() ConsumingAnnotationTrigger

func (a *ArgPass) Repr() fmt.Stringer

func (a ArgPass) String() string

type ArgPassDeep ¶

type ArgPassDeep struct {
	*TriggerIfDeepNonNil
}

ArgPassDeep is when a value deeply flows to a point where it is passed as an argument to a function

func (a *ArgPassDeep) Copy() ConsumingAnnotationTrigger

func (a *ArgPassDeep) Repr() fmt.Stringer

func (a ArgPassDeep) String() string

type ArgPassDeepRepr ¶

type ArgPassDeepRepr struct {
	ParamName string
	FuncName  string
	// Location points to the code location of the argument pass at the call site for a ArgPass
	// enclosing CallSiteParamAnnotationKey; Location is empty for a ArgPass enclosing ParamAnnotationKey.
	Location      string
	AssignmentStr string
}

ArgPassDeepRepr is a fmt.Stringer storing the needed information to compactly encode a ArgPassDeep

func (a ArgPassDeepRepr) String() string

type ArgPassRepr ¶

type ArgPassRepr struct {
	ParamName string
	FuncName  string
	// Location points to the code location of the argument pass at the call site for a ArgPass
	// enclosing CallSiteParamAnnotationKey; Location is empty for a ArgPass enclosing ParamAnnotationKey.
	Location      string
	AssignmentStr string
}

ArgPassRepr is a fmt.Stringer storing the needed information to compactly encode a ArgPass

func (a ArgPassRepr) String() string

type ArrayAssign ¶

type ArrayAssign struct {
	*TriggerIfDeepNonNil
}

ArrayAssign is when a value flows to a point where it is assigned into an array

func (a *ArrayAssign) Copy() ConsumingAnnotationTrigger

func (a *ArrayAssign) Repr() fmt.Stringer

func (a ArrayAssign) String() string

type ArrayAssignRepr ¶

type ArrayAssignRepr struct {
	TypeName      string
	AssignmentStr string
}

ArrayAssignRepr is a fmt.Stringer storing the needed information to compactly encode a SliceAssign

func (a ArrayAssignRepr) String() string

type ArrayRead ¶

type ArrayRead struct {
	*TriggerIfDeepNilable
}

ArrayRead is when a value is determined to flow from an array index expression

func (a *ArrayRead) Repr() fmt.Stringer

type ArrayReadRepr ¶

type ArrayReadRepr struct {
	TypeName string
}

ArrayReadRepr is a fmt.Stringer storing the needed information to compactly encode a ArrayRead

func (a ArrayReadRepr) String() string

type Assignment ¶

type Assignment struct {
	LHSExprStr string
	RHSExprStr string
	Position   token.Position
}

Assignment is a struct that represents an assignment to an expression

func (a *Assignment) String() string

type BlankVarReturn ¶

type BlankVarReturn struct {
	*ProduceTriggerTautology
}

BlankVarReturn is when a value is determined to flow from a blank variable ('_') to a return of the function

func (*BlankVarReturn) Repr() fmt.Stringer

type BlankVarReturnRepr ¶

type BlankVarReturnRepr struct{}

BlankVarReturnRepr is a fmt.Stringer storing the needed information to compactly encode a BlankVarReturn

func (BlankVarReturnRepr) String() string

type CallSite ¶

type CallSite struct {
	Fun      *types.Func
	Location token.Position
}

CallSite uniquely identifies a function call. It contains the called function object and the code location of the call expression.

type CallSiteParamAnnotationKey ¶

type CallSiteParamAnnotationKey struct {
	FuncDecl *types.Func
	ParamNum int
	Location token.Position
}

CallSiteParamAnnotationKey is similar to ParamAnnotationKey but it represents the site in the caller where the actual argument is passed to the called function. For the same parameter of the same function, there is only one distinct ParamAnnotationKey but there is a new CallSiteParamAnnotationKey for the parameter for every call of the same function.

func NewCallSiteParamKey(
	fdecl *types.Func, num int, location token.Position) *CallSiteParamAnnotationKey

func (pk *CallSiteParamAnnotationKey) Lookup(annMap Map) (Val, bool)

func (pk *CallSiteParamAnnotationKey) MinimalString() string

func (pk *CallSiteParamAnnotationKey) Object() types.Object

func (pk *CallSiteParamAnnotationKey) ParamName() *types.Var

func (pk *CallSiteParamAnnotationKey) ParamNameString() string

func (pk *CallSiteParamAnnotationKey) String() string

type CallSiteRetAnnotationKey ¶

type CallSiteRetAnnotationKey struct {
	FuncDecl *types.Func
	RetNum   int // which result
	Location token.Position
}

CallSiteRetAnnotationKey is similar to RetAnnotationKey, but it represents the site in the caller where the actual result is returned from the function. For the same return result of the same function, there is only one distinct RetAnnotationKey but there is a new CallSiteRetAnnotationKey for the return result for every call of the same function.

func NewCallSiteRetKey(fdecl *types.Func, retNum int, location token.Position) *CallSiteRetAnnotationKey

func (rk *CallSiteRetAnnotationKey) Lookup(annMap Map) (Val, bool)

func (rk *CallSiteRetAnnotationKey) Object() types.Object

func (rk *CallSiteRetAnnotationKey) String() string

type ChanRecv ¶

type ChanRecv struct {
	*TriggerIfDeepNilable
}

ChanRecv is when a value is determined to flow from a channel receive

func (c *ChanRecv) Repr() fmt.Stringer

type ChanRecvRepr ¶

type ChanRecvRepr struct {
	TypeName string
}

ChanRecvRepr is a fmt.Stringer storing the needed information to compactly encode a ChanRecv

func (c ChanRecvRepr) String() string

type ChanSend ¶

type ChanSend struct {
	*TriggerIfDeepNonNil
}

ChanSend is when a value flows to a point where it is sent to a channel

func (c *ChanSend) Copy() ConsumingAnnotationTrigger

func (c *ChanSend) Repr() fmt.Stringer

func (a ChanSend) String() string

type ChanSendRepr ¶

type ChanSendRepr struct {
	TypeName      string
	AssignmentStr string
}

ChanSendRepr is a fmt.Stringer storing the needed information to compactly encode a ChanSend

func (c ChanSendRepr) String() string

type ConstNil ¶

type ConstNil struct {
	*ProduceTriggerTautology
}

ConstNil is when a value is determined to flow from a constant nil expression

func (*ConstNil) Repr() fmt.Stringer

type ConstNilRepr ¶

type ConstNilRepr struct{}

ConstNilRepr is a fmt.Stringer storing the needed information to compactly encode a ConstNil

func (ConstNilRepr) String() string

type ConsumeTrigger ¶

type ConsumeTrigger struct {
	Annotation   ConsumingAnnotationTrigger
	Expr         ast.Expr
	Guards       guard.NonceSet
	GuardMatched bool
}

A ConsumeTrigger represents a point at which a value is consumed that may be required to be non-nil by some Annotation (ConsumingAnnotationTrigger). If Parent is not a RootAssertionNode, then that AssertionNode represents the expression that will flow into this consumption point. If Parent is a RootAssertionNode, then it will be paired with a ProduceTrigger

Expr should be the expression being consumed, not the expression doing the consumption. For example, if the field access x.f requires x to be non-nil, then x should be the expression embedded in the ConsumeTrigger not x.f.

The set Guards indicates whether this consumption takes places in a context in which it is known to be _guarded_ by one or more conditional checks that refine its behavior. This is not _all_ conditional checks this is a very small subset of them. Consume triggers become guarded via backpropagation across a check that `propagateRichChecks` identified with a `RichCheckEffect`. This pass will embed a call to `ConsumeTriggerSliceAsGuarded` that will modify all consume triggers for the value targeted by the check as guarded by the guard nonces of the flowed `RichCheckEffect`.

Like a nil check, guarding is used to indicate information refinement local to one branch. The presence of a guard is overwritten by the absence of a guard on a given ConsumeTrigger - see MergeConsumeTriggerSlices. Beyond RichCheckEffects, Guards consume triggers can be introduced by other sites that are known to obey compatible semantics - such as passing the results of one error-returning function directly to a return of another.

ConsumeTriggers arise at consumption sites that may guarded by a meaningful conditional check, adding that guard as a unique nonce to the set Guards of the trigger. The guard is added when the trigger is propagated across the check, so that when it reaches the statement that relies on the guard, the statement can see that the check was performed around the site of the consumption. This allows the statement to switch to more permissive semantics.

GuardMatched is a boolean used to indicate that this ConsumeTrigger, by the current point in backpropagation, passed through a conditional that granted it a guard, and that that guard was determined to match the guard expected by a statement such as `v, ok := m[k]`. Since there could have been multiple paths in the CFG between the current point in backpropagation and the site at which the trigger arose, GuardMatched is true only if a guard arose and was matched along every path. This allows the trigger to maintain its more permissive semantics in later stages of backpropagation.

For some productions, such as reading an index of a map, there is no way for them to generate nonnil without such a guarding along every path to their point of consumption, so if GuardMatched is not true then they will be replaced (by `checkGuardOnFullTrigger`) with an always-produce-nil producer. More explanation of this mechanism is provided in the documentation for `RootAssertionNode.AddGuardMatch`

nonnil(Guards)

func ConsumeTriggerSliceAsGuarded(slice []*ConsumeTrigger, guards ...guard.Nonce) []*ConsumeTrigger

func DuplicateReturnConsumer(t *ConsumeTrigger, location token.Position) *ConsumeTrigger

func GetEscapeFldConsumer(escKey Key, selExpr ast.Expr) *ConsumeTrigger

func GetParamFldConsumer(paramKey Key, expr ast.Expr) *ConsumeTrigger

func GetRetFldConsumer(retKey Key, expr ast.Expr) *ConsumeTrigger

func MergeConsumeTriggerSlices(left, right []*ConsumeTrigger) []*ConsumeTrigger

func (c *ConsumeTrigger) Copy() *ConsumeTrigger

func (c *ConsumeTrigger) Pos() token.Pos

type ConsumeTriggerTautology ¶

type ConsumeTriggerTautology struct {
	IsGuardNotNeeded bool // ConsumeTriggers need guards by default, when applicable. Set this to true when guards are not needed.
	// contains filtered or unexported fields
}

ConsumeTriggerTautology is used at consumption sites were consuming nil is always an error

func (c *ConsumeTriggerTautology) AddAssignment(e Assignment)

func (*ConsumeTriggerTautology) CheckConsume(Map) bool

func (c *ConsumeTriggerTautology) Copy() ConsumingAnnotationTrigger

func (*ConsumeTriggerTautology) Kind() TriggerKind

func (c *ConsumeTriggerTautology) NeedsGuard() bool

func (c *ConsumeTriggerTautology) Repr() fmt.Stringer

func (c *ConsumeTriggerTautology) SetNeedsGuard(b bool)

func (a *ConsumeTriggerTautology) String() string

func (*ConsumeTriggerTautology) UnderlyingSite() Key

type ConsumeTriggerTautologyRepr ¶

type ConsumeTriggerTautologyRepr struct {
	AssignmentStr string
}

ConsumeTriggerTautologyRepr is a fmt.Stringer storing the needed information to compactly encode a ConsumeTriggerTautology

func (c ConsumeTriggerTautologyRepr) String() string

type ConsumingAnnotationTrigger ¶

type ConsumingAnnotationTrigger interface {
	// CheckConsume can be called to determined whether this trigger should be triggered
	// given a particular Annotation map
	// for example - an `ArgPass` trigger triggers iff the corresponding function arg has
	// nonNil type
	CheckConsume(Map) bool
	Repr() fmt.Stringer

	// Kind returns the kind of the trigger.
	Kind() TriggerKind

	// UnderlyingSite returns the underlying site this trigger's nilability depends on. If the
	// trigger always or never fires, the site is nil.
	UnderlyingSite() Key

	// Copy returns a deep copy of this ConsumingAnnotationTrigger
	Copy() ConsumingAnnotationTrigger

	// AddAssignment adds an assignment to the trigger for tracking and printing informative error message.
	// NilAway's `backpropAcrossOneToOneAssignment()` lifts consumer triggers from the RHS of an assignment to the LHS.
	// This implies loss of information about the assignment. This method is used to track such assignments and print
	// a more informative error message.
	AddAssignment(Assignment)

	// NeedsGuard returns true if the trigger needs to be guarded, for example, by a nil check or an ok form.
	NeedsGuard() bool

	// SetNeedsGuard sets the underlying Guard-Neediness of this ConsumerTrigger, if present.
	// Default setting for ConsumerTriggers is that they need a guard. Override this method to set the need for a guard to false.
	SetNeedsGuard(bool)
	// contains filtered or unexported methods
}

A ConsumingAnnotationTrigger indicated a possible reason that a nil flow to this site would indicate an error

All ConsumingAnnotationTriggers must embed one of the following 3 structs: -TriggerIfNonnil -TriggerIfDeepNonnil -ConsumeTriggerTautology

type DeepAssignPrimitive ¶

type DeepAssignPrimitive struct {
	*ConsumeTriggerTautology
}

DeepAssignPrimitive is when a value flows to a point where it is assigned deeply into an unnannotated object

func (d *DeepAssignPrimitive) Copy() ConsumingAnnotationTrigger

func (d *DeepAssignPrimitive) Repr() fmt.Stringer

func (a DeepAssignPrimitive) String() string

type DeepAssignPrimitiveRepr ¶

type DeepAssignPrimitiveRepr struct {
	AssignmentStr string
}

DeepAssignPrimitiveRepr is a fmt.Stringer storing the needed information to compactly encode a DeepAssignPrimitive

func (d DeepAssignPrimitiveRepr) String() string

type EscapeFieldAnnotationKey ¶

type EscapeFieldAnnotationKey struct {
	FieldDecl *types.Var
}

EscapeFieldAnnotationKey allows the Lookup of a field's Annotation in the Annotation map For fields of depth 1, with struct initialization check, we track the nilability using param field and return field. Anything that is not trackable using those, rely on the default nilability of the field. Thus, we use the escape information for choosing the nilability of the fields that we do not track. The annotation site is only used when the struct initialization check is enabled. The trigger that uses this key creates constraints on escaping fields. We create constraints only on the fields that have nilable type. There are 2 cases, that we currently consider as escaping: 1. If a struct is returned from the function where the field has nilable value, e.g, If aptr is pointer in struct A, then `return &A{}` causes the field aptr to escape 2. If a struct is parameter of a function and the field is not initialized e.g., if we have fun(&A{}) then the field aptr is considered escaped TODO: Add struct assignment as another possible cause of field escape

func NewEscapeFldAnnKey(fieldObj *types.Var) *EscapeFieldAnnotationKey

func (ek *EscapeFieldAnnotationKey) Lookup(_ Map) (Val, bool)

func (ek *EscapeFieldAnnotationKey) Object() types.Object

func (ek *EscapeFieldAnnotationKey) String() string

type ExprOkCheck ¶

type ExprOkCheck struct {
	*ProduceTriggerNever
}

ExprOkCheck is used when a value is determined to flow from the second argument of a map or typecast operation that necessarily makes it boolean and thus non-nil

type FieldAnnotationKey ¶

type FieldAnnotationKey struct {
	FieldDecl *types.Var
}

FieldAnnotationKey allows the Lookup of a field's Annotation in the Annotation map

func (k *FieldAnnotationKey) Lookup(annMap Map) (Val, bool)

func (k *FieldAnnotationKey) Object() types.Object

func (k *FieldAnnotationKey) String() string

type FieldAssignDeep ¶

type FieldAssignDeep struct {
	*TriggerIfDeepNonNil
}

FieldAssignDeep is when a value flows to a point where it is assigned deeply into a field

func (f *FieldAssignDeep) Copy() ConsumingAnnotationTrigger

func (f *FieldAssignDeep) Repr() fmt.Stringer

func (a FieldAssignDeep) String() string

type FieldAssignDeepRepr ¶

type FieldAssignDeepRepr struct {
	FldName       string
	AssignmentStr string
}

FieldAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a FieldAssignDeep

func (f FieldAssignDeepRepr) String() string

type FldAccess ¶

type FldAccess struct {
	*ConsumeTriggerTautology

	Sel types.Object
}

FldAccess is when a value flows to a point where a field of it is accessed, and so it must be non-nil

func (f *FldAccess) Copy() ConsumingAnnotationTrigger

func (f *FldAccess) Repr() fmt.Stringer

func (a FldAccess) String() string

type FldAccessRepr ¶

type FldAccessRepr struct {
	FieldName     string
	MethodName    string
	AssignmentStr string
}

FldAccessRepr is a fmt.Stringer storing the needed information to compactly encode a FldAccess

func (f FldAccessRepr) String() string

type FldAssign ¶

type FldAssign struct {
	*TriggerIfNonNil
}

FldAssign is when a value flows to a point where it is assigned into a field

func (f *FldAssign) Copy() ConsumingAnnotationTrigger

func (f *FldAssign) Repr() fmt.Stringer

func (a FldAssign) String() string

type FldAssignRepr ¶

type FldAssignRepr struct {
	FieldName     string
	AssignmentStr string
}

FldAssignRepr is a fmt.Stringer storing the needed information to compactly encode a FldAssign

func (f FldAssignRepr) String() string

type FldEscape ¶

type FldEscape struct {
	*TriggerIfNonNil
}

FldEscape is when a nilable value flows through a field of a struct that escapes. The consumer is added for the fields at sites of escape. There are 2 cases, that we currently consider as escaping: 1. If a struct is returned from the function where the field has nilable value, e.g, If aptr is pointer in struct A, then `return &A{}` causes the field aptr to escape 2. If a struct is parameter of a function and the field is not initialized e.g., if we have fun(&A{}) then the field aptr is considered escaped TODO: Add struct assignment as another possible cause of field escape

func (f *FldEscape) Copy() ConsumingAnnotationTrigger

func (f *FldEscape) Repr() fmt.Stringer

func (a FldEscape) String() string

type FldEscapeRepr ¶

type FldEscapeRepr struct {
	FieldName     string
	AssignmentStr string
}

FldEscapeRepr is a fmt.Stringer storing the needed information to compactly encode a FldEscape

func (f FldEscapeRepr) String() string

type FldRead ¶

type FldRead struct {
	*TriggerIfNilable
}

FldRead is used when a value is determined to flow from a read to a field

func (f *FldRead) Repr() fmt.Stringer

type FldReadDeep ¶

type FldReadDeep struct {
	*TriggerIfDeepNilable
}

FldReadDeep is used when a value is determined to flow from the deep Annotation of a field that is read and then indexed into - for example x.f[0]

func (f *FldReadDeep) Repr() fmt.Stringer

type FldReadDeepRepr ¶

type FldReadDeepRepr struct {
	FieldName string
}

FldReadDeepRepr is a fmt.Stringer storing the needed information to compactly encode a FldReadDeep

func (f FldReadDeepRepr) String() string

type FldReadRepr ¶

type FldReadRepr struct {
	FieldName string
}

FldReadRepr is a fmt.Stringer storing the needed information to compactly encode a FldRead

func (f FldReadRepr) String() string

type FldReturn ¶

type FldReturn struct {
	*TriggerIfNilable
}

FldReturn is used when a struct field value is determined to flow from a return value of a function

func (f *FldReturn) Repr() fmt.Stringer

func (f FldReturn) String() string

type FldReturnRepr ¶

type FldReturnRepr struct {
	RetNum    int
	FuncName  string
	FieldName string
}

FldReturnRepr is a fmt.Stringer storing the needed information to compactly encode a FldReturn

func (f FldReturnRepr) String() string

type FullTrigger ¶

type FullTrigger struct {
	Producer *ProduceTrigger
	Consumer *ConsumeTrigger
	// Controller is the site that controls if this trigger will be activated or not.
	// If the controller site is assigned to nilable, then this full trigger is activated;
	// otherwise the full trigger is deactivated in the inference engine.
	// If this field is nil, it means the trigger is not a controlled trigger and the trigger will
	// be activated all the time.
	Controller *CallSiteParamAnnotationKey
	// CreatedFromDuplication is true if the full trigger is created from duplicating another full
	// trigger; otherwise false, which is also the default value for any normal full trigger.
	CreatedFromDuplication bool
}

A FullTrigger is a completed assertion. It contains both a ProduceTrigger Producer and a ConsumeTrigger Consumer, representing a path along which a nil value can be produced and consumed respectively. All produce and consume triggers are functions of the read set of annotations, so a FullTrigger represents only a possibility of a nil flow error depending on the set of annotations. A FullTrigger can be compared to an Annotation set to see if such a nil flow error actually arises by the Check method.

func FullTriggerForInterfaceParamFlow(affiliation AffiliationPair, paramNum int) FullTrigger

func FullTriggerForInterfaceResultFlow(affiliation AffiliationPair, retNum int) FullTrigger

func MergeFullTriggers(left []FullTrigger, right ...FullTrigger) []FullTrigger

func (t *FullTrigger) Check(annMap Map) bool

func (t *FullTrigger) Controlled() bool

func (t *FullTrigger) Pos() token.Pos

func (t *FullTrigger) Reprs(pass *analysishelper.EnhancedPass) (fmt.Stringer, fmt.Stringer)

type FuncParam ¶

type FuncParam struct {
	*TriggerIfNilable
}

FuncParam is used when a value is determined to flow from a function parameter. This consumer trigger can be used on top of two different sites: ParamAnnotationKey & CallSiteParamAnnotationKey. ParamAnnotationKey is the parameter site in the function declaration; CallSiteParamAnnotationKey is the argument site in the call expression. CallSiteParamAnnotationKey is specifically used for functions with contracts since we need to duplicate the sites for context sensitivity.

func (f *FuncParam) Repr() fmt.Stringer

type FuncParamDeep ¶

type FuncParamDeep struct {
	*TriggerIfDeepNilable
}

FuncParamDeep is used when a value is determined to flow deeply from a function parameter

func (f *FuncParamDeep) Repr() fmt.Stringer

type FuncParamDeepRepr ¶

type FuncParamDeepRepr struct {
	ParamName string
}

FuncParamDeepRepr is a fmt.Stringer storing the needed information to compactly encode a FuncParamDeep

func (f FuncParamDeepRepr) String() string

type FuncParamRepr ¶

type FuncParamRepr struct {
	ParamName string
	FuncName  string
	// Location is empty for a FuncParam enclosing ParamAnnotationKey. Location points to the
	// location of the argument pass at the call site for a FuncParam enclosing CallSiteParamAnnotationKey.
	Location string
}

FuncParamRepr is a fmt.Stringer storing the needed information to compactly encode a FuncParam

func (f FuncParamRepr) String() string

type FuncRetAssignDeep ¶

type FuncRetAssignDeep struct {
	*TriggerIfDeepNonNil
}

FuncRetAssignDeep is when a value flows to a point where it is assigned deeply into a function return

func (f *FuncRetAssignDeep) Copy() ConsumingAnnotationTrigger

func (f *FuncRetAssignDeep) Repr() fmt.Stringer

func (a FuncRetAssignDeep) String() string

type FuncRetAssignDeepRepr ¶

type FuncRetAssignDeepRepr struct {
	FuncName      string
	RetNum        int
	AssignmentStr string
}

FuncRetAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a FuncRetAssignDeep

func (f FuncRetAssignDeepRepr) String() string

type FuncReturn ¶

type FuncReturn struct {
	*TriggerIfNilable

	IsFromRichCheckEffectFunc bool
}

FuncReturn is used when a value is determined to flow from the return of a function. This consumer trigger can be used on top of two different sites: RetAnnotationKey & CallSiteRetAnnotationKey. RetAnnotationKey is the parameter site in the function declaration; CallSiteRetAnnotationKey is the argument site in the call expression. CallSiteRetAnnotationKey is specifically used for functions with contracts since we need to duplicate the sites for context sensitivity.

func (f *FuncReturn) Repr() fmt.Stringer

type FuncReturnDeep ¶

type FuncReturnDeep struct {
	*TriggerIfDeepNilable
}

FuncReturnDeep is used when a value is determined to flow from the deep Annotation of the return of a function

func (f *FuncReturnDeep) Repr() fmt.Stringer

type FuncReturnDeepRepr ¶

type FuncReturnDeepRepr struct {
	RetNum   int
	FuncName string
}

FuncReturnDeepRepr is a fmt.Stringer storing the needed information to compactly encode a FuncReturnDeep

func (f FuncReturnDeepRepr) String() string

type FuncReturnRepr ¶

type FuncReturnRepr struct {
	RetNum   int
	FuncName string
	// Location is empty for a FuncReturn enclosing RetAnnotationKey. Location points to the
	// location of the result return at the call site for a FuncReturn enclosing CallSiteRetAnnotationKey.
	Location string
}

FuncReturnRepr is a fmt.Stringer storing the needed information to compactly encode a FuncReturn

func (f FuncReturnRepr) String() string

type GlobalVarAnnotationKey ¶

type GlobalVarAnnotationKey struct {
	VarDecl *types.Var
}

GlobalVarAnnotationKey allows the Lookup of a global variable's annotations in the Annotation Map

func (gk *GlobalVarAnnotationKey) Lookup(annMap Map) (Val, bool)

func (gk *GlobalVarAnnotationKey) Object() types.Object

func (gk *GlobalVarAnnotationKey) String() string

type GlobalVarAssign ¶

type GlobalVarAssign struct {
	*TriggerIfNonNil
}

GlobalVarAssign is when a value flows to a point where it is assigned into a global variable

func (g *GlobalVarAssign) Copy() ConsumingAnnotationTrigger

func (g *GlobalVarAssign) Repr() fmt.Stringer

func (a GlobalVarAssign) String() string

type GlobalVarAssignDeep ¶

type GlobalVarAssignDeep struct {
	*TriggerIfDeepNonNil
}

GlobalVarAssignDeep is when a value flows to a point where it is assigned deeply into a global variable

func (g *GlobalVarAssignDeep) Copy() ConsumingAnnotationTrigger

func (g *GlobalVarAssignDeep) Repr() fmt.Stringer

func (a GlobalVarAssignDeep) String() string

type GlobalVarAssignDeepRepr ¶

type GlobalVarAssignDeepRepr struct {
	VarName       string
	AssignmentStr string
}

GlobalVarAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a GlobalVarAssignDeep

func (g GlobalVarAssignDeepRepr) String() string

type GlobalVarAssignRepr ¶

type GlobalVarAssignRepr struct {
	VarName       string
	AssignmentStr string
}

GlobalVarAssignRepr is a fmt.Stringer storing the needed information to compactly encode a GlobalVarAssign

func (g GlobalVarAssignRepr) String() string

type GlobalVarRead ¶

type GlobalVarRead struct {
	*TriggerIfNilable
}

GlobalVarRead is when a value is determined to flow from a read to a global variable

func (g *GlobalVarRead) Repr() fmt.Stringer

type GlobalVarReadDeep ¶

type GlobalVarReadDeep struct {
	*TriggerIfDeepNilable
}

GlobalVarReadDeep is when a value is determined to flow from the deep Annotation of a global variable that is read and indexed into

func (g *GlobalVarReadDeep) Repr() fmt.Stringer

type GlobalVarReadDeepRepr ¶

type GlobalVarReadDeepRepr struct {
	VarName string
}

GlobalVarReadDeepRepr is a fmt.Stringer storing the needed information to compactly encode a GlobalVarReadDeep

func (g GlobalVarReadDeepRepr) String() string

type GlobalVarReadRepr ¶

type GlobalVarReadRepr struct {
	VarName string
}

GlobalVarReadRepr is a fmt.Stringer storing the needed information to compactly encode a GlobalVarRead

func (g GlobalVarReadRepr) String() string

type GuardMissing ¶

type GuardMissing struct {
	*ProduceTriggerTautology
	OldAnnotation ProducingAnnotationTrigger
}

GuardMissing is when a value is determined to flow from a site that requires a guard, to a site that is not guarded by that guard.

GuardMissing is never created during backpropagation, but on a call to RootAssertionNode.ProcessEntry that checks the guards on ever FullTrigger created, it is substituted for the producer in any FullTrigger whose producer has NeedsGuard = true and whose consumer has GuardMatched = false, guaranteeing that that producer triggers.

For example, from a read to map without the `v, ok := m[k]` form, thus always resulting in nilable regardless of `m`'s deep nilability

func (g *GuardMissing) Repr() fmt.Stringer

type GuardMissingRepr ¶

type GuardMissingRepr struct {
	// OldPrestring retains the existing gob field name for fact encoding compatibility.
	OldPrestring fmt.Stringer
}

GuardMissingRepr is a fmt.Stringer storing the needed information to compactly encode a GuardMissing

func (g GuardMissingRepr) String() string

type InterfaceParamReachesImplementation ¶

type InterfaceParamReachesImplementation struct {
	*TriggerIfNilable
	AffiliationPair
}

InterfaceParamReachesImplementation is used when a param of a method is determined to flow into the param of an implementing method

func (i *InterfaceParamReachesImplementation) Repr() fmt.Stringer

type InterfaceParamReachesImplementationRepr ¶

type InterfaceParamReachesImplementationRepr struct {
	ParamName string
	IntName   string
	ImplName  string
}

InterfaceParamReachesImplementationRepr is a fmt.Stringer storing the needed information to compactly encode a InterfaceParamReachesImplementation

func (i InterfaceParamReachesImplementationRepr) String() string

type InterfaceResultFromImplementation ¶

type InterfaceResultFromImplementation struct {
	*TriggerIfNonNil
	AffiliationPair
}

InterfaceResultFromImplementation is when a result is determined to flow from a concrete method to an interface method via implementation

func (i *InterfaceResultFromImplementation) Copy() ConsumingAnnotationTrigger

func (i *InterfaceResultFromImplementation) Repr() fmt.Stringer

func (a InterfaceResultFromImplementation) String() string

type InterfaceResultFromImplementationRepr ¶

type InterfaceResultFromImplementationRepr struct {
	RetNum        int
	IntName       string
	ImplName      string
	AssignmentStr string
}

InterfaceResultFromImplementationRepr is a fmt.Stringer storing the needed information to compactly encode a InterfaceResultFromImplementation

func (i InterfaceResultFromImplementationRepr) String() string

type Key ¶

type Key interface {
	// Lookup checks whether this key is present in a given Map - returning false as its
	// second result if not present, and true as its second result with the Val found if
	// one is found.
	// To provide optimistic defaults for unannotated files (formally - files on which the annotations
	// checker has not been run), uses of `Lookup` such as `CheckProduce` and `CheckConsume` always
	// return false (i.e. "don't trigger") if the key they wrap is not found in the map.
	// Since not triggering on the level of a produce or consume trigger always results in fewer
	// errors, this gives optimistic defaults to library code.
	Lookup(Map) (Val, bool)

	// Object returns the underlying object that this annotation key can be interpreted as annotating
	Object() types.Object

	// String returns a string representation of this annotation key
	// These get stored into PrimitiveAnnotationKeys - so KEEP THEM COMPACT
	// a good guideline would be the length of their name plus no more than 10 characters
	String() string
	// contains filtered or unexported methods
}

A Key is an object that can be looked up in a Map

type LocalVarAnnotationKey ¶

type LocalVarAnnotationKey struct {
	VarDecl *types.Var
}

LocalVarAnnotationKey allows the Lookup of a local variable's annotations in the Annotation Map

func (lk *LocalVarAnnotationKey) Lookup(_ Map) (Val, bool)

func (lk *LocalVarAnnotationKey) Object() types.Object

func (lk *LocalVarAnnotationKey) String() string

type LocalVarAssignDeep ¶

type LocalVarAssignDeep struct {
	*TriggerIfDeepNonNil
}

LocalVarAssignDeep is when a value flows to a point where it is assigned deeply into a local variable of deeply nonnil type

func (l *LocalVarAssignDeep) Copy() ConsumingAnnotationTrigger

func (l *LocalVarAssignDeep) Repr() fmt.Stringer

func (a LocalVarAssignDeep) String() string

type LocalVarAssignDeepRepr ¶

type LocalVarAssignDeepRepr struct {
	VarName       string
	AssignmentStr string
}

LocalVarAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a LocalVarAssignDeep

func (l LocalVarAssignDeepRepr) String() string

type LocalVarReadDeep ¶

type LocalVarReadDeep struct {
	*TriggerIfDeepNilable
}

LocalVarReadDeep is when a value is determined to flow deeply from a local variable.

func (v LocalVarReadDeep) Repr() fmt.Stringer

type LocalVarReadDeepRepr ¶

type LocalVarReadDeepRepr struct {
	VarName string
}

LocalVarReadDeepRepr is a fmt.Stringer storing the needed information to compactly encode a LocalVarReadDeep

func (v LocalVarReadDeepRepr) String() string

type LocatedRepr ¶

type LocatedRepr struct {
	Contained fmt.Stringer
	Location  token.Position
}

A LocatedRepr wraps another fmt.Stringer with a `token.Position` - for formatting with that position

func (l LocatedRepr) String() string

type Map ¶

type Map interface {
	CheckFieldAnn(*types.Var) (Val, bool)
	CheckFuncParamAnn(*types.Func, int) (Val, bool)
	CheckFuncRetAnn(*types.Func, int) (Val, bool)
	CheckFuncRecvAnn(*types.Func) (Val, bool)
	CheckDeepTypeAnn(*types.TypeName) (Val, bool)
	CheckGlobalVarAnn(*types.Var) (Val, bool)
	CheckFuncCallSiteParamAnn(*CallSiteParamAnnotationKey) (Val, bool)
	CheckFuncCallSiteRetAnn(*CallSiteRetAnnotationKey) (Val, bool)
}

Map is an abstraction that concrete annotation maps must implement to be checked against.

type MapAccess ¶

type MapAccess struct {
	*ConsumeTriggerTautology
}

MapAccess is when a map value flows to a point where it is indexed, and thus must be non-nil

note: this trigger is produced only if config.ErrorOnNilableMapRead == true

func (i *MapAccess) Copy() ConsumingAnnotationTrigger

func (i *MapAccess) Repr() fmt.Stringer

func (a MapAccess) String() string

type MapAccessRepr ¶

type MapAccessRepr struct {
	AssignmentStr string
}

MapAccessRepr is a fmt.Stringer storing the needed information to compactly encode a MapAccess

func (i MapAccessRepr) String() string

type MapAssign ¶

type MapAssign struct {
	*TriggerIfDeepNonNil
}

MapAssign is when a value flows to a point where it is assigned into an annotated map

func (f *MapAssign) Copy() ConsumingAnnotationTrigger

func (f *MapAssign) Repr() fmt.Stringer

func (a MapAssign) String() string

type MapAssignRepr ¶

type MapAssignRepr struct {
	TypeName      string
	AssignmentStr string
}

MapAssignRepr is a fmt.Stringer storing the needed information to compactly encode a MapAssign

func (f MapAssignRepr) String() string

type MapRead ¶

type MapRead struct {
	*TriggerIfDeepNilable
}

MapRead is when a value is determined to flow from a map index expression These should always be instantiated with NeedsGuard = true

func (m *MapRead) Repr() fmt.Stringer

type MapReadRepr ¶

type MapReadRepr struct {
	TypeName string
}

MapReadRepr is a fmt.Stringer storing the needed information to compactly encode a MapRead

func (m MapReadRepr) String() string

type MapWrittenTo ¶

type MapWrittenTo struct {
	*ConsumeTriggerTautology
}

MapWrittenTo is when a map value flows to a point where one of its indices is written to, and thus must be non-nil

func (m *MapWrittenTo) Copy() ConsumingAnnotationTrigger

func (m *MapWrittenTo) Repr() fmt.Stringer

func (a MapWrittenTo) String() string

type MapWrittenToRepr ¶

type MapWrittenToRepr struct {
	AssignmentStr string
}

MapWrittenToRepr is a fmt.Stringer storing the needed information to compactly encode a MapWrittenTo

func (m MapWrittenToRepr) String() string

type MethodParamFromInterface ¶

type MethodParamFromInterface struct {
	*TriggerIfNonNil
	AffiliationPair
}

MethodParamFromInterface is when a param flows from an interface method to a concrete method via implementation

func (m *MethodParamFromInterface) Copy() ConsumingAnnotationTrigger

func (m *MethodParamFromInterface) Repr() fmt.Stringer

func (a MethodParamFromInterface) String() string

type MethodParamFromInterfaceRepr ¶

type MethodParamFromInterfaceRepr struct {
	ParamName     string
	ImplName      string
	IntName       string
	AssignmentStr string
}

MethodParamFromInterfaceRepr is a fmt.Stringer storing the needed information to compactly encode a MethodParamFromInterface

func (m MethodParamFromInterfaceRepr) String() string

type MethodRecv ¶

type MethodRecv struct {
	*TriggerIfNilable
	VarDecl *types.Var
}

MethodRecv is used when a value is determined to flow from a method receiver

func (m *MethodRecv) Repr() fmt.Stringer

type MethodRecvDeep ¶

type MethodRecvDeep struct {
	*TriggerIfDeepNilable
	VarDecl *types.Var
}

MethodRecvDeep is used when a value is determined to flow deeply from a method receiver

func (m *MethodRecvDeep) Repr() fmt.Stringer

type MethodRecvDeepRepr ¶

type MethodRecvDeepRepr struct {
	RecvName string
}

MethodRecvDeepRepr is a fmt.Stringer storing the needed information to compactly encode a MethodRecv

func (m MethodRecvDeepRepr) String() string

type MethodRecvRepr ¶

type MethodRecvRepr struct {
	RecvName string
}

MethodRecvRepr is a fmt.Stringer storing the needed information to compactly encode a MethodRecv

func (m MethodRecvRepr) String() string

type MethodResultReachesInterface ¶

type MethodResultReachesInterface struct {
	*TriggerIfNilable
	AffiliationPair
}

MethodResultReachesInterface is used when a result of a method is determined to flow into a result of an interface using inheritance

func (m *MethodResultReachesInterface) Repr() fmt.Stringer

type MethodResultReachesInterfaceRepr ¶

type MethodResultReachesInterfaceRepr struct {
	RetNum   int
	ImplName string
	IntName  string
}

MethodResultReachesInterfaceRepr is a fmt.Stringer storing the needed information to compactly encode a MethodResultReachesInterface

func (m MethodResultReachesInterfaceRepr) String() string

type MethodReturn ¶

type MethodReturn struct {
	*TriggerIfNilable
}

MethodReturn is used when a value is determined to flow from the return of a method

func (m *MethodReturn) Repr() fmt.Stringer

type MethodReturnRepr ¶

type MethodReturnRepr struct {
	RetNum   int
	FuncName string
}

MethodReturnRepr is a fmt.Stringer storing the needed information to compactly encode a MethodReturn

func (m MethodReturnRepr) String() string

type NegativeNilCheck ¶

type NegativeNilCheck struct {
	*ProduceTriggerNever
}

NegativeNilCheck is used when a value is checked in a conditional to NOT BE nil

func (*NegativeNilCheck) Repr() fmt.Stringer

type NegativeNilCheckRepr ¶

type NegativeNilCheckRepr struct{}

NegativeNilCheckRepr is a fmt.Stringer storing the needed information to compactly encode a NegativeNilCheck

func (NegativeNilCheckRepr) String() string

type NoVarAssign ¶

type NoVarAssign struct {
	*ProduceTriggerTautology
	VarObj *types.Var
}

NoVarAssign is when a value is determined to flow from a variable that wasn't assigned to

func (n *NoVarAssign) Repr() fmt.Stringer

type NoVarAssignRepr ¶

type NoVarAssignRepr struct {
	VarName string
}

NoVarAssignRepr is a fmt.Stringer storing the needed information to compactly encode a NoVarAssign

func (n NoVarAssignRepr) String() string

type ObservedMap ¶

type ObservedMap struct {
	// contains filtered or unexported fields
}

A ObservedMap represents a completed set of annotations read from a file or set of files, it can be checked against an assertionTree using RootAssertionNode.ReportErrors

The maps are keyed by *ast.Idents because such an object is unique at each site in the code it is used; canonically, declarations are identified with the identifier used at the site of the declaration

TODO: handle annotations for anonymous functions too

func (m *ObservedMap) Range(op func(key Key, isDeep bool, val bool), setSitesOnly bool)

type OkReadReflCheck ¶

type OkReadReflCheck struct {
	*ProduceTriggerNever
}

OkReadReflCheck is used to produce nonnil for artifacts of successful `ok` forms (e.g., maps, channels, type casts). For example, a map value `m` that was read from in a `v, ok := m[k]` check followed by a positive check of `ok`, implies `m` is non-nil. This is valid because nil maps contain no keys.

type ParamAnnotationKey ¶

type ParamAnnotationKey struct {
	FuncDecl *types.Func
	ParamNum int
}

ParamAnnotationKey allows the Lookup of a function parameter's Annotation in the Annotation map Only construct these using ParamKeyFromArgNum and ParamKeyFromName

func ParamKeyFromArgNum(fdecl *types.Func, num int) *ParamAnnotationKey

func ParamKeyFromName(fdecl *types.Func, paramName *types.Var) *ParamAnnotationKey

func (pk *ParamAnnotationKey) Lookup(annMap Map) (Val, bool)

func (pk *ParamAnnotationKey) MinimalString() string

func (pk *ParamAnnotationKey) Object() types.Object

func (pk *ParamAnnotationKey) ParamName() *types.Var

func (pk *ParamAnnotationKey) ParamNameString() string

func (pk *ParamAnnotationKey) String() string

type ParamAssignDeep ¶

type ParamAssignDeep struct {
	*TriggerIfDeepNonNil
}

ParamAssignDeep is when a value flows to a point where it is assigned deeply into a function parameter

func (p *ParamAssignDeep) Copy() ConsumingAnnotationTrigger

func (p *ParamAssignDeep) Repr() fmt.Stringer

func (a ParamAssignDeep) String() string

type ParamAssignDeepRepr ¶

type ParamAssignDeepRepr struct {
	ParamName     string
	AssignmentStr string
}

ParamAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a ParamAssignDeep

func (p ParamAssignDeepRepr) String() string

type ParamFieldAnnotationKey ¶

type ParamFieldAnnotationKey struct {
	// FuncDecl is the function corresponding to the key
	FuncDecl *types.Func
	// ParamNum is the index of the param. It is set to const ReceiverParamIndex -1 if IsReceiver is set to true
	ParamNum int
	// FieldDecl is the declaration of the field
	FieldDecl *types.Var
	// IsTrackingSideEffect is true if the key is used for tracking the param field nilability from callee to caller
	IsTrackingSideEffect bool
}

ParamFieldAnnotationKey allows the Lookup of Annotation of a function parameter's fields in the Annotation map. The key is used for tracking flows through both function params and the receiver. In case, the key is tracking nilability flow through receivers ParamNum is set to ReceiverParamIndex If the key is tracking flow from caller to callee then IsTrackingSideEffect is false. If the key is tracking flow from callee to caller at return of the callee function then IsTrackingSideEffect is true

func NewParamFldAnnKey(funcObj *types.Func, index int, fieldDecl *types.Var) *ParamFieldAnnotationKey

func (pf *ParamFieldAnnotationKey) IsReceiver() bool

func (pf *ParamFieldAnnotationKey) Lookup(_ Map) (Val, bool)

func (pf *ParamFieldAnnotationKey) Object() types.Object

func (pf *ParamFieldAnnotationKey) ParamName() *types.Var

func (pf *ParamFieldAnnotationKey) String() string

type ParamFldRead ¶

type ParamFldRead struct {
	*TriggerIfNilable
}

ParamFldRead is used when a struct field value is determined to flow from the param of a function to a consumption site within the body of the function

func (f *ParamFldRead) Repr() fmt.Stringer

type ParamFldReadRepr ¶

type ParamFldReadRepr struct {
	FieldName string
}

ParamFldReadRepr is a fmt.Stringer storing the needed information to compactly encode a ParamFldRead

func (f ParamFldReadRepr) String() string

type PositiveNilCheck ¶

type PositiveNilCheck struct {
	*ProduceTriggerTautology
}

PositiveNilCheck is used when a value is checked in a conditional to BE nil

func (*PositiveNilCheck) Repr() fmt.Stringer

type PositiveNilCheckRepr ¶

type PositiveNilCheckRepr struct{}

PositiveNilCheckRepr is a fmt.Stringer storing the needed information to compactly encode a PositiveNilCheck

func (PositiveNilCheckRepr) String() string

type ProduceTrigger ¶

type ProduceTrigger struct {
	Annotation ProducingAnnotationTrigger
	Expr       ast.Expr
}

A ProduceTrigger represents a point at which a value is produced that may be nilable because of an Annotation (ProducingAnnotationTrigger). Will always be paired with a ConsumeTrigger. For semantics' sake, the Annotation field of a ProduceTrigger is all that matters - the Expr is included only to produce more informative error messages

func DuplicateParamProducer(t *ProduceTrigger, location token.Position) *ProduceTrigger

type ProduceTriggerNever ¶

type ProduceTriggerNever struct {
	NeedsGuard bool
}

ProduceTriggerNever is used for trigger producers that will never be nil

func (*ProduceTriggerNever) CheckProduce(Map) bool

func (*ProduceTriggerNever) Kind() TriggerKind

func (p *ProduceTriggerNever) NeedsGuardMatch() bool

func (*ProduceTriggerNever) Repr() fmt.Stringer

func (p *ProduceTriggerNever) SetNeedsGuard(b bool)

func (*ProduceTriggerNever) UnderlyingSite() Key

type ProduceTriggerNeverRepr ¶

type ProduceTriggerNeverRepr struct{}

ProduceTriggerNeverRepr is a fmt.Stringer storing the needed information to compactly encode a ProduceTriggerNever

func (ProduceTriggerNeverRepr) String() string

type ProduceTriggerTautology ¶

type ProduceTriggerTautology struct {
	NeedsGuard bool
}

ProduceTriggerTautology is used for trigger producers that will always result in nil

func (*ProduceTriggerTautology) CheckProduce(Map) bool

func (*ProduceTriggerTautology) Kind() TriggerKind

func (p *ProduceTriggerTautology) NeedsGuardMatch() bool

func (*ProduceTriggerTautology) Repr() fmt.Stringer

func (p *ProduceTriggerTautology) SetNeedsGuard(b bool)

func (*ProduceTriggerTautology) UnderlyingSite() Key

type ProduceTriggerTautologyRepr ¶

type ProduceTriggerTautologyRepr struct{}

ProduceTriggerTautologyRepr is a fmt.Stringer storing the needed information to compactly encode a ProduceTriggerTautology

func (ProduceTriggerTautologyRepr) String() string

type ProducingAnnotationTrigger ¶

type ProducingAnnotationTrigger interface {
	// CheckProduce can be called to determined whether this trigger should be triggered
	// given a particular Annotation map
	// for example - a `FuncReturn` trigger triggers iff the corresponding function has
	// nilable return type
	CheckProduce(Map) bool

	// NeedsGuardMatch returns whether this production is contingent on being
	// paired with a guarded consumer.
	// In other words, this production is only given the freedom to produce
	// a non-nil value in the case that it is matched with a guarded consumer.
	// otherwise, it is replaced with annotation.GuardMissing
	NeedsGuardMatch() bool

	// SetNeedsGuard sets the underlying Guard-Neediness of this ProduceTrigger, if present
	// This should be very sparingly used, and only with utter conviction of correctness.
	// Default setting for ProduceTriggers is to not need a guard.
	SetNeedsGuard(bool)

	Repr() fmt.Stringer

	// Kind returns the kind of the trigger.
	Kind() TriggerKind

	// UnderlyingSite returns the underlying site this trigger's nilability depends on. If the
	// trigger always or never fires, the site is nil.
	UnderlyingSite() Key
	// contains filtered or unexported methods
}

A ProducingAnnotationTrigger is a possible reason that a nil value might be produced

All ProducingAnnotationTriggers must embed one of the following 4 structs: -TriggerIfNilable -TriggerIfDeepNilable -ProduceTriggerTautology -ProduceTriggerNever

This is because there are interfaces, such as AdmitsPrimitive, that are implemented only for those structs, and to which a ProducingAnnotationTrigger must be able to be case

func DeepNilabilityAsNamedType(typ types.Type) ProducingAnnotationTrigger

func DeepNilabilityOfFld(fld *types.Var) ProducingAnnotationTrigger

func DeepNilabilityOfFuncRet(fn *types.Func, retNum int) ProducingAnnotationTrigger

func DeepNilabilityOfVar(fdecl *types.Func, v *types.Var) ProducingAnnotationTrigger

func ParamAsProducer(fdecl *types.Func, param *types.Var) ProducingAnnotationTrigger

type PtrAssign ¶

type PtrAssign struct {
	*TriggerIfDeepNonNil
}

PtrAssign is when a value flows to a point where it is assigned into a pointer

func (f *PtrAssign) Copy() ConsumingAnnotationTrigger

func (f *PtrAssign) Repr() fmt.Stringer

func (a PtrAssign) String() string

type PtrAssignRepr ¶

type PtrAssignRepr struct {
	TypeName      string
	AssignmentStr string
}

PtrAssignRepr is a fmt.Stringer storing the needed information to compactly encode a PtrAssign

func (f PtrAssignRepr) String() string

type PtrLoad ¶

type PtrLoad struct {
	*ConsumeTriggerTautology
}

PtrLoad is when a value flows to a point where it is loaded as a pointer

func (p *PtrLoad) Copy() ConsumingAnnotationTrigger

func (p *PtrLoad) Repr() fmt.Stringer

func (a PtrLoad) String() string

type PtrLoadRepr ¶

type PtrLoadRepr struct {
	AssignmentStr string
}

PtrLoadRepr is a fmt.Stringer storing the needed information to compactly encode a PtrLoad

func (p PtrLoadRepr) String() string

type PtrRead ¶

type PtrRead struct {
	*TriggerIfDeepNilable
}

PtrRead is when a value is determined to flow from a read to a pointer

func (p *PtrRead) Repr() fmt.Stringer

type PtrReadRepr ¶

type PtrReadRepr struct {
	TypeName string
}

PtrReadRepr is a fmt.Stringer storing the needed information to compactly encode a PtrRead

func (p PtrReadRepr) String() string

type RangeIndexAssignment ¶

type RangeIndexAssignment struct {
	*ProduceTriggerNever
}

RangeIndexAssignment is used when a value is determined to flow from the first argument of a range loop, and thus be an integer and non-nil

type RangeOver ¶

type RangeOver struct {
	*ProduceTriggerNever
}

RangeOver is used when a value is ranged over - and thus nonnil in its range body

type RecvAnnotationKey ¶

type RecvAnnotationKey struct {
	FuncDecl *types.Func
}

RecvAnnotationKey allows the Lookup of a method's receiver Annotation in the Annotation map

func (rk *RecvAnnotationKey) Exported() bool

func (rk *RecvAnnotationKey) Lookup(annMap Map) (Val, bool)

func (rk *RecvAnnotationKey) Object() types.Object

func (rk *RecvAnnotationKey) Package() *types.Package

func (rk *RecvAnnotationKey) String() string

type RecvPass ¶

type RecvPass struct {
	*TriggerIfNonNil
}

RecvPass is when a receiver value flows to a point where it is used to invoke a method. E.g., `s.foo()`, here `s` is a receiver and forms the RecvPass Consumer

func (a *RecvPass) Copy() ConsumingAnnotationTrigger

func (a *RecvPass) Repr() fmt.Stringer

func (a RecvPass) String() string

type RecvPassRepr ¶

type RecvPassRepr struct {
	FuncName      string
	AssignmentStr string
}

RecvPassRepr is a fmt.Stringer storing the needed information to compactly encode a RecvPass

func (a RecvPassRepr) String() string

type RetAnnotationKey ¶

type RetAnnotationKey struct {
	FuncDecl *types.Func
	RetNum   int // which result
}

RetAnnotationKey allows the Lookup of a function's return Annotation in the Annotation Map

func RetKeyFromRetNum(fdecl *types.Func, retNum int) *RetAnnotationKey

func (rk *RetAnnotationKey) Lookup(annMap Map) (Val, bool)

func (rk *RetAnnotationKey) Object() types.Object

func (rk *RetAnnotationKey) String() string

type RetFieldAnnotationKey ¶

type RetFieldAnnotationKey struct {
	// FuncDecl is the function type of function containing return
	FuncDecl *types.Func
	// RetNum is the index of the return for the key
	RetNum int
	// FieldDecl is the declaration for the field of the key
	FieldDecl *types.Var
}

RetFieldAnnotationKey allows the Lookup of the Annotation on a specific field within a function's return of struct (or pointer to struct) type, in the Annotation Map. This key is only effective when the struct initialization checking is enabled.

TODO: Add support for field of function return with no inference (Currently, only works with inference)

func NewRetFldAnnKey(funcDecl *types.Func, retNum int, fieldDecl *types.Var) *RetFieldAnnotationKey

func (rf *RetFieldAnnotationKey) Lookup(_ Map) (Val, bool)

func (rf *RetFieldAnnotationKey) Object() types.Object

func (rf *RetFieldAnnotationKey) String() string

type SliceAccess ¶

type SliceAccess struct {
	*ConsumeTriggerTautology
}

SliceAccess is when a slice value flows to a point where it is sliced, and thus must be non-nil

func (s *SliceAccess) Copy() ConsumingAnnotationTrigger

func (s *SliceAccess) Repr() fmt.Stringer

func (a SliceAccess) String() string

type SliceAccessRepr ¶

type SliceAccessRepr struct {
	AssignmentStr string
}

SliceAccessRepr is a fmt.Stringer storing the needed information to compactly encode a SliceAccess

func (s SliceAccessRepr) String() string

type SliceAssign ¶

type SliceAssign struct {
	*TriggerIfDeepNonNil
}

SliceAssign is when a value flows to a point where it is assigned into a slice

func (f *SliceAssign) Copy() ConsumingAnnotationTrigger

func (f *SliceAssign) Repr() fmt.Stringer

func (a SliceAssign) String() string

type SliceAssignRepr ¶

type SliceAssignRepr struct {
	TypeName      string
	AssignmentStr string
}

SliceAssignRepr is a fmt.Stringer storing the needed information to compactly encode a SliceAssign

func (f SliceAssignRepr) String() string

type SliceRead ¶

type SliceRead struct {
	*TriggerIfDeepNilable
}

SliceRead is when a value is determined to flow from a slice index expression

func (s *SliceRead) Repr() fmt.Stringer

type SliceReadRepr ¶

type SliceReadRepr struct {
	TypeName string
}

SliceReadRepr is a fmt.Stringer storing the needed information to compactly encode a SliceRead

func (s SliceReadRepr) String() string

type StructFieldContextKind ¶

type StructFieldContextKind uint8

StructFieldContextKind distinguishes whether a context site summarizes a field of a function return value or of a function parameter/receiver.

const (
	// StructFieldReturnContext is the nilability of a field of a function's return value.
	StructFieldReturnContext StructFieldContextKind = iota
	// StructFieldParamContext is the nilability of a field of a function's parameter/receiver,
	// as observed on entry to the function (the value passed in by the caller).
	StructFieldParamContext
	// StructFieldParamOutContext is the nilability of a parameter or receiver field after the
	// function has assigned it.
	StructFieldParamOutContext
)

type StructFieldContextSite ¶

type StructFieldContextSite struct {
	FuncObj *types.Func
	Kind    StructFieldContextKind
	Index   int
	// Path is the dotted field path from the boundary value to the tracked field (e.g. "aptr").
	Path string
}

StructFieldContextSite is an annotation site (annotation.Key) representing the nilability of a nested field, identified by Path, of the Index-th return value or parameter of FuncObj. It is inference-only.

func (s *StructFieldContextSite) Lookup(Map) (Val, bool)

func (s *StructFieldContextSite) Object() types.Object

func (s *StructFieldContextSite) String() string

type StructFieldFromContext ¶

type StructFieldFromContext struct {
	*TriggerIfNilable
}

StructFieldFromContext is a producer: the value of a field (read from a boundary, e.g. `b.f` where `b := give()`) is nil iff the corresponding context site is inferred nilable.

func (s *StructFieldFromContext) Repr() fmt.Stringer

type StructFieldFromContextRepr ¶

type StructFieldFromContextRepr struct {
	Path     string
	Kind     StructFieldContextKind
	Index    int
	FuncName string
}

StructFieldFromContextRepr is the compact encoding of a StructFieldFromContext.

func (s StructFieldFromContextRepr) String() string

type StructFieldNil ¶

type StructFieldNil struct {
	*ProduceTriggerTautology

	// FieldName is the name of the field that is nil, used only for diagnostics.
	FieldName string
}

StructFieldNil is a producer for a nil field in a specific struct allocation. It always produces nil. Because it is attached to the field node for that allocation, different allocations of the same struct type keep separate producers.

func (s *StructFieldNil) Repr() fmt.Stringer

type StructFieldNilRepr ¶

type StructFieldNilRepr struct {
	FieldName string
}

StructFieldNilRepr is a fmt.Stringer storing the information needed to compactly encode a StructFieldNil.

func (s StructFieldNilRepr) String() string

type StructFieldToContext ¶

type StructFieldToContext struct {
	*TriggerIfNonNil
}

StructFieldToContext is a consumer: a value flows into a field of a boundary (e.g. a returned struct's field). It requires the context site to be nonnil; when a definitely-nil producer reaches it, inference marks the site nilable.

func (s *StructFieldToContext) Copy() ConsumingAnnotationTrigger

func (s *StructFieldToContext) Repr() fmt.Stringer

func (a StructFieldToContext) String() string

type StructFieldToContextRepr ¶

type StructFieldToContextRepr struct {
	Path     string
	Kind     StructFieldContextKind
	Index    int
	FuncName string
}

StructFieldToContextRepr is the compact encoding of a StructFieldToContext.

func (s StructFieldToContextRepr) String() string

type TriggerIfDeepNilable ¶

type TriggerIfDeepNilable struct {
	Ann        Key
	NeedsGuard bool
}

TriggerIfDeepNilable is a general trigger indicating the the bad case occurs when a certain Annotation key is deeply nilable

func (t *TriggerIfDeepNilable) CheckProduce(annMap Map) bool

func (t *TriggerIfDeepNilable) Kind() TriggerKind

func (t *TriggerIfDeepNilable) NeedsGuardMatch() bool

func (*TriggerIfDeepNilable) Repr() fmt.Stringer

func (t *TriggerIfDeepNilable) SetNeedsGuard(b bool)

func (t *TriggerIfDeepNilable) UnderlyingSite() Key

type TriggerIfDeepNilableRepr ¶

type TriggerIfDeepNilableRepr struct{}

TriggerIfDeepNilableRepr is a fmt.Stringer storing the needed information to compactly encode a TriggerIfDeepNilable

func (TriggerIfDeepNilableRepr) String() string

type TriggerIfDeepNonNil ¶

type TriggerIfDeepNonNil struct {
	Ann              Key
	IsGuardNotNeeded bool // ConsumeTriggers need guards by default, when applicable. Set this to true when guards are not needed.
	// contains filtered or unexported fields
}

TriggerIfDeepNonNil is triggered if the contained Annotation is deeply non-nil

func (t *TriggerIfDeepNonNil) AddAssignment(e Assignment)

func (t *TriggerIfDeepNonNil) CheckConsume(annMap Map) bool

func (t *TriggerIfDeepNonNil) Copy() ConsumingAnnotationTrigger

func (*TriggerIfDeepNonNil) Kind() TriggerKind

func (t *TriggerIfDeepNonNil) NeedsGuard() bool

func (t *TriggerIfDeepNonNil) Repr() fmt.Stringer

func (t *TriggerIfDeepNonNil) SetNeedsGuard(b bool)

func (a *TriggerIfDeepNonNil) String() string

func (t *TriggerIfDeepNonNil) UnderlyingSite() Key

type TriggerIfDeepNonNilRepr ¶

type TriggerIfDeepNonNilRepr struct {
	AssignmentStr string
}

TriggerIfDeepNonNilRepr is a fmt.Stringer storing the needed information to compactly encode a TriggerIfDeepNonNil

func (t TriggerIfDeepNonNilRepr) String() string

type TriggerIfNilable ¶

type TriggerIfNilable struct {
	Ann        Key
	NeedsGuard bool
}

TriggerIfNilable is a general trigger indicating that the bad case occurs when a certain Annotation key is nilable

func (t *TriggerIfNilable) CheckProduce(annMap Map) bool

func (t *TriggerIfNilable) Kind() TriggerKind

func (t *TriggerIfNilable) NeedsGuardMatch() bool

func (*TriggerIfNilable) Repr() fmt.Stringer

func (t *TriggerIfNilable) SetNeedsGuard(b bool)

func (t *TriggerIfNilable) UnderlyingSite() Key

type TriggerIfNilableRepr ¶

type TriggerIfNilableRepr struct{}

TriggerIfNilableRepr is a fmt.Stringer storing the needed information to compactly encode a TriggerIfNilable

func (TriggerIfNilableRepr) String() string

type TriggerIfNonNil ¶

type TriggerIfNonNil struct {
	Ann              Key
	IsGuardNotNeeded bool // ConsumeTriggers need guards by default, when applicable. Set this to true when guards are not needed.
	// contains filtered or unexported fields
}

TriggerIfNonNil is triggered if the contained Annotation is non-nil

func (t *TriggerIfNonNil) AddAssignment(e Assignment)

func (t *TriggerIfNonNil) CheckConsume(annMap Map) bool

func (t *TriggerIfNonNil) Copy() ConsumingAnnotationTrigger

func (*TriggerIfNonNil) Kind() TriggerKind

func (t *TriggerIfNonNil) NeedsGuard() bool

func (t *TriggerIfNonNil) Repr() fmt.Stringer

func (t *TriggerIfNonNil) SetNeedsGuard(b bool)

func (a *TriggerIfNonNil) String() string

func (t *TriggerIfNonNil) UnderlyingSite() Key

type TriggerIfNonNilRepr ¶

type TriggerIfNonNilRepr struct {
	AssignmentStr string
}

TriggerIfNonNilRepr is a fmt.Stringer storing the needed information to compactly encode a TriggerIfNonNil

func (t TriggerIfNonNilRepr) String() string

type TriggerKind ¶

type TriggerKind uint8

TriggerKind indicates the kind of the producer / consume trigger, e.g., a trigger will always fire, or a trigger will only fire if the underlying site is nilable etc.

const (
	// Always indicates a trigger will always fire.
	Always TriggerKind = iota + 1
	// Conditional indicates a trigger will only fire depending on the nilability of the
	// underlying site.
	Conditional
	// DeepConditional indicates a trigger will only fire depending on the deep nilability of the
	// underlying site.
	DeepConditional
	// Never indicates a trigger will never fire.
	Never
)

type TrustedFuncNilable ¶

type TrustedFuncNilable struct {
	*ProduceTriggerTautology
}

TrustedFuncNilable is used when a value is determined to be nilable by a trusted function call

func (*TrustedFuncNilable) Repr() fmt.Stringer

type TrustedFuncNilableRepr ¶

type TrustedFuncNilableRepr struct{}

TrustedFuncNilableRepr is a fmt.Stringer storing the needed information to compactly encode a TrustedFuncNilable

func (TrustedFuncNilableRepr) String() string

type TrustedFuncNonnil ¶

type TrustedFuncNonnil struct {
	*ProduceTriggerNever
}

TrustedFuncNonnil is used when a value is determined to be nonnil by a trusted function call

func (*TrustedFuncNonnil) Repr() fmt.Stringer

type TrustedFuncNonnilRepr ¶

type TrustedFuncNonnilRepr struct{}

TrustedFuncNonnilRepr is a fmt.Stringer storing the needed information to compactly encode a TrustedFuncNonnil

func (TrustedFuncNonnilRepr) String() string

type TypeNameAnnotationKey ¶

type TypeNameAnnotationKey struct {
	TypeDecl *types.TypeName
}

TypeNameAnnotationKey allows the Lookup of a named type annotations in the Annotation Map

func (tk *TypeNameAnnotationKey) Lookup(annMap Map) (Val, bool)

func (tk *TypeNameAnnotationKey) Object() types.Object

func (tk *TypeNameAnnotationKey) String() string

type UnassignedFld ¶

type UnassignedFld struct {
	*ProduceTriggerTautology
}

UnassignedFld is when a field of struct is not assigned at initialization

func (*UnassignedFld) Repr() fmt.Stringer

type UnassignedFldRepr ¶

type UnassignedFldRepr struct{}

UnassignedFldRepr is a fmt.Stringer storing the needed information to compactly encode a UnassignedFld

func (UnassignedFldRepr) String() string

type UseAsErrorResult ¶

type UseAsErrorResult struct {
	*TriggerIfNonNil

	RetStmt       *ast.ReturnStmt
	IsNamedReturn bool
}

UseAsErrorResult is when a value flows to the error result of a function, where it is expected to be non-nil

func (u *UseAsErrorResult) Copy() ConsumingAnnotationTrigger

func (u *UseAsErrorResult) Repr() fmt.Stringer

func (a UseAsErrorResult) String() string

type UseAsErrorResultRepr ¶

type UseAsErrorResultRepr struct {
	Pos              int
	ReturningFuncStr string
	IsNamedReturn    bool
	RetName          string
	AssignmentStr    string
}

UseAsErrorResultRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsErrorResult

func (u UseAsErrorResultRepr) String() string

type UseAsErrorRetWithNilabilityUnknown ¶

type UseAsErrorRetWithNilabilityUnknown struct {
	*TriggerIfNonNil

	IsNamedReturn bool
	RetStmt       *ast.ReturnStmt
}

UseAsErrorRetWithNilabilityUnknown is when a value flows to a point where it is returned from an error returning function

func (u *UseAsErrorRetWithNilabilityUnknown) Copy() ConsumingAnnotationTrigger

func (u *UseAsErrorRetWithNilabilityUnknown) Repr() fmt.Stringer

func (a UseAsErrorRetWithNilabilityUnknown) String() string

type UseAsErrorRetWithNilabilityUnknownRepr ¶

type UseAsErrorRetWithNilabilityUnknownRepr struct {
	FuncName      string
	RetNum        int
	IsNamedReturn bool
	RetName       string
	AssignmentStr string
}

UseAsErrorRetWithNilabilityUnknownRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsErrorRetWithNilabilityUnknown

func (u UseAsErrorRetWithNilabilityUnknownRepr) String() string

type UseAsFldOfReturn ¶

type UseAsFldOfReturn struct {
	*TriggerIfNonNil
}

UseAsFldOfReturn is when a struct field value (A.f) flows to a point where it is returned from a function with the return expression of the same struct type (A)

func (u *UseAsFldOfReturn) Copy() ConsumingAnnotationTrigger

func (u *UseAsFldOfReturn) Repr() fmt.Stringer

func (a UseAsFldOfReturn) String() string

type UseAsFldOfReturnRepr ¶

type UseAsFldOfReturnRepr struct {
	FuncName      string
	FieldName     string
	RetNum        int
	AssignmentStr string
}

UseAsFldOfReturnRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsFldOfReturn

func (u UseAsFldOfReturnRepr) String() string

type UseAsNonErrorRetDependentOnErrorRetNilability ¶

type UseAsNonErrorRetDependentOnErrorRetNilability struct {
	*TriggerIfNonNil

	IsNamedReturn bool
	RetStmt       *ast.ReturnStmt
}

UseAsNonErrorRetDependentOnErrorRetNilability is when a value flows to a point where it is returned from an error returning function

func (u *UseAsNonErrorRetDependentOnErrorRetNilability) Copy() ConsumingAnnotationTrigger

func (u *UseAsNonErrorRetDependentOnErrorRetNilability) Repr() fmt.Stringer

func (a UseAsNonErrorRetDependentOnErrorRetNilability) String() string

type UseAsNonErrorRetDependentOnErrorRetNilabilityRepr ¶

type UseAsNonErrorRetDependentOnErrorRetNilabilityRepr struct {
	FuncName      string
	RetNum        int
	RetName       string
	ErrRetNum     int
	IsNamedReturn bool
	AssignmentStr string
}

UseAsNonErrorRetDependentOnErrorRetNilabilityRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsNonErrorRetDependentOnErrorRetNilability

func (u UseAsNonErrorRetDependentOnErrorRetNilabilityRepr) String() string

type UseAsReturn ¶

type UseAsReturn struct {
	*TriggerIfNonNil
	IsNamedReturn        bool
	IsTrackingAlwaysSafe bool
	RetStmt              *ast.ReturnStmt
}

UseAsReturn is when a value flows to a point where it is returned from a function. This consumer trigger can be used on top of two different sites: RetAnnotationKey & CallSiteRetAnnotationKey. RetAnnotationKey is the parameter site in the function declaration; CallSiteRetAnnotationKey is the argument site in the call expression. CallSiteRetAnnotationKey is specifically used for functions with contracts since we need to duplicate the sites for context sensitivity.

func (u *UseAsReturn) Copy() ConsumingAnnotationTrigger

func (u *UseAsReturn) Repr() fmt.Stringer

func (a UseAsReturn) String() string

type UseAsReturnDeep ¶

type UseAsReturnDeep struct {
	*TriggerIfDeepNonNil
	IsNamedReturn bool
	RetStmt       *ast.ReturnStmt
}

UseAsReturnDeep is when a deep value flows to a point where it is returned from a function.

func (u *UseAsReturnDeep) Copy() ConsumingAnnotationTrigger

func (u *UseAsReturnDeep) Repr() fmt.Stringer

func (a UseAsReturnDeep) String() string

type UseAsReturnDeepRepr ¶

type UseAsReturnDeepRepr struct {
	FuncName      string
	RetNum        int
	RetName       string
	AssignmentStr string
}

UseAsReturnDeepRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsReturnDeep

func (u UseAsReturnDeepRepr) String() string

type UseAsReturnRepr ¶

type UseAsReturnRepr struct {
	FuncName      string
	RetNum        int
	IsNamedReturn bool
	RetName       string
	// Location is empty for a UseAsReturn enclosing RetAnnotationKey. Location points to the
	// location of the result at the call site for a UseAsReturn enclosing
	// CallSiteRetAnnotationKey.
	Location      string
	AssignmentStr string
}

UseAsReturnRepr is a fmt.Stringer storing the needed information to compactly encode a UseAsReturn

func (u UseAsReturnRepr) String() string

type Val ¶

type Val struct {
	IsNilable        bool
	IsDeepNilable    bool
	IsNilableSet     bool
	IsDeepNilableSet bool
}

Val is a possible value of an Annotation

type VariadicFuncParam ¶

type VariadicFuncParam struct {
	*ProduceTriggerTautology
	VarDecl *types.Var
}

VariadicFuncParam is used when a value is determined to flow from a variadic function parameter, and thus always be nilable

func (v *VariadicFuncParam) Repr() fmt.Stringer

type VariadicFuncParamDeep ¶

type VariadicFuncParamDeep struct {
	*TriggerIfNilable
}

VariadicFuncParamDeep is used when a value is determined to flow deeply from a variadic function parameter, and thus be nilable iff the shallow Annotation on that parameter is nilable

func (v *VariadicFuncParamDeep) Repr() fmt.Stringer

type VariadicFuncParamDeepRepr ¶

type VariadicFuncParamDeepRepr struct {
	ParamName string
}

VariadicFuncParamDeepRepr is a fmt.Stringer storing the needed information to compactly encode a VariadicFuncParamDeep

func (v VariadicFuncParamDeepRepr) String() string

type VariadicFuncParamRepr ¶

type VariadicFuncParamRepr struct {
	ParamName string
}

VariadicFuncParamRepr is a fmt.Stringer storing the needed information to compactly encode a VariadicFuncParam

func (v VariadicFuncParamRepr) String() string

type VariadicParamAssignDeep ¶

type VariadicParamAssignDeep struct {
	*TriggerIfNonNil
}

VariadicParamAssignDeep is when a value flows to a point where it is assigned deeply into a variadic function parameter

func (v *VariadicParamAssignDeep) Copy() ConsumingAnnotationTrigger

func (v *VariadicParamAssignDeep) Repr() fmt.Stringer

func (a VariadicParamAssignDeep) String() string

type VariadicParamAssignDeepRepr ¶

type VariadicParamAssignDeepRepr struct {
	ParamName     string
	AssignmentStr string
}

VariadicParamAssignDeepRepr is a fmt.Stringer storing the needed information to compactly encode a VariadicParamAssignDeep

func (v VariadicParamAssignDeepRepr) String() string