make get_program_options no-fail

an error here means the program options are not well-formed,
but that's generally not recoverable and represents a logic error
that should be caught be `conf(test)` on the main structure

Author: cbeck88

conf_derive/src/proc_macro_options/field_item/flatten_item.rs

@@ -323,11 +323,14 @@ impl FlattenItem {
               // Check for positional args in flatten optional
               for opt in __inner_options__ {
                   if opt.is_positional {
-                      return Err(::conf::Error::positional_in_flatten_optional(
-                          #field_name,
-                          <#inner_type as ::conf::Conf>::get_name(),
-                          &opt.id
-                      ));
+                      panic!(
+                          "{}",
+                          ::conf::Error::positional_in_flatten_optional(
+                              #field_name,
+                              <#inner_type as ::conf::Conf>::get_name(),
+                              &opt.id
+                          )
+                      );
                   }
               }
             }
@@ -337,7 +340,7 @@ impl FlattenItem {
 
         let push_expr = quote! {
           let mut #was_skipped_ident = [false; #skip_short_len];
-          let __inner_options__ = <#inner_type as ::conf::Conf>::get_program_options()?;
+          let __inner_options__ = <#inner_type as ::conf::Conf>::get_program_options();
           #positional_check
           #program_options_ident.extend(
             __inner_options__.iter().cloned().map(
@@ -354,7 +357,8 @@ impl FlattenItem {
                 .filter_map(
                   |(short_form, was_skipped)| if was_skipped { None } else { Some(short_form) }
                 ).collect();
-            return Err(
+            panic!(
+              "{}",
               ::conf::Error::skip_short_not_found(
                 not_skipped,
                 #field_name,

conf_derive/src/proc_macro_options/mod.rs

@@ -119,24 +119,19 @@ impl GenConfStruct {
             .struct_item
             .gen_post_process_program_options(&program_options_ident)?;
 
-        // Note: fields_push_program_options is allowed to early return with ? on an error
         Ok(quote! {
-            fn get_program_options() -> Result<&'static [::conf::ProgramOption], ::conf::Error> {
+            fn get_program_options() -> &'static [::conf::ProgramOption] {
                 static CACHED: ::std::sync::OnceLock<Vec<::conf::ProgramOption>> = ::std::sync::OnceLock::new();
 
-                if CACHED.get().is_none() {
+                CACHED.get_or_init(|| {
                     let mut #program_options_ident = vec![];
 
                     #(#fields_push_program_options)*
 
                     #struct_post_process_program_options
 
-                    let _ = CACHED.set(#program_options_ident);
-                }
-
-                let cached = CACHED.get().unwrap();
-
-                Ok(cached.as_ref())
+                    #program_options_ident
+                }).as_ref()
             }
         })
     }

src/traits.rs

@@ -90,7 +90,7 @@ pub trait Conf: Sized {
     #[doc(hidden)]
     fn get_parser(parsed_env: &ParsedEnv) -> Result<Parser<'_>, Error> {
         let parser_config = Self::get_parser_config()?;
-        let program_options = Self::get_program_options()?;
+        let program_options = Self::get_program_options();
         let subcommands = Self::get_subcommands(parsed_env)?;
         Parser::new(parser_config, program_options, subcommands, parsed_env)
     }
@@ -108,7 +108,7 @@ pub trait Conf: Sized {
     // Users shouldn't generally call this, because the returned data is implementation details,
     // and may change without a semver breaking change to the crate version.
     #[doc(hidden)]
-    fn get_program_options() -> Result<&'static [ProgramOption], Error>;
+    fn get_program_options() -> &'static [ProgramOption];
     // Get the subcommands that are declared on this Conf.
     //
     // These come from `conf(subcommand)` being used on a field, and `derive(Subcommand)` being used
@@ -135,16 +135,7 @@ pub trait Conf: Sized {
     fn any_program_options_appeared<'a>(
         conf_context: &ConfContext<'a>,
     ) -> Result<Option<(&'a str, ConfValueSource<&'a str>)>, InnerError> {
-        // This unwrap is unfortunate but this code is only called when an earlier call to
-        // Self::get_program_options has succeeded, since we have to call that to
-        // instantiate the parser, and we have to do that before getting a ConfContext.
-        // The only place in the library where a `ConfContext` is created where one doesn't already
-        // exist is in `try_parse_from`, and the ConfContext::new function is pub(crate).
-        // And we have to call get_program_options before that point, which calls it
-        // recursively on all the constituent structures.
-        // So I don't think this unwrap will panic unless get_program_options is implemented in a
-        // non-deterministic way, which it shouldn't be.
-        let program_options = Self::get_program_options().unwrap();
+        let program_options = Self::get_program_options();
         for opt in program_options {
             if let Some(value_source) = conf_context.option_appears(&opt.id)? {
                 return Ok(Some((&opt.id, value_source)));

tests/test_env_aliases.rs

@@ -14,7 +14,7 @@ struct TestEnvAliases {
 
 #[test]
 fn test_env_aliases_get_program_options() {
-    let opts = TestEnvAliases::get_program_options().unwrap();
+    let opts = TestEnvAliases::get_program_options();
 
     let mut iter = opts.iter();
     let opt = iter.next().unwrap();
@@ -96,7 +96,7 @@ struct TestEnvAliases2 {
 
 #[test]
 fn test_env_aliases2_get_program_options() {
-    let opts = TestEnvAliases2::get_program_options().unwrap();
+    let opts = TestEnvAliases2::get_program_options();
 
     let mut iter = opts.iter();
     let opt = iter.next().unwrap();

tests/test_env_only_param.rs

@@ -19,7 +19,7 @@ struct TestEnvOnly {
 #[test]
 fn test_env_only_get_program_options() {
     let parser_config = TestEnvOnly::get_parser_config().unwrap();
-    let opts = TestEnvOnly::get_program_options().unwrap();
+    let opts = TestEnvOnly::get_program_options();
 
     assert!(!parser_config.no_help_flag);
 

tests/test_flags.rs

@@ -17,7 +17,7 @@ struct TestFlags {
 #[test]
 fn test_flags_get_program_options() {
     let parser_config = TestFlags::get_parser_config().unwrap();
-    let opts = TestFlags::get_program_options().unwrap();
+    let opts = TestFlags::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());

tests/test_flatten.rs

@@ -30,7 +30,7 @@ struct TestClientConfig {
 #[test]
 fn test_client_config_program_options() {
     let parser_config = TestClientConfig::get_parser_config().unwrap();
-    let opts = TestClientConfig::get_program_options().unwrap();
+    let opts = TestClientConfig::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());
@@ -135,7 +135,7 @@ struct TestDbToolConfig {
 #[test]
 fn test_db_tool_config_program_options() {
     let parser_config = TestDbToolConfig::get_parser_config().unwrap();
-    let opts = TestDbToolConfig::get_program_options().unwrap();
+    let opts = TestDbToolConfig::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());
@@ -265,7 +265,7 @@ struct TestServiceConfig {
 #[test]
 fn test_service_config_program_options() {
     let parser_config = TestServiceConfig::get_parser_config().unwrap();
-    let opts = TestServiceConfig::get_program_options().unwrap();
+    let opts = TestServiceConfig::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());
@@ -512,7 +512,7 @@ struct FrobConfig {
 #[test]
 fn frob_config_program_options() {
     let parser_config = FrobConfig::get_parser_config().unwrap();
-    let opts = FrobConfig::get_program_options().unwrap();
+    let opts = FrobConfig::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());
@@ -845,7 +845,7 @@ struct FrobConfig2 {
 #[test]
 fn frob_config2_program_options() {
     let parser_config = FrobConfig2::get_parser_config().unwrap();
-    let opts = FrobConfig2::get_program_options().unwrap();
+    let opts = FrobConfig2::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());

tests/test_flatten_optional.rs

@@ -28,7 +28,7 @@ struct TestFlattenOptional {
 
 #[test]
 fn test_flatten_optional_get_program_options() {
-    let opts = TestFlattenOptional::get_program_options().unwrap();
+    let opts = TestFlattenOptional::get_program_options();
 
     let mut iter = opts.iter();
 

tests/test_help.rs

@@ -23,7 +23,7 @@ struct SubsystemOptions {
 #[test]
 fn test_subsystem_options_help() {
     let parser_config = SubsystemOptions::get_parser_config().unwrap();
-    let opts = SubsystemOptions::get_program_options().unwrap();
+    let opts = SubsystemOptions::get_program_options();
 
     let env = Default::default();
     let parser = Parser::new(parser_config, opts, &[], &env).unwrap();
@@ -66,7 +66,7 @@ struct OtherSubsystemOptions {
 #[test]
 fn test_other_subsystem_options_help() {
     let parser_config = OtherSubsystemOptions::get_parser_config().unwrap();
-    let opts = OtherSubsystemOptions::get_program_options().unwrap();
+    let opts = OtherSubsystemOptions::get_program_options();
 
     let env = Default::default();
     let parser = Parser::new(parser_config, opts, &[], &env).unwrap();
@@ -128,7 +128,7 @@ struct SystemOptions {
 #[test]
 fn test_system_options_help() {
     let parser_config = SystemOptions::get_parser_config().unwrap();
-    let opts = SystemOptions::get_program_options().unwrap();
+    let opts = SystemOptions::get_program_options();
 
     let env = Default::default();
     let parser = Parser::new(parser_config, opts, &[], &env).unwrap();

tests/test_params.rs

@@ -25,7 +25,7 @@ struct TestParams {
 #[test]
 fn test_params_get_program_options() {
     let parser_config = TestParams::get_parser_config().unwrap();
-    let opts = TestParams::get_program_options().unwrap();
+    let opts = TestParams::get_program_options();
 
     assert!(!parser_config.no_help_flag);
     assert!(parser_config.about.is_none());