// exprAtPos returns the index of the expression containing pos. func exprAtPos(pos token.Pos, args []ast.Expr) int { … } // eachField invokes fn for each field that can be selected from a // value of type T. func eachField(T types.Type, fn func(*types.Var)) { … } // typeIsValid reports whether typ doesn't contain any Invalid types. func typeIsValid(typ types.Type) bool { … } // resolveInvalid traverses the node of the AST that defines the scope // containing the declaration of obj, and attempts to find a user-friendly // name for its invalid type. The resulting Object and its Type are fake. func resolveInvalid(fset *token.FileSet, obj types.Object, node ast.Node, info *types.Info) types.Object { … } // TODO(adonovan): inline these. func isVar(obj types.Object) bool { … } func isTypeName(obj types.Object) bool { … } func isFunc(obj types.Object) bool { … } func isPkgName(obj types.Object) bool { … } // isPointer reports whether T is a Pointer, or an alias of one. // It returns false for a Named type whose Underlying is a Pointer. // // TODO(adonovan): shouldn't this use CoreType(T)? func isPointer(T types.Type) bool { … } // isEmptyInterface whether T is a (possibly Named or Alias) empty interface // type, such that every type is assignable to T. // // isEmptyInterface returns false for type parameters, since they have // different assignability rules. func isEmptyInterface(T types.Type) bool { … } func isUntyped(T types.Type) bool { … } func deslice(T types.Type) types.Type { … } // isSelector returns the enclosing *ast.SelectorExpr when pos is in the // selector. func enclosingSelector(path []ast.Node, pos token.Pos) *ast.SelectorExpr { … } // enclosingDeclLHS returns LHS idents from containing value spec or // assign statement. func enclosingDeclLHS(path []ast.Node) []*ast.Ident { … } // exprObj returns the types.Object associated with the *ast.Ident or // *ast.SelectorExpr e. func exprObj(info *types.Info, e ast.Expr) types.Object { … } // typeConversion returns the type being converted to if call is a type // conversion expression. func typeConversion(call *ast.CallExpr, info *types.Info) types.Type { … } // fieldsAccessible returns whether s has at least one field accessible by p. func fieldsAccessible(s *types.Struct, p *types.Package) bool { … } // prevStmt returns the statement that precedes the statement containing pos. // For example: // // foo := 1 // bar(1 + 2<>) // // If "<>" is pos, prevStmt returns "foo := 1" func prevStmt(pos token.Pos, path []ast.Node) ast.Stmt { … } // formatZeroValue produces Go code representing the zero value of T. It // returns the empty string if T is invalid. func formatZeroValue(T types.Type, qf types.Qualifier) string { … } // isBasicKind returns whether t is a basic type of kind k. func isBasicKind(t types.Type, k types.BasicInfo) bool { … } func (c *completer) editText(from, to token.Pos, newText string) ([]protocol.TextEdit, error) { … } // assignableTo is like types.AssignableTo, but returns false if // either type is invalid. func assignableTo(x, to types.Type) bool { … } // convertibleTo is like types.ConvertibleTo, but returns false if // either type is invalid. func convertibleTo(x, to types.Type) bool { … }