refactorings and fix libpaths maybe

Author: partouf

bin/lib/cmake_cache_extractor.py

@@ -3,8 +3,12 @@
 from pathlib import Path
 from typing import Dict, Optional
 
-from lib.compiler_utils import CMakeCacheExtractor, CompilerPropertyManager, PlatformEnvironmentManager, ScriptExecutor
+from lib.cmake_cache_extractor import CMakeCacheExtractor
+from lib.compiler_info import CompilerInfo
+from lib.compiler_properties import CompilerPropertyManager
 from lib.library_platform import LibraryPlatform
+from lib.platform_environment import PlatformEnvironmentManager
+from lib.script_executor import ScriptExecutor
 
 
 class CompilerCacheExtractor:
@@ -61,8 +65,6 @@ def setup_compiler_environment(self, compiler_id: str, compiler_props: dict) ->
         compiler_info = self.property_manager.get_compiler_info("c++", compiler_id)
         if not compiler_info:
             # Fallback to creating CompilerInfo from props if not found in manager
-            from lib.compiler_utils import CompilerInfo
-
             compiler_info = CompilerInfo(compiler_id, compiler_props)
 
         # Use the shared environment manager with default toolchain and arch
@@ -87,8 +89,6 @@ def extract_cache_for_compiler(
         compiler_info = self.property_manager.get_compiler_info("c++", compiler_id)
         if not compiler_info:
             # Fallback to creating CompilerInfo from props if not found in manager
-            from lib.compiler_utils import CompilerInfo
-
             compiler_info = CompilerInfo(compiler_id, compiler_props)
 
         # Create compiler-specific output directory
@@ -114,6 +114,7 @@ def extract_cache_for_compiler(
             keep_temp_dir=False,
             compiler_id=compiler_id,
             upload_to_s3=upload_to_s3,
+            compiler_info=compiler_info,
         )
 
         if success:

bin/lib/compiler_cache.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+
+
+class CompilerInfo:
+    """Typed wrapper around compiler properties with convenience methods."""
+
+    def __init__(self, compiler_id: str, props: dict):
+        self.id = compiler_id
+        self._props = props
+
+    @property
+    def executable(self) -> str:
+        return self._props.get("exe", "")
+
+    @property
+    def compiler_type(self) -> str:
+        return self._props.get("compilerType", "")
+
+    @property
+    def options(self) -> str:
+        return self._props.get("options", "")
+
+    @property
+    def include_path(self) -> str:
+        return self._props.get("includePath", "")
+
+    @property
+    def lib_path(self) -> str:
+        return self._props.get("libPath", "")
+
+    @property
+    def ld_path(self) -> str:
+        return self._props.get("ldPath", "")
+
+    @property
+    def is_msvc(self) -> bool:
+        return self.compiler_type == "win32-vc"
+
+    @property
+    def is_mingw_gcc(self) -> bool:
+        return self.compiler_type == "win32-mingw-gcc"
+
+    @property
+    def is_mingw_clang(self) -> bool:
+        return self.compiler_type == "win32-mingw-clang"
+
+    @property
+    def is_windows_compiler(self) -> bool:
+        return self.is_msvc or self.is_mingw_gcc or self.is_mingw_clang
+
+    @property
+    def is_clang(self) -> bool:
+        return self.compiler_type == "clang"
+
+    @property
+    def is_gcc_like(self) -> bool:
+        return self.compiler_type in ["", "gcc"]
+
+    @property
+    def exists(self) -> bool:
+        """Check if the compiler executable exists on the filesystem."""
+        return bool(self.executable and Path(self.executable).exists())
+
+    def get_c_compiler(self) -> str:
+        """
+        Derive C compiler path from C++ compiler path.
+        This logic is extracted from library_builder.py writebuildscript()
+        """
+        exe = self.executable
+
+        # Special case for EDG compilers
+        if self.compiler_type == "edg":
+            return exe
+
+        # Windows executable handling
+        if exe.endswith(".exe"):
+            compilerexecc = exe.replace("++.exe", "")
+            if exe.endswith("clang++.exe"):
+                compilerexecc = f"{compilerexecc}.exe"
+            elif exe.endswith("g++.exe"):
+                compilerexecc = f"{compilerexecc}cc.exe"
+            elif self.compiler_type == "edg":
+                compilerexecc = exe
+            else:
+                if not compilerexecc.endswith(".exe"):
+                    compilerexecc = compilerexecc + ".exe"
+            return compilerexecc
+
+        # Linux/Unix executable handling
+        else:
+            compilerexecc = exe[:-2]  # Remove last 2 chars (++)
+            if exe.endswith("clang++"):
+                compilerexecc = f"{compilerexecc}"  # clang++ -> clang
+            elif exe.endswith("g++"):
+                compilerexecc = f"{compilerexecc}cc"  # g++ -> gcc
+            elif self.compiler_type == "edg":
+                compilerexecc = exe
+            return compilerexecc

bin/lib/compiler_info.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+from typing import Dict, Optional, Tuple
+
+from lib.amazon_properties import get_properties_compilers_and_libraries
+from lib.compiler_info import CompilerInfo
+from lib.library_platform import LibraryPlatform
+
+
+class CompilerPropertyManager:
+    """Manages loading and caching of compiler properties."""
+
+    def __init__(self, logger, platform: LibraryPlatform):
+        self.logger = logger
+        self.platform = platform
+        self._props_cache: Dict[str, Tuple[Dict[str, dict], Dict[str, dict]]] = {}
+
+    def get_compiler_properties(
+        self, language: str, force_reload: bool = False
+    ) -> Tuple[Dict[str, dict], Dict[str, dict]]:
+        """Load and cache compiler properties for a language."""
+        cache_key = f"{language}_{self.platform.value}"
+
+        if not force_reload and cache_key in self._props_cache:
+            return self._props_cache[cache_key]
+
+        result = get_properties_compilers_and_libraries(language, self.logger, self.platform, True)
+        self._props_cache[cache_key] = result
+
+        self.logger.info(f"Loaded {len(result[0])} total compilers for {self.platform.value}")
+        return result
+
+    def get_compiler_info(self, language: str, compiler_id: str) -> Optional[CompilerInfo]:
+        """Get a CompilerInfo object for a specific compiler."""
+        compilers, _ = self.get_compiler_properties(language)
+
+        if compiler_id not in compilers:
+            return None
+
+        return CompilerInfo(compiler_id, compilers[compiler_id])
+
+    def get_supported_compilers(self, language: str, platform_filter: bool = True) -> Dict[str, CompilerInfo]:
+        """Get all supported compilers for a language, optionally filtered by platform compatibility."""
+        compilers, _ = self.get_compiler_properties(language)
+        supported = {}
+
+        for compiler_id, props in compilers.items():
+            compiler_info = CompilerInfo(compiler_id, props)
+
+            # Check if compiler exists
+            if not compiler_info.exists:
+                self.logger.debug(f"Skipping {compiler_id}: executable {compiler_info.executable} not found")
+                continue
+
+            # Platform-specific filtering
+            if platform_filter:
+                if self.platform == LibraryPlatform.Windows:
+                    # For Windows, support MSVC, MinGW GCC, and MinGW Clang compilers
+                    if not compiler_info.is_windows_compiler:
+                        continue
+                else:
+                    # For Linux, support GCC, Clang, and other Unix compilers (exclude Windows compilers)
+                    if compiler_info.is_windows_compiler:
+                        continue
+
+            supported[compiler_id] = compiler_info
+
+        self.logger.info(f"Found {len(supported)} supported compilers on {self.platform.value}")
+        return supported