feat: initial support for cxx collect

1. Since clangd does not support semanticTokens/range method, use
  semanticTokens/full + filtering to emulate.
2. Since the concept of package and module does not apply to C/C++,
  treat the whole repo as a single package/module.

Author: Hoblovski

lang/cxx/spec.go

@@ -15,7 +15,12 @@
 package cxx
 
 import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
 	lsp "github.com/cloudwego/abcoder/lang/lsp"
+	"github.com/cloudwego/abcoder/lang/utils"
 )
 
 type CxxSpec struct {
@@ -26,56 +31,165 @@ func NewCxxSpec() *CxxSpec {
 	return &CxxSpec{}
 }
 
+// XXX: maybe multi module support for C++?
 func (c *CxxSpec) WorkSpace(root string) (map[string]string, error) {
-	panic("TODO")
+	c.repo = root
+	rets := map[string]string{}
+	absPath, err := filepath.Abs(root)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get absolute path: %w", err)
+	}
+	rets["current"] = absPath
+	return rets, nil
 }
 
+// returns: mod, path, error
 func (c *CxxSpec) NameSpace(path string) (string, string, error) {
-	panic("TODO")
+	// external lib: only standard library (system headers), in /usr/
+	if !strings.HasPrefix(path, c.repo) {
+		if strings.HasPrefix(path, "/usr") {
+			// assume it is c system library
+			return "cstdlib", "cstdlib", nil
+		}
+		panic(fmt.Sprintf("external lib: %s\n", path))
+	}
+
+	return "current", "current", nil
+
 }
 
 func (c *CxxSpec) ShouldSkip(path string) bool {
-	panic("TODO")
+	if !strings.HasSuffix(path, ".c") {
+		return true
+	}
+	return false
+}
+
+func (c *CxxSpec) IsDocToken(tok lsp.Token) bool {
+	return tok.Type == "comment"
 }
 
 func (c *CxxSpec) DeclareTokenOfSymbol(sym lsp.DocumentSymbol) int {
-	panic("TODO")
+	for i, t := range sym.Tokens {
+		if c.IsDocToken(t) {
+			continue
+		}
+		for _, m := range t.Modifiers {
+			if m == "declaration" {
+				return i
+			}
+		}
+	}
+	return -1
 }
 
 func (c *CxxSpec) IsEntityToken(tok lsp.Token) bool {
-	panic("TODO")
+	return tok.Type == "class" || tok.Type == "function" || tok.Type == "variable"
 }
 
 func (c *CxxSpec) IsStdToken(tok lsp.Token) bool {
 	panic("TODO")
 }
 
 func (c *CxxSpec) TokenKind(tok lsp.Token) lsp.SymbolKind {
-	panic("TODO")
+	switch tok.Type {
+	case "class":
+		return lsp.SKStruct
+	case "enum":
+		return lsp.SKEnum
+	case "enumMember":
+		return lsp.SKEnumMember
+	case "function", "macro":
+		return lsp.SKFunction
+	// rust spec does not treat parameter as a variable
+	case "parameter":
+		return lsp.SKVariable
+	case "typeParameter":
+		return lsp.SKTypeParameter
+	// type: TODO
+	case "interface", "concept", "method", "modifier", "namespace", "type":
+		panic(fmt.Sprintf("Unsupported token type: %s at %+v\n", tok.Type, tok.Location))
+	case "bracket", "comment", "label", "operator", "property", "unknown":
+		return lsp.SKUnknown
+	}
+	panic(fmt.Sprintf("Weird token type: %s at %+v\n", tok.Type, tok.Location))
 }
 
 func (c *CxxSpec) IsMainFunction(sym lsp.DocumentSymbol) bool {
-	panic("TODO")
+	return sym.Kind == lsp.SKFunction && sym.Name == "main"
 }
 
 func (c *CxxSpec) IsEntitySymbol(sym lsp.DocumentSymbol) bool {
-	panic("TODO")
-}
+	typ := sym.Kind
+	return typ == lsp.SKFunction || typ == lsp.SKVariable || typ == lsp.SKClass
 
-func (c *CxxSpec) IsPublicSymbol(sym lsp.DocumentSymbol) bool {
-	panic("TODO")
 }
 
+func (c *CxxSpec) IsPublicSymbol(sym lsp.DocumentSymbol) bool {
+	id := c.DeclareTokenOfSymbol(sym)
+	if id == -1 {
+		return false
+	}
+	for _, m := range sym.Tokens[id].Modifiers {
+		if m == "globalScope" {
+			return true
+		}
+	}
+	return false
+}
+
+// TODO(cpp): support C++ OOP
 func (c *CxxSpec) HasImplSymbol() bool {
-	panic("TODO")
+	return false
 }
 
 func (c *CxxSpec) ImplSymbol(sym lsp.DocumentSymbol) (int, int, int) {
 	panic("TODO")
 }
 
 func (c *CxxSpec) FunctionSymbol(sym lsp.DocumentSymbol) (int, []int, []int, []int) {
-	panic("TODO")
+	// No receiver and no type params for C
+	if sym.Kind != lsp.SKFunction {
+		return -1, nil, nil, nil
+	}
+	receiver := -1
+	typeParams := []int{}
+	inputParams := []int{}
+	outputs := []int{}
+
+	// general format: RETURNVALUE NAME "("  PARAMS  ")"  BODY
+	//                             --------
+	//                             fnNameText
+	// state machine   phase 0           phase 1        phase 2: break
+	// TODO: attributes may contain parens. also inline structs.
+
+	endRelOffset := 0
+	lines := utils.CountLinesCached(sym.Text)
+	phase := 0
+	for i, tok := range sym.Tokens {
+		switch phase {
+		case 0:
+			if tok.Type == "function" {
+				offset := lsp.RelativePostionWithLines(*lines, sym.Location.Range.Start, tok.Location.Range.Start)
+				endRelOffset = offset + strings.Index(sym.Text[offset:], ")")
+				phase = 1
+				continue
+			}
+			if c.IsEntityToken(tok) {
+				outputs = append(outputs, i)
+			}
+		case 1:
+			offset := lsp.RelativePostionWithLines(*lines, sym.Location.Range.Start, tok.Location.Range.Start)
+			if offset > endRelOffset {
+				phase = 2
+				continue
+			}
+			if c.IsEntityToken(tok) {
+				inputParams = append(inputParams, i)
+			}
+		}
+	}
+	return receiver, typeParams, inputParams, outputs
 }
 
 func (c *CxxSpec) GetUnloadedSymbol(from lsp.Token, define lsp.Location) (string, error) {

lang/lsp/lsp.go

@@ -24,6 +24,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/cloudwego/abcoder/lang/uniast"
 	"github.com/cloudwego/abcoder/lang/utils"
 	"github.com/sourcegraph/go-lsp"
 )
@@ -284,6 +285,57 @@ func (cli *LSPClient) References(ctx context.Context, id Location) ([]Location,
 	return resp, nil
 }
 
+// TODO(perf): cache results especially for whole file queries.
+// TODO(refactor): infer use_full_method from capabilities
+func (cli *LSPClient) getSemanticTokensRange(ctx context.Context, req DocumentRange, resp *SemanticTokens, use_full_method bool) error {
+	if use_full_method {
+		req1 := struct {
+			TextDocument lsp.TextDocumentIdentifier `json:"textDocument"`
+		}{TextDocument: req.TextDocument}
+		if err := cli.Call(ctx, "textDocument/semanticTokens/full", req1, resp); err != nil {
+			return err
+		}
+		filterSemanticTokensInRange(resp, req.Range)
+	} else {
+		if err := cli.Call(ctx, "textDocument/semanticTokens/range", req, resp); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func filterSemanticTokensInRange(resp *SemanticTokens, r Range) {
+	// LSP starts from 0:0 but the project seems to use 1:1 (see collect PositionOffset)
+	curPos := Position{
+		Line:      0,
+		Character: 0,
+	}
+	newData := []uint32{}
+	includedIs := []int{}
+	for i := 0; i < len(resp.Data); i += 5 {
+		deltaLine := int(resp.Data[i])
+		deltaStart := int(resp.Data[i+1])
+		if deltaLine != 0 {
+			curPos.Line += deltaLine
+			curPos.Character = deltaStart
+		} else {
+			curPos.Character += deltaStart
+		}
+		if isPositionInRange(curPos, r, true) {
+			if len(newData) == 0 {
+				// add range start to initial delta
+				newData = append(newData, resp.Data[i:i+5]...)
+				newData[0] = uint32(curPos.Line)
+				newData[1] = uint32(curPos.Character)
+			} else {
+				newData = append(newData, resp.Data[i:i+5]...)
+			}
+			includedIs = append(includedIs, i)
+		}
+	}
+	resp.Data = newData
+}
+
 func (cli *LSPClient) SemanticTokens(ctx context.Context, id Location) ([]Token, error) {
 	// open file first
 	syms, err := cli.DocumentSymbols(ctx, id.URI)
@@ -304,7 +356,8 @@ func (cli *LSPClient) SemanticTokens(ctx context.Context, id Location) ([]Token,
 	}
 
 	var resp SemanticTokens
-	if err := cli.Call(ctx, "textDocument/semanticTokens/range", req, &resp); err != nil {
+	if err := cli.getSemanticTokensRange(ctx, req, &resp, cli.Language == uniast.Cxx); err != nil {
+
 		return nil, err
 	}