golang源码分析 ：gopls（9）

type callHierarchy struct {
    app *Application
}

func (c *callHierarchy) Run(ctx context.Context, args ...string) error {
    if len(args) != 1 {
        return tool.CommandLineErrorf("call_hierarchy expects 1 argument (position)")
    }
    conn, err := c.app.connect(ctx)
    if err != nil {
        return err
    }
    defer conn.terminate(ctx)
    from := parseSpan(args[0])
    file, err := conn.openFile(ctx, from.URI())
    if err != nil {
        return err
    }
    loc, err := file.spanLocation(from)
    if err != nil {
        return err
    }
    p := protocol.CallHierarchyPrepareParams{
        TextDocumentPositionParams: protocol.LocationTextDocumentPositionParams(loc),
    }
    callItems, err := conn.PrepareCallHierarchy(ctx, &p)
    if err != nil {
        return err
    }
    if len(callItems) == 0 {
        return fmt.Errorf("function declaration identifier not found at %v", args[0])
    }
    for _, item := range callItems {
        incomingCalls, err := conn.IncomingCalls(ctx, &protocol.CallHierarchyIncomingCallsParams{Item: item})
        if err != nil {
            return err
        }
        for i, call := range incomingCalls {
            // From the spec: CallHierarchyIncomingCall.FromRanges is relative to
            // the caller denoted by CallHierarchyIncomingCall.from.
            printString, err := callItemPrintString(ctx, conn, call.From, call.From.URI, call.FromRanges)
            if err != nil {
                return err
            }
            fmt.Printf("caller[%d]: %s\n", i, printString)
        }
        printString, err := callItemPrintString(ctx, conn, item, "", nil)
        if err != nil {
            return err
        }
        fmt.Printf("identifier: %s\n", printString)
        outgoingCalls, err := conn.OutgoingCalls(ctx, &protocol.CallHierarchyOutgoingCallsParams{Item: item})
        if err != nil {
            return err
        }
        for i, call := range outgoingCalls {
            // From the spec: CallHierarchyOutgoingCall.FromRanges is the range
            // relative to the caller, e.g the item passed to
            printString, err := callItemPrintString(ctx, conn, call.To, item.URI, call.FromRanges)
            if err != nil {
                return err
            }
            fmt.Printf("callee[%d]: %s\n", i, printString)
        }
    }
    return nil
}

// connect creates and initializes a new in-process gopls session.
func (app *Application) connect(ctx context.Context) (*connection, error) {
    client := newClient(app)
    var svr protocol.Server
    if app.Remote == "" {
        // local
        options := settings.DefaultOptions(app.options)
        svr = server.New(cache.NewSession(ctx, cache.New(nil)), client, options)
        ctx = protocol.WithClient(ctx, client)
    } else {
        // remote
        netConn, err := lsprpc.ConnectToRemote(ctx, app.Remote)
        if err != nil {
            return nil, err
        }
        stream := jsonrpc2.NewHeaderStream(netConn)
        jsonConn := jsonrpc2.NewConn(stream)
        svr = protocol.ServerDispatcher(jsonConn)
        ctx = protocol.WithClient(ctx, client)
        jsonConn.Go(ctx,
            protocol.Handlers(
                protocol.ClientHandler(client, jsonrpc2.MethodNotFound)))
    }
    conn := newConnection(svr, client)
    return conn, conn.initialize(ctx, app.options)
}

type CallHierarchyPrepareParams struct {
    TextDocumentPositionParams
    WorkDoneProgressParams
}

type WorkDoneProgressParams struct {
    // An optional token that a server can use to report work done progress.
    WorkDoneToken ProgressToken `json:"workDoneToken,omitempty"`
}

type TextDocumentPositionParams struct {
    // The text document.
    TextDocument TextDocumentIdentifier `json:"textDocument"`
    // The position inside the text document.
    Position Position `json:"position"`
}