feat(internal/config): reduce calling libclang mutiple times

_xtool/internal/header/header.go

@@ -1,8 +1,13 @@
 package header
 
 import (
+	"fmt"
+	"io"
+	"maps"
 	"os"
 	"path/filepath"
+	"slices"
+	"sort"
 	"strings"
 
 	"github.com/goplus/lib/c/clang"
@@ -41,75 +46,84 @@ func PkgHfileInfo(includes []string, args []string, mix bool) *PkgHfilesInfo {
 	}
 	defer os.Remove(outfile.Name())
 
-	inters := make(map[string]struct{})
-	others := []string{} // impl & third
-	for _, f := range includes {
-		content := "#include <" + f + ">"
-		index, unit, err := clangutils.CreateTranslationUnit(&clangutils.Config{
-			File: content,
-			Temp: true,
-			Args: args,
-		})
-		if err != nil {
-			panic(err)
-		}
-		clangutils.GetInclusions(unit, func(inced clang.File, incins []clang.SourceLocation) {
-			if len(incins) == 1 {
-				filename := filepath.Clean(clang.GoString(inced.FileName()))
-				info.Inters = append(info.Inters, filename)
-				inters[filename] = struct{}{}
-			}
-		})
-		unit.Dispose()
-		index.Dispose()
+	mmOutput, err := os.CreateTemp("", "mmoutput_*")
+	if err != nil {
+		panic(err)
+	}
+	defer os.Remove(mmOutput.Name())
+
+	includeTrie := NewTrie(WithReversePathSegmenter())
+
+	for _, inc := range includes {
+		includeTrie.Insert(inc)
+		args = append(args, fmt.Sprintf("--no-system-header-prefix=%s", inc))
 	}
 
+	args = append(args, "-MM", "-MF", mmOutput.Name())
+
 	clangtool.ComposeIncludes(includes, outfile.Name())
 	index, unit, err := clangutils.CreateTranslationUnit(&clangutils.Config{
 		File: outfile.Name(),
 		Temp: false,
 		Args: args,
 	})
+
 	defer unit.Dispose()
 	defer index.Dispose()
 	if err != nil {
 		panic(err)
 	}
+
+	var others []string
+	inters, longestPrefix := RetrieveInterfaceFromMM(outfile.Name(), mmOutput, includeTrie)
+
 	clangutils.GetInclusions(unit, func(inced clang.File, incins []clang.SourceLocation) {
 		// not in the first level include maybe impl or third hfile
 		filename := filepath.Clean(clang.GoString(inced.FileName()))
-		_, inter := inters[filename]
-		if len(incins) > 1 && !inter {
+
+		// skip the composed header
+		if filename == outfile.Name() {
+			return
+		}
+
+		if _, isInterface := inters[filename]; !isInterface {
 			others = append(others, filename)
 		}
 	})
 
-	if mix {
-		info.Thirds = others
-		return info
-	}
+	info.Inters = slices.Collect(maps.Keys(inters))
 
-	root, err := filepath.Abs(commonParentDir(info.Inters))
+	absLongestPrefix, err := filepath.Abs(longestPrefix)
 	if err != nil {
 		panic(err)
 	}
-	for _, f := range others {
-		file, err := filepath.Abs(f)
+
+	fmt.Fprintln(os.Stderr, "tttttt", longestPrefix, CommonParentDir(info.Inters))
+
+	for _, filename := range others {
+		if mix {
+			info.Thirds = append(info.Thirds, filename)
+			continue
+		}
+		filePath, err := filepath.Abs(filename)
 		if err != nil {
 			panic(err)
 		}
-		if strings.HasPrefix(file, root) {
-			info.Impls = append(info.Impls, f)
+		if strings.HasPrefix(filePath, absLongestPrefix) {
+			info.Impls = append(info.Impls, filename)
 		} else {
-			info.Thirds = append(info.Thirds, f)
+			info.Thirds = append(info.Thirds, filename)
 		}
 	}
+
+	sort.Strings(info.Inters)
+
 	return info
 }
 
 // commonParentDir finds the longest common parent directory path for a given slice of paths.
 // For example, given paths ["/a/b/c/d", "/a/b/e/f"], it returns "/a/b".
-func commonParentDir(paths []string) string {
+func CommonParentDir(paths []string) string {
 	if len(paths) == 0 {
 		return ""
 	}
@@ -128,3 +142,33 @@ func commonParentDir(paths []string) string {
 	}
 	return filepath.Dir(paths[0])
 }
+
+func RetrieveInterfaceFromMM(
+	composedHeaderFileName string,
+	mmOutput *os.File,
+	includeTrie *Trie,
+) (interfaceMap map[string]struct{}, prefix string) {
+	fileName := strings.TrimSuffix(filepath.Base(composedHeaderFileName), ".h")
+
+	interfaceMap = make(map[string]struct{})
+
+	content, _ := io.ReadAll(mmOutput)
+
+	mmTrie := NewTrie()
+
+	for _, line := range strings.Fields(string(content)) {
+		// skip composed header file
+		if strings.Contains(line, fileName) || line == `\` {
+			continue
+		}
+		headerFile := filepath.Clean(line)
+
+		if includeTrie.IsOnSameBranch(headerFile) {
+			mmTrie.Insert(headerFile)
+
+			interfaceMap[headerFile] = struct{}{}
+		}
+	}
+	prefix = mmTrie.LongestPrefix()
+	return
+}

_xtool/internal/header/header_test.go

@@ -2,11 +2,16 @@ package header_test
 
 import (
 	"fmt"
+	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/goplus/lib/c/clang"
+	clangutils "github.com/goplus/llcppg/_xtool/internal/clang"
+	"github.com/goplus/llcppg/_xtool/internal/clangtool"
 	"github.com/goplus/llcppg/_xtool/internal/header"
 	llconfig "github.com/goplus/llcppg/config"
 )
@@ -73,3 +78,173 @@ func TestPkgHfileInfo(t *testing.T) {
 		})
 	}
 }
+
+func TestLongestPrefix(t *testing.T) {
+	testCases := []struct {
+		name string
+		strs []string
+		want string
+	}{
+		{
+			name: "empty string 1",
+			strs: []string{},
+			want: "",
+		},
+		{
+			name: "empty string 2",
+			strs: []string{"", ""},
+			want: ".",
+		},
+		{
+			name: "one empty string(b)",
+			strs: []string{"/a", ""},
+			want: "",
+		},
+		{
+			name: "one empty string(a)",
+			strs: []string{"", "/a"},
+
+			want: "",
+		},
+		// FIXME: substring bug
+		// {
+		// 	name: "b is substring of a",
+		// 	strs: []string{"/usr/a/b", "/usr/a"},
+		// 	want: "/usr/a",
+		// },
+		// {
+		// 	name: "a is substring of b",
+		// 	strs: []string{"/usr/c", "/usr/c/b"},
+		// 	want: "/usr/c",
+		// },
+		{
+			name: "normal case 1",
+			strs: []string{"testdata/hfile/temp1.h", "testdata/thirdhfile/third.h"},
+			want: "testdata",
+		},
+		{
+			name: "normal case 2",
+			strs: []string{"testdata/hfile/temp1.h", "testdata/hfile/third.h"},
+
+			want: "testdata/hfile",
+		},
+		// FIXME: absolute path
+		// {
+		// 	name: "normal case 3",
+		// 	strs: []string{"/opt/homebrew/Cellar/cjson/1.7.18/include/cJSON/cJSON.h", "/opt/homebrew/Cellar/cjson/1.7.18/include/cJSON.h", "/opt/homebrew/Cellar/cjson/1.7.18/include/zlib/zlib.h"},
+		// 	want: "/opt/homebrew/Cellar/cjson/1.7.18/include",
+		// },
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := header.CommonParentDir(tc.strs); got != tc.want {
+				t.Fatalf("unexpected longest prefix: want %s got %s", tc.want, got)
+			}
+		})
+	}
+}
+
+func benchmarkFn(fn func()) time.Duration {
+	now := time.Now()
+
+	fn()
+
+	return time.Since(now)
+}
+
+func TestBenchmarkPkgHfileInfo(t *testing.T) {
+	include := []string{"temp1.h", "temp2.h"}
+	cflags := []string{"-I./testdata/hfile", "-I./testdata/thirdhfile"}
+	t1 := benchmarkFn(func() {
+		for i := 0; i < 100; i++ {
+			pkgHfileInfo(include, cflags, false)
+		}
+	})
+
+	t2 := benchmarkFn(func() {
+		for i := 0; i < 100; i++ {
+			header.PkgHfileInfo(include, cflags, false)
+		}
+	})
+
+	fmt.Println("old PkgHfileInfo elapsed: ", t1, "new PkgHfileInfo elasped: ", t2)
+}
+
+func pkgHfileInfo(includes []string, args []string, mix bool) *header.PkgHfilesInfo {
+	info := &header.PkgHfilesInfo{
+		Inters: []string{},
+		Impls:  []string{},
+		Thirds: []string{},
+	}
+	outfile, err := os.CreateTemp("", "compose_*.h")
+	if err != nil {
+		panic(err)
+	}
+	defer os.Remove(outfile.Name())
+
+	inters := make(map[string]struct{})
+	others := []string{} // impl & third
+	for _, f := range includes {
+		content := "#include <" + f + ">"
+		index, unit, err := clangutils.CreateTranslationUnit(&clangutils.Config{
+			File: content,
+			Temp: true,
+			Args: args,
+		})
+		if err != nil {
+			panic(err)
+		}
+		clangutils.GetInclusions(unit, func(inced clang.File, incins []clang.SourceLocation) {
+			if len(incins) == 1 {
+				filename := filepath.Clean(clang.GoString(inced.FileName()))
+				info.Inters = append(info.Inters, filename)
+				inters[filename] = struct{}{}
+			}
+		})
+		unit.Dispose()
+		index.Dispose()
+	}
+
+	clangtool.ComposeIncludes(includes, outfile.Name())
+	index, unit, err := clangutils.CreateTranslationUnit(&clangutils.Config{
+		File: outfile.Name(),
+		Temp: false,
+		Args: args,
+	})
+	defer unit.Dispose()
+	defer index.Dispose()
+	if err != nil {
+		panic(err)
+	}
+	clangutils.GetInclusions(unit, func(inced clang.File, incins []clang.SourceLocation) {
+		// not in the first level include maybe impl or third hfile
+		filename := filepath.Clean(clang.GoString(inced.FileName()))
+		_, inter := inters[filename]
+		if len(incins) > 1 && !inter {
+			others = append(others, filename)
+		}
+	})
+
+	if mix {
+		info.Thirds = others
+		return info
+	}
+
+	root, err := filepath.Abs(header.CommonParentDir(info.Inters))
+	if err != nil {
+		panic(err)
+	}
+	for _, f := range others {
+		file, err := filepath.Abs(f)
+		if err != nil {
+			panic(err)
+		}
+		if strings.HasPrefix(file, root) {
+			info.Impls = append(info.Impls, f)
+		} else {
+			info.Thirds = append(info.Thirds, f)
+		}
+	}
+	return info
+}

_xtool/internal/header/testdata/hfile/temp1.h

@@ -1,2 +1,3 @@
 #include "tempimpl.h"
+#include "temp2.h"
 #include <third.h>