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>