Fix segfault on invalid SMARTS and add RDKIT_PREFIX env var support

- Add null pointer check in RWMol::from_smarts() to prevent segfault on
  invalid SMARTS input (addresses #18, supersedes #19). Introduces
  RWMolError type mirroring the existing ROMolError pattern.
- Support RDKIT_PREFIX env var to allow specifying a custom RDKit install
  prefix, overriding all other detection logic (supersedes #45). Includes
  cargo:rerun-if-env-changed and empty string handling.

https://claude.ai/code/session_01QNQtwSN1RrM5XCnXZoA6pb

Author: claude

rdkit-sys/build.rs

@@ -8,12 +8,27 @@ fn main() {
     env_logger::init();
 
     let use_conda = std::env::var("CARGO_FEATURE_DYNAMIC_LINKING_FROM_CONDA").is_ok();
+    let explicit_prefix = std::env::var("RDKIT_PREFIX")
+        .ok()
+        .filter(|s| !s.is_empty());
+
+    println!("cargo:rerun-if-env-changed=RDKIT_PREFIX");
 
     let mut lib_paths = vec![];
     let mut include_paths = vec![];
 
-    match (std::env::consts::OS, std::env::consts::ARCH, use_conda) {
-        (_, _, true) => {
+    match (
+        std::env::consts::OS,
+        std::env::consts::ARCH,
+        &explicit_prefix,
+        use_conda,
+    ) {
+        (_, _, Some(prefix), _) => {
+            include_paths.push(format!("{prefix}/include"));
+            include_paths.push(format!("{prefix}/include/rdkit"));
+            lib_paths.push(format!("{prefix}/lib"));
+        }
+        (_, _, _, true) => {
             // prefer the prefix env var, if not, fall back to the base from the CLI
             match std::env::var("CONDA_PREFIX") {
                 Ok(prefix) => {
@@ -38,24 +53,24 @@ fn main() {
                 }
             }
         }
-        ("macos", "x86_64", _) => {
+        ("macos", "x86_64", _, _) => {
             include_paths.push("/usr/local/include".to_string());
             include_paths.push("/usr/local/include/rdkit".to_string());
         }
-        ("macos", "aarch64", _) => {
+        ("macos", "aarch64", _, _) => {
             include_paths.push("/opt/homebrew/include".to_string());
             include_paths.push("/opt/homebrew/include/rdkit".to_string());
             lib_paths.push("/opt/homebrew/lib".to_string())
         }
-        ("linux", _, _) => {
+        ("linux", _, _, _) => {
             include_paths.push("/usr/local/include".to_string());
             include_paths.push("/usr/local/include/rdkit".to_string());
             include_paths.push("/usr/include".to_string());
             include_paths.push("/usr/include/rdkit".to_string());
         }
-        (unsupported_os, unsupported_arch, use_conda) => panic!(
-            "sorry, rdkit-sys doesn't support {}/{}/use_conda={} at this time",
-            unsupported_os, unsupported_arch, use_conda
+        (unsupported_os, unsupported_arch, explicit_prefix, use_conda) => panic!(
+            "sorry, rdkit-sys doesn't support {}/{}/prefix={:?}/use_conda={} at this time",
+            unsupported_os, unsupported_arch, explicit_prefix, use_conda
         ),
     };
 

src/graphmol/rw_mol.rs

@@ -5,6 +5,14 @@ use rdkit_sys::*;
 
 use crate::ROMol;
 
+#[derive(Debug, PartialEq, thiserror::Error)]
+pub enum RWMolError {
+    #[error("could not convert smarts to rwmol (nullptr)")]
+    UnknownConversionError,
+    #[error("could not convert smarts to rwmol (exception)")]
+    ConversionException(String),
+}
+
 pub struct RWMol {
     pub(crate) ptr: SharedPtr<rdkit_sys::rw_mol_ffi::RWMol>,
 }
@@ -48,11 +56,19 @@ impl RWMol {
         ROMol { ptr }
     }
 
-    pub fn from_smarts(smarts: &str) -> Result<Self, Box<dyn std::error::Error>> {
+    pub fn from_smarts(smarts: &str) -> Result<Self, RWMolError> {
         let_cxx_string!(smarts = smarts);
 
-        let ptr = rdkit_sys::rw_mol_ffi::smarts_to_mol(&smarts)?;
-        Ok(RWMol { ptr })
+        match rw_mol_ffi::smarts_to_mol(&smarts) {
+            Ok(ptr) => {
+                if ptr.is_null() {
+                    Err(RWMolError::UnknownConversionError)
+                } else {
+                    Ok(RWMol { ptr })
+                }
+            }
+            Err(e) => Err(RWMolError::ConversionException(e.to_string())),
+        }
     }
 }
 

tests/test_graphmol.rs

@@ -1,7 +1,7 @@
 use rdkit::{
     detect_chemistry_problems, fragment_parent, substruct_match, CleanupParameters,
-    MolSanitizeException, ROMol, ROMolError, RWMol, SmilesParserParams, SubstructMatchParameters,
-    TautomerEnumerator, Uncharger,
+    MolSanitizeException, ROMol, ROMolError, RWMol, RWMolError, SmilesParserParams,
+    SubstructMatchParameters, TautomerEnumerator, Uncharger,
 };
 
 #[test]
@@ -308,6 +308,13 @@ fn test_building_rwmol_from_smarts() {
     assert_eq!(result.len(), 1);
 }
 
+#[test]
+fn test_building_rwmol_from_invalid_smarts() {
+    let smarts = "invalid_smarts";
+    let rwmol = RWMol::from_smarts(smarts);
+    assert_eq!(rwmol.err(), Some(RWMolError::UnknownConversionError));
+}
+
 #[test]
 fn test_build_romol_from_really_bad_smiles() {
     let smiles = "smiles";