Complete undefined mode wiring

Status	File	+	-
M	`src/args.rs`	16	13
M	`src/diag.rs`	6	0
M	`src/lib.rs`	11	2
M	`src/main.rs`	1	1
M	`src/resolve.rs`	45	16
M	`tests/cli_diagnostics.rs`	124	0

src/args.rsmodified

                      .ok_or_else(|| ArgsError::MissingValue("-undefined".into()))?;
                  opts.undefined_treatment = match value.as_str() {
                      "error" => UndefinedTreatment::Error,
++                    "warning" => UndefinedTreatment::Warning,
++                    "suppress" => UndefinedTreatment::Suppress,
                      "dynamic_lookup" => UndefinedTreatment::DynamicLookup,
--                    "warning" | "suppress" => {
--                        return Err(ArgsError::InvalidValue {
--                            flag: "-undefined".into(),
--                            value: value.clone(),
--                            expected:
--                                "`error` or `dynamic_lookup` (warning/suppress not yet supported)"
--                                    .into(),
--                        });
--                    }
                      _ => {
                          return Err(ArgsError::InvalidValue {
                              flag: "-undefined".into(),
                              value: value.clone(),
--                            expected: "`error` or `dynamic_lookup`".into(),
++                            expected: "`error`, `warning`, `suppress`, or `dynamic_lookup`"
++                                .into(),
                          });
+                     }
                  };
+     }
      #[test]
--    fn undefined_flag_rejects_unsupported_modes() {
++    fn undefined_flag_records_warning_and_suppress() {
--        let err = parse(&argv(&["-undefined", "warning", "main.o"])).unwrap_err();
++        let warning = parse(&argv(&["-undefined", "warning", "main.o"])).unwrap();
++        assert_eq!(warning.undefined_treatment, UndefinedTreatment::Warning);
++
++        let suppress = parse(&argv(&["-undefined", "suppress", "main.o"])).unwrap();
++        assert_eq!(suppress.undefined_treatment, UndefinedTreatment::Suppress);
++    }
++
++    #[test]
++    fn undefined_flag_rejects_unknown_modes() {
++        let err = parse(&argv(&["-undefined", "bogus", "main.o"])).unwrap_err();
          assert!(matches!(
              err,
              ArgsError::InvalidValue {
                  ref flag,
                  ref value,
                  ..
--            } if flag == "-undefined" && value == "warning"
++            } if flag == "-undefined" && value == "bogus"
          ));
+     }

src/diag.rsmodified

      let mut h = stderr.lock();
      let _ = writeln!(h, "afs-ld: warning: {msg}");
+ }
++
++pub fn warning_verbatim(msg: &str) {
++    let stderr = std::io::stderr();
++    let mut h = stderr.lock();
++    let _ = writeln!(h, "{msg}");
++}

src/lib.rsmodified

  use reloc::arm64::RelocError;
  use resolve::{
      classify_unresolved, drain_fetches, find_archive_by_path, force_load_all, force_load_archive,
--    format_duplicate_diagnostic, format_undefined_diagnostic, seed_all, DrainReport, DylibLoadMeta,
++    format_duplicate_diagnostic, format_undefined_diagnostic,
--    InputAddError, Inputs, Symbol, SymbolTable, UndefinedTreatment,
++    format_undefined_warning_diagnostic, seed_all, DrainReport, DylibLoadMeta, InputAddError,
++    Inputs, Symbol, SymbolTable, UndefinedTreatment,
  };
  const DEFAULT_TBD_VERSION: u32 = 1 << 16;
                  &unresolved.errors,
              )));
+         }
++        if !unresolved.warnings.is_empty() {
++            crate::diag::warning_verbatim(&format_undefined_warning_diagnostic(
++                &sym_table,
++                &inputs,
++                &referrers,
++                &unresolved.warnings,
++            ));
++        }
          let mut atom_table = AtomTable::new();
          let mut objects = Vec::new();

src/main.rsmodified


                                   Set LC_BUILD_VERSION payload
   -r                              Relocatable output (deferred; errors)
   -bundle                         Bundle output (deferred; errors)
+  -undefined <error|warning|suppress|dynamic_lookup>
                                   Control unresolved-symbol treatment
   -rpath <path>                   Add LC_RPATH
   -install_name <path>            Override dylib install name

src/resolve.rsmodified

  pub struct ClassificationReport {
      /// Strong undefineds that triggered errors under `Error` treatment.
      pub errors: Vec<Unresolved>,
--    /// Strong undefineds that produced warnings under `Warning` treatment.
++    /// Strong undefineds that produced warnings under `Warning` treatment and
++    /// were promoted to flat-lookup imports for final emission.
      pub warnings: Vec<Unresolved>,
--    /// Strong undefineds that were silently accepted under `Suppress`.
++    /// Strong undefineds that were silently accepted under `Suppress` and
++    /// were promoted to flat-lookup imports for final emission.
      pub suppressed: Vec<Unresolved>,
      /// Undefineds promoted to flat-lookup DylibImport entries.
      pub promoted_to_dynamic: Vec<SymbolId>,
  /// Format the full undefined-symbol diagnostic block, one entry per
  /// unresolved name: the error line, every referrer, and an optional
  /// did-you-mean hint.
--pub fn format_undefined_diagnostic(
++fn format_undefined_diagnostic_with_level(
      table: &SymbolTable,
      inputs: &Inputs,
      referrers: &ReferrerLog,
      unresolved: &[Unresolved],
++    level: &str,
  ) -> String {
      let mut out = String::new();
      for u in unresolved {
          let name = table.interner.resolve(u.name);
--        out.push_str(&format!("afs-ld: error: undefined symbol: {name}\n"));
++        out.push_str(&format!("afs-ld: {level}: undefined symbol: {name}\n"));
          for origin in referrers.get(u.name) {
              if let Some(oi) = inputs.objects.get(origin.0 as usize) {
                  out.push_str(&format!("      referenced by {}\n", oi.path.display()));
      out
+ }
++pub fn format_undefined_diagnostic(
++    table: &SymbolTable,
++    inputs: &Inputs,
++    referrers: &ReferrerLog,
++    unresolved: &[Unresolved],
++) -> String {
++    format_undefined_diagnostic_with_level(table, inputs, referrers, unresolved, "error")
++}
++
++pub fn format_undefined_warning_diagnostic(
++    table: &SymbolTable,
++    inputs: &Inputs,
++    referrers: &ReferrerLog,
++    unresolved: &[Unresolved],
++) -> String {
++    format_undefined_diagnostic_with_level(table, inputs, referrers, unresolved, "warning")
++}
++
  /// Format a `DuplicateStrong` insertion error for user consumption. Needs
  /// the incumbent symbol (from the table) plus the losing second symbol
  /// carried in the error itself.
  ) -> ClassificationReport {
      let mut report = ClassificationReport::default();
++    fn promote_to_flat_lookup(table: &mut SymbolTable, id: SymbolId, name: Istr) {
++        table.symbols[id.0 as usize] = Symbol::DylibImport {
++            name,
++            dylib: DylibId::INVALID,
++            ordinal: FLAT_LOOKUP_ORDINAL,
++            weak_import: true,
++        };
++        table.transitions.push(Transition {
++            id,
++            from: SymbolKindTag::Undefined,
++            to: SymbolKindTag::DylibImport,
++            cause: TransitionCause::Replaced,
++        });
++    }
++
      // Collect undefineds before mutating — avoids double-borrow grief.
      let undefs: Vec<(SymbolId, Istr, bool)> = table
          .iter()
+             }
              UndefinedTreatment::Warning => {
                  report.warnings.push(Unresolved { name, id });
++                promote_to_flat_lookup(table, id, name);
++                report.promoted_to_dynamic.push(id);
+             }
              UndefinedTreatment::Suppress => {
                  report.suppressed.push(Unresolved { name, id });
++                promote_to_flat_lookup(table, id, name);
++                report.promoted_to_dynamic.push(id);
+             }
              UndefinedTreatment::DynamicLookup => {
--                table.symbols[id.0 as usize] = Symbol::DylibImport {
++                promote_to_flat_lookup(table, id, name);
--                    name,
--                    dylib: DylibId::INVALID,
--                    ordinal: FLAT_LOOKUP_ORDINAL,
--                    weak_import: true,
--                };
--                table.transitions.push(Transition {
--                    id,
--                    from: SymbolKindTag::Undefined,
--                    to: SymbolKindTag::DylibImport,
--                    cause: TransitionCause::Replaced,
--                });
                  report.promoted_to_dynamic.push(id);
+             }
+         }

tests/cli_diagnostics.rsmodified

          .unwrap_or(false)
+ }
++fn sdk_path() -> Option<String> {
++    let out = Command::new("xcrun")
++        .args(["--sdk", "macosx", "--show-sdk-path"])
++        .output()
++        .ok()?;
++    if !out.status.success() {
++        return None;
++    }
++    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
++}
++
  fn minimal_main_src() -> &'static str {
      r#"
          .section __TEXT,__text,regular,pure_instructions
      assert!(stdout.contains("-map <path>"));
      assert!(stdout.contains("-no_uuid"));
      assert!(stdout.contains("-dead_strip"));
++    assert!(stdout.contains("-undefined <error|warning|suppress|dynamic_lookup>"));
      assert!(stdout.contains("-t, -trace"));
      assert!(stdout.contains("-v, --version"));
+ }
      let _ = fs::remove_file(obj);
+ }
++#[test]
++fn undefined_warning_mode_links_and_warns_once() {
++    if !have_xcrun() {
++        eprintln!("skipping: xcrun as unavailable");
++        return;
++    }
++    let Some(sdk) = sdk_path() else {
++        eprintln!("skipping: xcrun --show-sdk-path unavailable");
++        return;
++    };
++
++    let exe = env!("CARGO_BIN_EXE_afs-ld");
++    let obj = scratch("missing-warning.o");
++    let src = r#"
++        .section __TEXT,__text,regular,pure_instructions
++        .globl _main
++        _main:
++            bl _missing
++            ret
++        .subsections_via_symbols
++    "#;
++    if let Err(e) = assemble(src, &obj) {
++        eprintln!("skipping: assemble failed: {e}");
++        return;
++    }
++
++    let out_path = scratch("missing-warning.out");
++    let out = Command::new(exe)
++        .arg("-undefined")
++        .arg("warning")
++        .arg("-syslibroot")
++        .arg(&sdk)
++        .arg("-lSystem")
++        .arg("-o")
++        .arg(&out_path)
++        .arg(&obj)
++        .output()
++        .expect("afs-ld should run");
++    assert!(
++        out.status.success(),
++        "-undefined warning should link successfully:\nstderr:\n{}",
++        String::from_utf8_lossy(&out.stderr)
++    );
++    let stderr = String::from_utf8_lossy(&out.stderr);
++    assert!(
++        stderr.contains("afs-ld: warning: undefined symbol: _missing"),
++        "missing expected undefined-symbol warning:\n{stderr}"
++    );
++    assert!(
++        !stderr.contains("afs-ld: warning: afs-ld: warning:"),
++        "warning diagnostic was double-prefixed:\n{stderr}"
++    );
++    assert!(out_path.exists(), "expected linked output to be written");
++
++    let _ = fs::remove_file(obj);
++    let _ = fs::remove_file(out_path);
++}
++
++#[test]
++fn undefined_suppress_mode_links_silently() {
++    if !have_xcrun() {
++        eprintln!("skipping: xcrun as unavailable");
++        return;
++    }
++    let Some(sdk) = sdk_path() else {
++        eprintln!("skipping: xcrun --show-sdk-path unavailable");
++        return;
++    };
++
++    let exe = env!("CARGO_BIN_EXE_afs-ld");
++    let obj = scratch("missing-suppress.o");
++    let src = r#"
++        .section __TEXT,__text,regular,pure_instructions
++        .globl _main
++        _main:
++            bl _missing
++            ret
++        .subsections_via_symbols
++    "#;
++    if let Err(e) = assemble(src, &obj) {
++        eprintln!("skipping: assemble failed: {e}");
++        return;
++    }
++
++    let out_path = scratch("missing-suppress.out");
++    let out = Command::new(exe)
++        .arg("-undefined")
++        .arg("suppress")
++        .arg("-syslibroot")
++        .arg(&sdk)
++        .arg("-lSystem")
++        .arg("-o")
++        .arg(&out_path)
++        .arg(&obj)
++        .output()
++        .expect("afs-ld should run");
++    assert!(
++        out.status.success(),
++        "-undefined suppress should link successfully:\nstderr:\n{}",
++        String::from_utf8_lossy(&out.stderr)
++    );
++    let stderr = String::from_utf8_lossy(&out.stderr);
++    assert!(
++        !stderr.contains("undefined symbol: _missing"),
++        "expected -undefined suppress to omit undefined diagnostic:\n{stderr}"
++    );
++    assert!(out_path.exists(), "expected linked output to be written");
++
++    let _ = fs::remove_file(obj);
++    let _ = fs::remove_file(out_path);
++}
++
  #[test]
  fn trace_flag_prints_loaded_inputs_and_archive_members() {
      if !have_xcrun() {

fortrangoingonforty/afs-ld / `cab9755`

6 changed files

`@@ -19,7 +19,7 @@` Options:
19	Set LC_BUILD_VERSION payload	19	Set LC_BUILD_VERSION payload
20	-r Relocatable output (deferred; errors)	20	-r Relocatable output (deferred; errors)
21	-bundle Bundle output (deferred; errors)	21	-bundle Bundle output (deferred; errors)
22	- -undefined <error\|dynamic_lookup>	22	+ -undefined <error\|warning\|suppress\|dynamic_lookup>
23	Control unresolved-symbol treatment	23	Control unresolved-symbol treatment
24	-rpath <path> Add LC_RPATH	24	-rpath <path> Add LC_RPATH
25	-install_name <path> Override dylib install name	25	-install_name <path> Override dylib install name