optional use esp clang for non-cross-compilation

internal/build/build.go

@@ -159,7 +159,8 @@ func Do(args []string, conf *Config) ([]Package, error) {
 		conf.Goarch = runtime.GOARCH
 	}
 	// Handle crosscompile configuration first to set correct GOOS/GOARCH
-	export, err := crosscompile.Use(conf.Goos, conf.Goarch, IsWasiThreadsEnabled(), conf.Target)
+	forceEspClang := conf.Target != ""
+	export, err := crosscompile.Use(conf.Goos, conf.Goarch, conf.Target, IsWasiThreadsEnabled(), forceEspClang)
 	if err != nil {
 		return nil, fmt.Errorf("failed to setup crosscompile: %w", err)
 	}

internal/crosscompile/crosscompile.go

@@ -156,7 +156,7 @@ func getMacOSSysroot() (string, error) {
 
 // getESPClangRoot returns the ESP Clang root directory, checking LLGoROOT first,
 // then downloading if needed and platform is supported
-func getESPClangRoot() (clangRoot string, err error) {
+func getESPClangRoot(forceEspClang bool) (clangRoot string, err error) {
 	llgoRoot := env.LLGoROOT()
 
 	// First check if clang exists in LLGoROOT
@@ -166,6 +166,10 @@ func getESPClangRoot() (clangRoot string, err error) {
 		return
 	}
 
+	if !forceEspClang {
+		return "", nil
+	}
+
 	// Try to download ESP Clang if platform is supported
 	platformSuffix := getESPClangPlatform(runtime.GOOS, runtime.GOARCH)
 	if platformSuffix != "" {
@@ -215,39 +219,39 @@ func getESPClangPlatform(goos, goarch string) string {
 	return ""
 }
 
-func use(goos, goarch string, wasiThreads bool) (export Export, err error) {
+func use(goos, goarch string, wasiThreads, forceEspClang bool) (export Export, err error) {
 	targetTriple := llvm.GetTargetTriple(goos, goarch)
 	llgoRoot := env.LLGoROOT()
 
 	// Check for ESP Clang support for target-based builds
-	clangRoot, err := getESPClangRoot()
+	clangRoot, err := getESPClangRoot(forceEspClang)
 	if err != nil {
 		return
 	}
 
 	// Set ClangRoot and CC if clang is available
 	export.ClangRoot = clangRoot
+	if clangRoot != "" {
 		export.CC = filepath.Join(clangRoot, "bin", "clang++")
+	} else {
+		export.CC = "clang++"
+	}
 
 	if runtime.GOOS == goos && runtime.GOARCH == goarch {
-		clangLib := filepath.Join(clangRoot, "lib")
-		clangInc := filepath.Join(clangRoot, "include")
 		// not cross compile
 		// Set up basic flags for non-cross-compile
 		export.LDFLAGS = []string{
-			"-L" + clangLib,
 			"-target", targetTriple,
 			"-Qunused-arguments",
 			"-Wno-unused-command-line-argument",
 			"-Wl,--error-limit=0",
 			"-fuse-ld=lld",
 		}
+		if clangRoot != "" {
+			clangLib := filepath.Join(clangRoot, "lib")
+			clangInc := filepath.Join(clangRoot, "include")
 			export.CFLAGS = append(export.CFLAGS, "-I"+clangInc)
-		export.CCFLAGS = []string{
+			export.LDFLAGS = append(export.LDFLAGS, "-L"+clangLib)
-			"-Qunused-arguments",
-			"-Wno-unused-command-line-argument",
-		}
-
 			// Add platform-specific rpath flags
 			switch goos {
 			case "darwin":
@@ -260,6 +264,11 @@ func use(goos, goarch string, wasiThreads bool) (export Export, err error) {
 				// For other Unix-like systems, try the generic rpath
 				export.LDFLAGS = append(export.LDFLAGS, "-Wl,-rpath,"+clangLib)
 			}
+		}
+		export.CCFLAGS = []string{
+			"-Qunused-arguments",
+			"-Wno-unused-command-line-argument",
+		}
 
 		// Add sysroot for macOS only
 		if goos == "darwin" {
@@ -452,7 +461,7 @@ func useTarget(targetName string) (export Export, err error) {
 	}
 
 	// Check for ESP Clang support for target-based builds
-	clangRoot, err := getESPClangRoot()
+	clangRoot, err := getESPClangRoot(true)
 	if err != nil {
 		return
 	}
@@ -585,9 +594,9 @@ func useTarget(targetName string) (export Export, err error) {
 
 // Use extends the original Use function to support target-based configuration
 // If targetName is provided, it takes precedence over goos/goarch
-func Use(goos, goarch string, wasiThreads bool, targetName string) (export Export, err error) {
+func Use(goos, goarch, targetName string, wasiThreads, forceEspClang bool) (export Export, err error) {
 	if targetName != "" {
 		return useTarget(targetName)
 	}
-	return use(goos, goarch, wasiThreads)
+	return use(goos, goarch, wasiThreads, forceEspClang)
 }

internal/crosscompile/crosscompile_test.go

@@ -39,8 +39,8 @@ func TestUseCrossCompileSDK(t *testing.T) {
 			goarch:        runtime.GOARCH,
 			expectSDK:     true,  // Changed: now we expect flags even for same platform
 			expectCCFlags: true,  // Changed: CCFLAGS will contain sysroot
-			expectCFlags:  true, // Changed: CFLAGS will contain include paths
+			expectCFlags:  false, // Changed: CFLAGS will not contain include paths
-			expectLDFlags: true, // Changed: LDFLAGS will contain library paths
+			expectLDFlags: false, // Changed: LDFLAGS will not contain library paths
 		},
 		{
 			name:          "WASM Target",
@@ -76,7 +76,7 @@ func TestUseCrossCompileSDK(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			export, err := use(tc.goos, tc.goarch, false)
+			export, err := use(tc.goos, tc.goarch, false, false)
 
 			if err != nil {
 				t.Fatalf("Unexpected error: %v", err)
@@ -279,7 +279,7 @@ func TestUseTarget(t *testing.T) {
 
 func TestUseWithTarget(t *testing.T) {
 	// Test target-based configuration takes precedence
-	export, err := Use("linux", "amd64", false, "wasi")
+	export, err := Use("linux", "amd64", "wasi", false, true)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -291,7 +291,7 @@ func TestUseWithTarget(t *testing.T) {
 	}
 
 	// Test fallback to goos/goarch when no target specified
-	export, err = Use(runtime.GOOS, runtime.GOARCH, false, "")
+	export, err = Use(runtime.GOOS, runtime.GOARCH, "", false, false)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}