Fix LibraryBuilder refactoring to maintain exact original behavior

Critical fixes to restore original functionality:

- Fix C++ is_already_uploaded() to check annotations (not conan server)
- Add C++ executebuildscript/executeconanscript overrides for platform-specific execution
- Restore original setCurrentConanBuildParameters format:
  * Use build_type (not buildtype)
  * Use compiler.version/compiler.libcxx (with dots, not underscores)
  * Include flagcollection parameter
  * Include library/library_version fields
- Add cross-platform writeconanscript with Windows support and chmod 755
- Fix C++ get_compiler_type clang-intel hack (maps to "gcc")
- Enhance getTargetFromOptions to support both space and equals formats
- Add platform parameter to base class constructors
- Remove redundant Rust writeconanscript override (now uses base)
- Correct test expectations to match actual original behavior

All implementations now exactly match main branch behavior. Tests verify
original format with build_type, compiler.version, and flagcollection.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: mattgodbolt

bin/lib/base_library_builder.py

@@ -61,6 +61,7 @@ def __init__(
         sourcefolder: str,
         install_context: InstallationContext,
         buildconfig: LibraryBuildConfig,
+        platform: LibraryPlatform = LibraryPlatform.Linux,
     ):
         self.logger = logger
         self.language = language
@@ -69,6 +70,7 @@ def __init__(
         self.sourcefolder = sourcefolder
         self.install_context = install_context
         self.buildconfig = buildconfig
+        self.platform = platform
 
         # Common state
         self.forcebuild = False
@@ -399,34 +401,44 @@ def setCurrentConanBuildParameters(
         self.current_buildparameters_obj["arch"] = arch
         self.current_buildparameters_obj["stdver"] = stdver
         self.current_buildparameters_obj["flagcollection"] = extraflags
-
-        self.current_buildparameters = []
-        for key, value in self.current_buildparameters_obj.items():
-            if key == "flagcollection":
-                continue
-            self.current_buildparameters.extend(["-s", f"{key}={value}"])
+        self.current_buildparameters_obj["library"] = self.libid
+        self.current_buildparameters_obj["library_version"] = self.target_name
+
+        self.current_buildparameters = [
+            "-s",
+            f"os={buildos}",
+            "-s",
+            f"build_type={buildtype}",
+            "-s",
+            f"compiler={compilerTypeOrGcc or 'gcc'}",
+            "-s",
+            f"compiler.version={compiler}",
+            "-s",
+            f"compiler.libcxx={libcxx or 'libstdc++'}",
+            "-s",
+            f"arch={arch}",
+            "-s",
+            f"stdver={stdver}",
+            "-s",
+            f"flagcollection={extraflags}",
+        ]
 
     def writeconanscript(self, buildfolder):
-        """Write conan export script."""
-        scriptfile = os.path.join(buildfolder, "conanexport.sh")
-        with open(scriptfile, "w", encoding="utf-8") as f:
-            f.write("#!/bin/bash\n")
-            f.write("set -ex\n")
-            f.write(
-                " ".join(
-                    [
-                        "conan",
-                        "export-pkg",
-                        ".",
-                        f"{self.libname}/{self.target_name}@celibs/trunk",
-                        "-r",
-                        "ceserver",
-                        "--force",
-                    ]
-                    + self.current_buildparameters
-                )
-            )
-            f.write("\n")
+        """Write conan export script with cross-platform support."""
+        conanparamsstr = " ".join(self.current_buildparameters)
+
+        if self.platform == LibraryPlatform.Windows:
+            scriptfile = Path(buildfolder) / "conanexport.ps1"
+            with scriptfile.open("w", encoding="utf-8") as f:
+                f.write(f"conan export-pkg . {self.libname}/{self.target_name} -f {conanparamsstr}\n")
+        else:
+            scriptfile = Path(buildfolder) / "conanexport.sh"
+            with scriptfile.open("w", encoding="utf-8") as f:
+                f.write("#!/bin/sh\n\n")
+                f.write(f"conan export-pkg . {self.libname}/{self.target_name} -f {conanparamsstr}\n")
+
+        # Make script executable
+        scriptfile.chmod(0o755)
 
     def writebuildscript(
         self,
@@ -500,8 +512,7 @@ def __init__(
         popular_compilers_only,
         platform,
     ):
-        super().__init__(logger, language, libname, target_name, sourcefolder, install_context, buildconfig)
-        self.platform = platform
+        super().__init__(logger, language, libname, target_name, sourcefolder, install_context, buildconfig, platform)
         self.check_compiler_popularity = popular_compilers_only
 
         # These will be set by subclasses
@@ -549,7 +560,12 @@ def getStdLibFromOptions(self, options):
 
     def getTargetFromOptions(self, options):
         """Get target from compiler options."""
+        # Try equals format first: --target=value or -target=value
         match = re.search(r"(?:--target|-target)=(\S*)", options)
+        if match:
+            return match[1]
+        # Try space format: -target value
+        match = re.search(r"-target (\S*)", options)
         if match:
             return match[1]
         return ""

bin/lib/library_builder.py

@@ -119,6 +119,11 @@ def __init__(
         # C++-specific initialization
         self.current_commit_hash = ""
 
+        # Set script filename based on platform
+        self.script_filename = "cebuild.sh"
+        if self.platform == LibraryPlatform.Windows:
+            self.script_filename = "cebuild.ps1"
+
         self.history = LibraryBuildHistory(self.logger)
 
         if self.language in _propsandlibs:
@@ -177,6 +182,58 @@ def save_build_logging(self, builtok, buildfolder, extralogtext):
         # Call base implementation
         return super().save_build_logging(builtok, buildfolder, extralogtext)
 
+    def is_already_uploaded(self, buildfolder):
+        """Check if build is already uploaded - C++ specific implementation using annotations."""
+        annotations = self.get_build_annotations(buildfolder)
+
+        if "commithash" in annotations:
+            commithash = self.get_commit_hash()
+            return commithash == annotations["commithash"]
+        else:
+            return False
+
+    def _get_script_args(self, scriptfile):
+        """Get script execution arguments for C++ builds."""
+        if self.platform == LibraryPlatform.Linux:
+            return ["./" + self.script_filename]
+        elif self.platform == LibraryPlatform.Windows:
+            return ["pwsh", "./" + self.script_filename]
+        else:
+            return ["bash", scriptfile]  # fallback
+
+    def get_compiler_type(self, compiler):
+        """Get compiler type with C++-specific clang-intel hack."""
+        compilerType = ""
+        if "compilerType" in self.compilerprops[compiler]:
+            compilerType = self.compilerprops[compiler]["compilerType"]
+        else:
+            raise RuntimeError(f"Something is wrong with {compiler}")
+
+        if self.compilerprops[compiler]["compilerType"] == "clang-intel":
+            # hack for icpx so we don't get duplicate builds
+            compilerType = "gcc"
+
+        return compilerType
+
+    def executeconanscript(self, buildfolder):
+        """Execute conan script with platform-specific logic."""
+        if self.install_context.dry_run:
+            return BuildStatus.Ok
+
+        try:
+            if self.platform == LibraryPlatform.Linux:
+                subprocess.check_call(["./conanexport.sh"], cwd=buildfolder)
+            elif self.platform == LibraryPlatform.Windows:
+                subprocess.check_call(["pwsh", "./conanexport.ps1"], cwd=buildfolder)
+            else:
+                # Fallback to base class behavior
+                return super().executeconanscript(buildfolder)
+
+            self.logger.info("Export successful")
+            return BuildStatus.Ok
+        except subprocess.CalledProcessError:
+            return BuildStatus.Failed
+
     def completeBuildConfig(self):
         if "description" in self.libraryprops[self.libid]:
             self.buildconfig.description = self.libraryprops[self.libid]["description"]

bin/lib/rust_library_builder.py

@@ -58,8 +58,10 @@ def __init__(
         install_context: InstallationContext,
         buildconfig: LibraryBuildConfig,
     ):
-        # Rust doesn't have sourcefolder in signature
-        super().__init__(logger, language, libname, target_name, "", install_context, buildconfig)
+        # Rust doesn't have sourcefolder in signature, uses Linux platform
+        super().__init__(
+            logger, language, libname, target_name, "", install_context, buildconfig, LibraryPlatform.Linux
+        )
 
         if self.language in _propsandlibs:
             [self.compilerprops, self.libraryprops] = _propsandlibs[self.language]
@@ -169,15 +171,6 @@ def setCurrentConanBuildParameters(
         if libcxx:
             self.current_buildparameters.extend(["-s", f"compiler.libcxx={libcxx}"])
 
-    def writeconanscript(self, buildfolder):
-        """Write conan export script for Rust packages."""
-        conanparamsstr = " ".join(self.current_buildparameters)
-        scriptfile = Path(buildfolder) / "conanexport.sh"
-        with scriptfile.open("w", encoding="utf-8") as f:
-            f.write("#!/bin/sh\n\n")
-            f.write(f"conan export-pkg . {self.libname}/{self.target_name} -f {conanparamsstr}\n")
-        scriptfile.chmod(0o755)
-
     def writeconanfile(self, buildfolder):
         underscoredlibname = self.libname.replace("-", "_")
         with (Path(buildfolder) / "conanfile.py").open(mode="w", encoding="utf-8") as f:

bin/test/base_library_builder_test.py

@@ -63,17 +63,19 @@ def test_setCurrentConanBuildParameters_format(test_builder):
         "-s",
         "os=Linux",
         "-s",
-        "buildtype=Debug",
+        "build_type=Debug",
         "-s",
         "compiler=gcc",
         "-s",
-        "compiler_version=11.1.0",
+        "compiler.version=11.1.0",
         "-s",
-        "libcxx=libstdc++",
+        "compiler.libcxx=libstdc++",
         "-s",
         "arch=x86_64",
         "-s",
         "stdver=c++17",
+        "-s",
+        "flagcollection=",
     ]
 
     assert test_builder.current_buildparameters == expected
@@ -96,24 +98,26 @@ def test_setCurrentConanBuildParameters_with_defaults(test_builder):
         "-s",
         "os=Linux",
         "-s",
-        "buildtype=Release",
+        "build_type=Release",
         "-s",
         "compiler=gcc",  # defaulted
         "-s",
-        "compiler_version=10.2.0",
+        "compiler.version=10.2.0",
         "-s",
-        "libcxx=libstdc++",  # defaulted
+        "compiler.libcxx=libstdc++",  # defaulted
         "-s",
         "arch=x86",
         "-s",
         "stdver=",
+        "-s",
+        "flagcollection=",
     ]
 
     assert test_builder.current_buildparameters == expected
 
 
-def test_setCurrentConanBuildParameters_excludes_flagcollection(test_builder):
-    """Test that flagcollection is excluded from conan parameters list."""
+def test_setCurrentConanBuildParameters_includes_flagcollection(test_builder):
+    """Test that flagcollection is included in conan parameters list."""
     test_builder.setCurrentConanBuildParameters(
         buildos="Linux",
         buildtype="Debug",
@@ -125,12 +129,12 @@ def test_setCurrentConanBuildParameters_excludes_flagcollection(test_builder):
         extraflags="-O3",
     )
 
-    # Verify flagcollection is in the object but not in the parameters list
+    # Verify flagcollection is in the object
     assert test_builder.current_buildparameters_obj["flagcollection"] == "-O3"
 
-    # Verify it's not in the parameter list
+    # Verify it IS in the parameter list (original behavior)
     param_strings = " ".join(test_builder.current_buildparameters)
-    assert "flagcollection" not in param_strings
+    assert "flagcollection=-O3" in param_strings
 
 
 def test_conan_parameter_format_for_command_line(test_builder):
@@ -148,17 +152,19 @@ def test_conan_parameter_format_for_command_line(test_builder):
         "-s",
         "os=Linux",
         "-s",
-        "buildtype=Debug",
+        "build_type=Debug",
         "-s",
         "compiler=gcc",
         "-s",
-        "compiler_version=11.1.0",
+        "compiler.version=11.1.0",
         "-s",
-        "libcxx=libstdc++",
+        "compiler.libcxx=libstdc++",
         "-s",
         "arch=x86_64",
         "-s",
         "stdver=c++17",
+        "-s",
+        "flagcollection=",
     ]
 
     assert conan_cmd == expected_cmd