func canAlias(n1, n2 node) bool { … } func isReferenceNode(n node) bool { … } // hasInFlow checks if a concrete type can flow to node `n`. // Returns yes iff the type of `n` satisfies one the following: // 1. is an interface // 2. is a (nested) pointer to interface (needed for, say, // slice elements of nested pointers to interface type) // 3. is a function type (needed for higher-order type flow) // 4. is a (nested) pointer to function (needed for, say, // slice elements of nested pointers to function type) // 5. is a global Recover or Panic node func hasInFlow(n node) bool { … } func isFunction(t types.Type) bool { … } // interfaceUnderPtr checks if type `t` is a potentially nested // pointer to interface and if yes, returns the interface type. // Otherwise, returns nil. func interfaceUnderPtr(t types.Type) types.Type { … } // functionUnderPtr checks if type `t` is a potentially nested // pointer to function type and if yes, returns the function type. // Otherwise, returns nil. func functionUnderPtr(t types.Type) types.Type { … } // sliceArrayElem returns the element type of type `t` that is // expected to be a (pointer to) array, slice or string, consistent with // the ssa.Index and ssa.IndexAddr instructions. Panics otherwise. func sliceArrayElem(t types.Type) types.Type { … } // siteCallees returns a go1.23 iterator for the callees for call site `c`. func siteCallees(c ssa.CallInstruction, callees calleesFunc) func(yield func(*ssa.Function) bool) { … } func canHaveMethods(t types.Type) bool { … } // calls returns the set of call instructions in `f`. func calls(f *ssa.Function) []ssa.CallInstruction { … }