// CrossReferences implements part of the xrefs.Service interface.
func (t *tableImpl) CrossReferences(ctx context.Context, req *xpb.CrossReferencesRequest) (*xpb.CrossReferencesReply, error) {
tickets, err := xrefs.FixTickets(req.Ticket)
if err != nil {
return nil, err
}
stats := refStats{
max: int(req.PageSize),
}
if stats.max < 0 {
return nil, fmt.Errorf("invalid page_size: %d", req.PageSize)
} else if stats.max == 0 {
stats.max = defaultPageSize
} else if stats.max > maxPageSize {
stats.max = maxPageSize
}
var edgesPageToken string
if req.PageToken != "" {
rec, err := base64.StdEncoding.DecodeString(req.PageToken)
if err != nil {
return nil, fmt.Errorf("invalid page_token: %q", req.PageToken)
}
var t ipb.PageToken
if err := proto.Unmarshal(rec, &t); err != nil || t.Index < 0 {
return nil, fmt.Errorf("invalid page_token: %q", req.PageToken)
}
stats.skip = int(t.Index)
edgesPageToken = t.SecondaryToken
}
pageToken := stats.skip
reply := &xpb.CrossReferencesReply{
CrossReferences: make(map[string]*xpb.CrossReferencesReply_CrossReferenceSet, len(req.Ticket)),
Nodes: make(map[string]*xpb.NodeInfo, len(req.Ticket)),
Total: &xpb.CrossReferencesReply_Total{},
}
var nextToken *ipb.PageToken
wantMoreCrossRefs := edgesPageToken == "" &&
(req.DefinitionKind != xpb.CrossReferencesRequest_NO_DEFINITIONS ||
req.DeclarationKind != xpb.CrossReferencesRequest_NO_DECLARATIONS ||
req.ReferenceKind != xpb.CrossReferencesRequest_NO_REFERENCES ||
req.DocumentationKind != xpb.CrossReferencesRequest_NO_DOCUMENTATION ||
req.CallerKind != xpb.CrossReferencesRequest_NO_CALLERS)
for _, ticket := range tickets {
// TODO(schroederc): retrieve PagedCrossReferences in parallel
cr, err := t.crossReferences(ctx, ticket)
if err == table.ErrNoSuchKey {
log.Println("Missing CrossReferences:", ticket)
continue
} else if err != nil {
return nil, fmt.Errorf("error looking up cross-references for ticket %q: %v", ticket, err)
}
crs := &xpb.CrossReferencesReply_CrossReferenceSet{
Ticket: ticket,
}
if req.ExperimentalSignatures {
crs.DisplayName, err = xrefs.SlowSignature(ctx, t, ticket)
if err != nil {
log.Printf("WARNING: error looking up signature for ticket %q: %v", ticket, err)
}
}
for _, grp := range cr.Group {
switch {
case xrefs.IsDefKind(req.DefinitionKind, grp.Kind, cr.Incomplete):
reply.Total.Definitions += int64(len(grp.Anchor))
if wantMoreCrossRefs {
stats.addAnchors(&crs.Definition, grp.Anchor, req.AnchorText)
}
case xrefs.IsDeclKind(req.DeclarationKind, grp.Kind, cr.Incomplete):
reply.Total.Declarations += int64(len(grp.Anchor))
if wantMoreCrossRefs {
stats.addAnchors(&crs.Declaration, grp.Anchor, req.AnchorText)
}
case xrefs.IsDocKind(req.DocumentationKind, grp.Kind):
reply.Total.Documentation += int64(len(grp.Anchor))
if wantMoreCrossRefs {
stats.addAnchors(&crs.Documentation, grp.Anchor, req.AnchorText)
}
case xrefs.IsRefKind(req.ReferenceKind, grp.Kind):
reply.Total.References += int64(len(grp.Anchor))
if wantMoreCrossRefs {
stats.addAnchors(&crs.Reference, grp.Anchor, req.AnchorText)
}
}
}
if wantMoreCrossRefs && req.CallerKind != xpb.CrossReferencesRequest_NO_CALLERS {
anchors, err := xrefs.SlowCallersForCrossReferences(ctx, t, req.CallerKind == xpb.CrossReferencesRequest_OVERRIDE_CALLERS, req.ExperimentalSignatures, ticket)
if err != nil {
return nil, fmt.Errorf("error in SlowCallersForCrossReferences: %v", err)
}
reply.Total.Callers += int64(len(anchors))
stats.addRelatedAnchors(&crs.Caller, anchors, req.AnchorText)
}
for _, idx := range cr.PageIndex {
switch {
case xrefs.IsDefKind(req.DefinitionKind, idx.Kind, cr.Incomplete):
reply.Total.Definitions += int64(idx.Count)
if wantMoreCrossRefs && !stats.skipPage(idx) {
p, err := t.crossReferencesPage(ctx, idx.PageKey)
if err != nil {
return nil, fmt.Errorf("internal error: error retrieving cross-references page: %v", idx.PageKey)
}
stats.addAnchors(&crs.Definition, p.Group.Anchor, req.AnchorText)
}
case xrefs.IsDeclKind(req.DeclarationKind, idx.Kind, cr.Incomplete):
reply.Total.Declarations += int64(idx.Count)
if wantMoreCrossRefs && !stats.skipPage(idx) {
p, err := t.crossReferencesPage(ctx, idx.PageKey)
if err != nil {
return nil, fmt.Errorf("internal error: error retrieving cross-references page: %v", idx.PageKey)
}
stats.addAnchors(&crs.Declaration, p.Group.Anchor, req.AnchorText)
}
case xrefs.IsDocKind(req.DocumentationKind, idx.Kind):
reply.Total.Documentation += int64(idx.Count)
if wantMoreCrossRefs && !stats.skipPage(idx) {
p, err := t.crossReferencesPage(ctx, idx.PageKey)
if err != nil {
return nil, fmt.Errorf("internal error: error retrieving cross-references page: %v", idx.PageKey)
}
stats.addAnchors(&crs.Documentation, p.Group.Anchor, req.AnchorText)
}
case xrefs.IsRefKind(req.ReferenceKind, idx.Kind):
reply.Total.References += int64(idx.Count)
if wantMoreCrossRefs && !stats.skipPage(idx) {
p, err := t.crossReferencesPage(ctx, idx.PageKey)
if err != nil {
return nil, fmt.Errorf("internal error: error retrieving cross-references page: %v", idx.PageKey)
}
stats.addAnchors(&crs.Reference, p.Group.Anchor, req.AnchorText)
}
}
}
if len(crs.Declaration) > 0 || len(crs.Definition) > 0 || len(crs.Reference) > 0 || len(crs.Documentation) > 0 || len(crs.Caller) > 0 {
reply.CrossReferences[crs.Ticket] = crs
}
}
if pageToken+stats.total != sumTotalCrossRefs(reply.Total) && stats.total != 0 {
nextToken = &ipb.PageToken{Index: int32(pageToken + stats.total)}
}
if len(req.Filter) > 0 {
er, err := t.edges(ctx, edgesRequest{
Tickets: tickets,
Filters: req.Filter,
Kinds: func(kind string) bool { return !schema.IsAnchorEdge(kind) },
PageToken: edgesPageToken,
TotalOnly: (stats.max <= stats.total),
PageSize: stats.max - stats.total,
})
if err != nil {
return nil, fmt.Errorf("error getting related nodes: %v", err)
}
reply.Total.RelatedNodesByRelation = er.TotalEdgesByKind
for ticket, es := range er.EdgeSets {
nodes := stringset.New()
crs, ok := reply.CrossReferences[ticket]
if !ok {
crs = &xpb.CrossReferencesReply_CrossReferenceSet{
Ticket: ticket,
}
}
for kind, g := range es.Groups {
for _, edge := range g.Edge {
nodes.Add(edge.TargetTicket)
crs.RelatedNode = append(crs.RelatedNode, &xpb.CrossReferencesReply_RelatedNode{
RelationKind: kind,
Ticket: edge.TargetTicket,
Ordinal: edge.Ordinal,
})
}
}
if len(nodes) > 0 {
for ticket, n := range er.Nodes {
if nodes.Contains(ticket) {
reply.Nodes[ticket] = n
}
}
}
if !ok && len(crs.RelatedNode) > 0 {
reply.CrossReferences[ticket] = crs
}
}
if er.NextPageToken != "" {
nextToken = &ipb.PageToken{SecondaryToken: er.NextPageToken}
}
}
if nextToken != nil {
rec, err := proto.Marshal(nextToken)
if err != nil {
return nil, fmt.Errorf("internal error: error marshalling page token: %v", err)
}
reply.NextPageToken = base64.StdEncoding.EncodeToString(rec)
}
if req.NodeDefinitions {
nodeTickets := make([]string, 0, len(reply.Nodes))
for ticket := range reply.Nodes {
nodeTickets = append(nodeTickets, ticket)
}
// TODO(schroederc): cache this in the serving data
defs, err := xrefs.SlowDefinitions(t, ctx, nodeTickets)
if err != nil {
return nil, fmt.Errorf("error retrieving node definitions: %v", err)
}
reply.DefinitionLocations = make(map[string]*xpb.Anchor, len(defs))
for ticket, def := range defs {
node, ok := reply.Nodes[ticket]
if !ok {
panic(fmt.Sprintf("extra definition returned for unknown node %q: %v", ticket, def))
}
node.Definition = def.Ticket
if _, ok := reply.DefinitionLocations[def.Ticket]; !ok {
reply.DefinitionLocations[def.Ticket] = def
}
}
}
return reply, nil
}
// Decorations implements part of the xrefs Service interface.
func (t *tableImpl) Decorations(ctx context.Context, req *xpb.DecorationsRequest) (*xpb.DecorationsReply, error) {
if req.GetLocation() == nil || req.GetLocation().Ticket == "" {
return nil, errors.New("missing location")
}
ticket, err := kytheuri.Fix(req.GetLocation().Ticket)
if err != nil {
return nil, fmt.Errorf("invalid ticket %q: %v", req.GetLocation().Ticket, err)
}
decor, err := t.fileDecorations(ctx, ticket)
if err == table.ErrNoSuchKey {
return nil, xrefs.ErrDecorationsNotFound
} else if err != nil {
return nil, fmt.Errorf("lookup error for file decorations %q: %v", ticket, err)
}
text := decor.File.Text
if len(req.DirtyBuffer) > 0 {
text = req.DirtyBuffer
}
norm := xrefs.NewNormalizer(text)
loc, err := norm.Location(req.GetLocation())
if err != nil {
return nil, err
}
reply := &xpb.DecorationsReply{Location: loc}
if req.SourceText {
reply.Encoding = decor.File.Encoding
if loc.Kind == xpb.Location_FILE {
reply.SourceText = text
} else {
reply.SourceText = text[loc.Start.ByteOffset:loc.End.ByteOffset]
}
}
if req.References {
patterns := xrefs.ConvertFilters(req.Filter)
var patcher *xrefs.Patcher
if len(req.DirtyBuffer) > 0 {
patcher = xrefs.NewPatcher(decor.File.Text, req.DirtyBuffer)
}
// The span with which to constrain the set of returned anchor references.
var startBoundary, endBoundary int32
spanKind := req.SpanKind
if loc.Kind == xpb.Location_FILE {
startBoundary = 0
endBoundary = int32(len(text))
spanKind = xpb.DecorationsRequest_WITHIN_SPAN
} else {
startBoundary = loc.Start.ByteOffset
endBoundary = loc.End.ByteOffset
}
reply.Reference = make([]*xpb.DecorationsReply_Reference, 0, len(decor.Decoration))
reply.Nodes = make(map[string]*xpb.NodeInfo)
seenTarget := stringset.New()
// Reference.TargetTicket -> NodeInfo (superset of reply.Nodes)
var nodes map[string]*xpb.NodeInfo
if len(patterns) > 0 {
nodes = make(map[string]*xpb.NodeInfo)
for _, n := range decor.Target {
nodes[n.Ticket] = nodeToInfo(patterns, n)
}
}
// Reference.TargetTicket -> []Reference set
var refs map[string][]*xpb.DecorationsReply_Reference
// ExpandedAnchor.Ticket -> ExpandedAnchor
var defs map[string]*srvpb.ExpandedAnchor
if req.TargetDefinitions {
refs = make(map[string][]*xpb.DecorationsReply_Reference)
reply.DefinitionLocations = make(map[string]*xpb.Anchor)
defs = make(map[string]*srvpb.ExpandedAnchor)
for _, def := range decor.TargetDefinitions {
defs[def.Ticket] = def
}
}
for _, d := range decor.Decoration {
start, end, exists := patcher.Patch(d.Anchor.StartOffset, d.Anchor.EndOffset)
// Filter non-existent anchor. Anchors can no longer exist if we were
// given a dirty buffer and the anchor was inside a changed region.
if exists {
if xrefs.InSpanBounds(spanKind, start, end, startBoundary, endBoundary) {
d.Anchor.StartOffset = start
d.Anchor.EndOffset = end
r := decorationToReference(norm, d)
if req.TargetDefinitions {
if def, ok := defs[d.TargetDefinition]; ok {
reply.DefinitionLocations[d.TargetDefinition] = a2a(def, false).Anchor
} else {
refs[r.TargetTicket] = append(refs[r.TargetTicket], r)
}
} else {
r.TargetDefinition = ""
}
reply.Reference = append(reply.Reference, r)
if !seenTarget.Contains(r.TargetTicket) && nodes != nil {
reply.Nodes[r.TargetTicket] = nodes[r.TargetTicket]
seenTarget.Add(r.TargetTicket)
}
}
}
}
// Only compute target definitions if the serving data doesn't contain any
// TODO(schroederc): remove this once serving data is always populated
if req.TargetDefinitions && len(defs) == 0 {
targetTickets := make([]string, 0, len(refs))
for ticket := range refs {
targetTickets = append(targetTickets, ticket)
}
defs, err := xrefs.SlowDefinitions(t, ctx, targetTickets)
if err != nil {
return nil, fmt.Errorf("error retrieving target definitions: %v", err)
}
reply.DefinitionLocations = make(map[string]*xpb.Anchor, len(defs))
for tgt, def := range defs {
for _, ref := range refs[tgt] {
if def.Ticket != ref.SourceTicket {
ref.TargetDefinition = def.Ticket
if _, ok := reply.DefinitionLocations[def.Ticket]; !ok {
reply.DefinitionLocations[def.Ticket] = def
}
}
}
}
}
}
return reply, nil
}