[rustjava-bootstrap-argument-diagnostic-names-index-and-tag] fix(classfile): 부트스트랩 인자 거부가 어느 인자·무엇을 찾았는지 말한다

Author: jun0

REPORT.md

@@ -1,4 +1,17 @@
 # REPORT
+## [2026-09-18] 부트스트랩 인자 거부가 «어느 인자·무엇을 찾았는지» 말한다 (rustjava-bootstrap-argument-diagnostic-names-index-and-tag)
+- 무엇을: 채택 제안 `2026-09-18-bootstrap-argument-diagnostic-sequencing#p0`(worklog json 기록). ★**새 기능이 아니라 «이미 계산된 값을 버리지 않는 것»** — 술어가 `false` 를 내는 그 자리에 index 와 찾은 항목이 **손에 있었다**.
+- ★**ⓑ 대안을 만들지 않았다** — 같은 enum 의 `UnsupportedVersion(u16)` 이 **이미 3층을 관통해 경계에서 `format!` 되는 패턴**이라 그것을 **복제**했다(새 진단 체계 **0**).
+- ★**전/후**(같은 픽스처 `test-data/ldc/LdcDynamicBSMArgPastEnd.class` · CLI 실제 출력):
+  `BEFORE  java.lang.ClassFormatError: a bootstrap method argument names nothing or is not a loadable constant`
+  `AFTER   java.lang.ClassFormatError: bootstrap method #0 argument #0 names no constant pool entry`
+- ★**세 요구 3/3**: expected(문면) · index(`argument_index` ★+`method_index` — OpenJDK 는 그걸 안 말해 여럿일 때 모호하다) · actual(가리킨 상수의 **종류 이름**). ★태그를 **번호가 아니라 이름**으로 나른다 — 태그 바이트가 파싱 후 남지 않아 번호는 «아무도 분기 안 하는 두 번째 표»를 만들게 된다.
+- ★★**양방향의 급소** — `StringConcat` 은 인자가 **1개**라 index 0 이 **계산이든 하드코딩이든 통과한다**. 그래서 정적 인자 **3개**짜리 `Lambda.class` 의 **#0 과 #2** 를 각각 망가뜨려 ★**보고된 index 가 0 ↔ 2 로 따라가는 것**을 잠갔다.
+- ★**소비자 전수**: `InvalidFormat` 34사용처 중 **구조적 소비자는 1개**(`jvm-bytecode` 의 `From` match) — **arm 을 더했을 뿐 고치지 않았다**. 나머지 14규칙 무변.
+- ★**대가**(재서 적는다): ★**타입이 «커지지 않았다»** — `Copy` 유지 · 크기 불변(시험으로 잠금) ⇒ 할당 0. ※제안이 경계한 「소유 데이터로 커진다」는 **이 설계에선 일어나지 않았다**. ★**두 경로 공존**의 혼동은 변형 docstring 한 줄로 못박았다 · ★이 규칙의 **메시지 문면이 바뀌어** 그것을 단언하던 시험 2곳과 grep 습관이 깨진다.
+- 검증: `cargo test -p classfile` **16 passed**(전 13) · `--test test_class_format` **22 passed** · `cargo test --all` rc=0.
+- ★후속 추천: ⑴**다른 14규칙 중 «수를 아는데 버리는» 것을 세라**(S — 아직 그 수를 모른다) ⑵`ClassDefinitionError` 의 `&'static str` 두 변형도 같은 한계(M · 이 회차는 나란히 더해 **우회**했다). 상세 = `docs/worklog/2026-09-18-bootstrap-argument-index-and-tag.md`.
+
 ## [2026-09-18] 「어느 bootstrap argument 가 왜 나빴나」 — ★**대전제 ⓒ 에서 끝난다: 그 일을 하는 축이 이미 떠 있다**(rustjava-adopt-loadable-bootstrap-arguments-diagnostic)
 - 무엇을: 채택 제안 `2026-09-17-loadable-bootstrap-arguments#p0` 의 처분(worklog json `adoptedProposals` 기록). ★**코드 0행** — `classfile/src/{error,validation}.rs` **무접촉**.
 - ★**제안의 전제는 참이다 — CLI 로 돌려서 봤다**(`main` @ `8c7b473f`): 서로 다른 세 규칙(`LdcDynamicBSMArgPastEnd` 나쁜 argument · `LdcDynamicDuplicateBSM` 중복 속성 · `LdcDynamicOldMajor` 버전 게이트)이 ★**글자 하나 다르지 않은 `java.lang.ClassFormatError: Invalid class file`** 를 낸다.

STATE.md

@@ -7,6 +7,14 @@
  (둘 다 이것보다 오래됐고 MERGEABLE/CONFLICTING 처분이 이미 걸려 있다). 겹침은 전부 **append 형 합집합**이라 해소는 기계적이다)
 
 ## 완료
+- [rustjava-bootstrap-argument-diagnostic-names-index-and-tag] ★★**부트스트랩 인자 거부가 «어느 인자·무엇을» 말한다.** 채택 제안 `2026-09-18-bootstrap-argument-diagnostic-sequencing#p0`.
+  ★**전제 확인(코드)**: 술어가 `false` 를 내는 자리에 `index` 와 `constant_pool.get(index)` 가 **손에 있었다** — `bool` 이 둘을 버렸다.
+  ★**새 체계 0** — 같은 enum 의 `UnsupportedVersion(u16)` 이 이미 3층을 관통하는 패턴이라 **복제**했다.
+  ★**전/후**: `ClassFormatError: a bootstrap method argument names nothing or is not a loadable constant` → ★`ClassFormatError: bootstrap method #0 argument #0 names no constant pool entry`(CLI 실측).
+  ★**세 요구 3/3**(expected·index+method_index·actual) · 태그는 **이름**으로(번호는 표가 하나 더 는다).
+  ★**양방향 급소**: `StringConcat` 은 인자 1개라 index 0 이 하드코딩이어도 통과 ⇒ **인자 3개 `Lambda.class` 의 #0↔#2** 로 **index 가 따라가는 것**을 잠갔다.
+  ★**소비자 1개**(`jvm-bytecode` `From`) — arm 추가뿐, 14규칙 무변. ★**타입 «안 커졌다»**(`Copy`·크기 불변 시험) · ★메시지 문면이 바뀌어 단언 2곳이 바뀐다.
+  ★`-p classfile` **16 passed**(전 13) · `test_class_format` **22** · `--all` rc=0.
 - [rustjava-adopt-loadable-bootstrap-arguments-diagnostic] ★★**대전제 ⓒ 에서 끝났다 — 그 일을 하는 축(PR #67)이 이미 떠 있다.** 채택 제안 `2026-09-17-loadable-bootstrap-arguments#p0`(worklog json 기록). ★**코드 0행.**
   ★**전제는 참**(CLI 실행: 세 규칙이 전부 `ClassFormatError: Invalid class file` 동일 문면) — 그러나 ★**편집 영역은 전부 겹친다**(전달된 값은 **3 중 1** — 아래): #67 이 제안 `target` 두 파일을 고치고, 이 술어에 **이미 사유를 주며**, 밋밋한 문면 **두 자리**를 둘 다 고쳤다. ★제안 `tradeoff` 자신이 「두 번 하지 말고 함께 하라」고 적었다.
   ★**남는 잔여는 좁다** — `&'static str` 이라 **인덱스를 못 담는다** ⇒ 「기대」 달성 · 「인덱스·실제」 미달 ⇒ ★**새 카드를 냈다**(★**M** — 초판 `S` 에서 **실측 후 올렸다**: 잔여도 **같은 3층**을 건너 `target` **5파일/4크레이트**(`classfile`·`jvm-bytecode`·`RustJava`·`test-utils` — ★층 3 ↔ 크레이트 4: 경계 층이 두 크레이트에 걸친다) · `InvalidFormat` 을 넓히면 생성 17 + 매치 11 이라 **새 variant** 를 고르고 **두 갈래의 대가**를 적었다).

classfile/src/error.rs

@@ -10,5 +10,26 @@
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ClassFileError {
     InvalidFormat(&'static str),
+    /// A bootstrap method argument that is not a loadable constant, carrying the two things the
+    /// predicate already knows at the moment it refuses: *which* argument, and what it found there.
+    ///
+    /// ★ Which variant to use: `InvalidFormat` is for a rule that has nothing to point at, and that
+    /// is still most of them. Use this one only when a number is already in hand — folding it into
+    /// prose is the thing this variant exists to stop. `UnsupportedVersion` is the same shape and
+    /// predates it, so this is the established way here rather than a second scheme.
+    ///
+    /// It stays `Copy`: two `u16`s and a `&'static str`, no owned data.
+    InvalidBootstrapArgument {
+        /// Position of the `BootstrapMethods` entry, zero-based, as the attribute stores them.
+        method_index: u16,
+        /// Position within that entry's argument list, zero-based. OpenJDK calls this
+        /// `argument_index` and prints it without the method, which is ambiguous when a class has
+        /// more than one bootstrap method; both are carried here for that reason.
+        argument_index: u16,
+        /// The kind of constant the argument actually names, or `None` when the index names no
+        /// pool entry at all — "names nothing" and "names the wrong kind" are different failures
+        /// and the message says which.
+        actual: Option<&'static str>,
+    },
     UnsupportedVersion(u16),
 }

classfile/src/validation.rs

@@ -38,15 +38,10 @@ pub(crate) fn validate_class(class: &ClassInfo) -> Result<(), ClassFileError> {
             "class file version does not support a constant tag it carries",
         ));
     }
-    if !bootstrap_method_static_arguments_are_in_the_pool(class) {
-        return Err(ClassFileError::InvalidFormat(
-            // The rule is wider than the function name: the docstring above says the argument must also
-            // be a loadable constant, and OpenJDK says the same ("bad constant type"). The name stayed
-            // behind when the rule widened; renaming it is not this round's scope, so the cause is what
-            // gets the wording right.
-            "a bootstrap method argument names nothing or is not a loadable constant",
-        ));
-    }
+    // The rule is wider than the function name: the docstring below says the argument must also be a
+    // loadable constant, and OpenJDK says the same ("bad constant type"). The name stayed behind when
+    // the rule widened; renaming it is not this round's scope.
+    bootstrap_method_static_arguments_are_in_the_pool(class)?;
     if !bootstrap_method_indices_resolve(class) {
         return Err(ClassFileError::InvalidFormat("a dynamic constant names no bootstrap method"));
     }
@@ -165,11 +160,18 @@ fn constant_pool_tags_fit_the_class_file_version(class: &ClassInfo) -> bool {
 /// One consequence worth naming: a long or double occupies two pool slots and only the first is
 /// usable (JVMS 4.4.5), so the second has no entry in this map and an argument naming it is
 /// rejected. That is the intended reading of "valid index" rather than an accident of the map.
-fn bootstrap_method_static_arguments_are_in_the_pool(class: &ClassInfo) -> bool {
-    class.attributes.iter().all(|attribute| match attribute {
-        AttributeInfo::BootstrapMethods(methods) => methods.iter().all(|method| {
-            method.arguments.iter().all(|index| {
-                class.constant_pool.get(index).is_some_and(|item| {
+/// ★ It returns `Result` rather than `bool` for one reason: at the moment it refuses, it is holding
+/// the position of the argument and the entry it found, and a `bool` throws both away. The caller
+/// then had to describe the failure in prose it did not measure. Nothing else about the rule moved.
+fn bootstrap_method_static_arguments_are_in_the_pool(class: &ClassInfo) -> Result<(), ClassFileError> {
+    for attribute in &class.attributes {
+        let AttributeInfo::BootstrapMethods(methods) = attribute else {
+            continue;
+        };
+        for (method_index, method) in methods.iter().enumerate() {
+            for (argument_index, index) in method.arguments.iter().enumerate() {
+                let entry = class.constant_pool.get(index);
+                let loadable = entry.is_some_and(|item| {
                     matches!(
                         item,
                         ConstantPoolItem::Integer(_)
@@ -182,11 +184,43 @@ fn bootstrap_method_static_arguments_are_in_the_pool(class: &ClassInfo) -> bool
                             | ConstantPoolItem::MethodType { .. }
                             | ConstantPoolItem::Dynamic { .. }
                     )
-                })
-            })
-        }),
-        _ => true,
-    })
+                });
+                if !loadable {
+                    return Err(ClassFileError::InvalidBootstrapArgument {
+                        method_index: method_index as u16,
+                        argument_index: argument_index as u16,
+                        actual: entry.map(constant_kind_name),
+                    });
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// The JVMS 4.4 name of a constant's kind, for saying what an argument actually named.
+///
+/// ★ A name and not the numeric tag: the tag byte is not kept after parsing, so reporting it would
+/// mean a second table to hold numbers nothing branches on. The name is what a reader of the
+/// message needs, and it is derived from the variant rather than stored, so it cannot drift.
+fn constant_kind_name(item: &ConstantPoolItem) -> &'static str {
+    match item {
+        ConstantPoolItem::Utf8(_) => "Utf8",
+        ConstantPoolItem::Integer(_) => "Integer",
+        ConstantPoolItem::Float(_) => "Float",
+        ConstantPoolItem::Long(_) => "Long",
+        ConstantPoolItem::Double(_) => "Double",
+        ConstantPoolItem::Class { .. } => "Class",
+        ConstantPoolItem::String { .. } => "String",
+        ConstantPoolItem::Fieldref { .. } => "Fieldref",
+        ConstantPoolItem::Methodref { .. } => "Methodref",
+        ConstantPoolItem::InterfaceMethodref { .. } => "InterfaceMethodref",
+        ConstantPoolItem::NameAndType { .. } => "NameAndType",
+        ConstantPoolItem::MethodHandle { .. } => "MethodHandle",
+        ConstantPoolItem::MethodType { .. } => "MethodType",
+        ConstantPoolItem::Dynamic { .. } => "Dynamic",
+        ConstantPoolItem::InvokeDynamic { .. } => "InvokeDynamic",
+    }
 }
 
 /// JVMS 4.4.10 and 4.7.23: `bootstrap_method_attr_index` is an index into the `bootstrap_methods`

classfile/tests/test.rs

@@ -367,9 +367,96 @@ fn test_a_bootstrap_argument_that_is_not_a_loadable_constant_is_rejected() {
 
     assert_eq!(
         ClassInfo::parse(&mutated).err(),
-        Some(ClassFileError::InvalidFormat(
-            "a bootstrap method argument names nothing or is not a loadable constant"
-        )),
-        "a bootstrap argument naming a Utf8 is not a loadable constant"
+        Some(ClassFileError::InvalidBootstrapArgument {
+            method_index: 0,
+            argument_index: 0,
+            actual: Some("Utf8"),
+        }),
+        "a bootstrap argument naming a Utf8 is not a loadable constant, and the refusal says which argument and what it found"
     );
 }
+
+/// ★ The index has to *follow the input*, not be a constant that happens to read correctly.
+///
+/// `StringConcat` above has a single argument, so its `argument_index` is 0 whether the code
+/// computes it or hardcodes it — that test cannot tell the two apart. A lambda's bootstrap method
+/// takes three (samMethodType, implMethod, instantiatedMethodType), so breaking a different one has
+/// to move the number. Both mutations are the same edit at a different offset, which is what makes
+/// the pair a control for each other.
+#[test]
+fn test_the_reported_bootstrap_argument_index_follows_the_broken_argument() {
+    let lambda = include_bytes!("../../test-data/indy/Lambda.class");
+    let class = ClassInfo::parse(lambda).unwrap();
+    let arguments = &bootstrap_methods(&class)[0].arguments;
+    assert_eq!(arguments.len(), 3, "a LambdaMetafactory call site carries three static arguments");
+
+    // Derived from the parse rather than hardcoded, so a regenerated fixture moves the window with it.
+    let mut window = vec![0u8, arguments.len() as u8];
+    for argument in arguments {
+        window.extend_from_slice(&argument.to_be_bytes());
+    }
+    let at = lambda
+        .windows(window.len())
+        .position(|candidate| candidate == window)
+        .expect("test-data/indy/Lambda.class layout changed; the BootstrapMethods argument list moved");
+
+    // Entry #4 is a Utf8 ("java/lang/Object"): a real pool entry that is not a loadable constant.
+    // The kind is not assumed — the assertion below reads it back, so a regenerated fixture whose
+    // #4 is something else fails here rather than passing for the wrong reason.
+    let utf8: u16 = 4;
+    assert!(class.constant_pool.get(&utf8).is_some(), "the replacement index must be in the pool");
+
+    for broken in [0usize, 2usize] {
+        let mut mutated = lambda.to_vec();
+        let offset = at + 2 + broken * 2;
+        mutated[offset..offset + 2].copy_from_slice(&utf8.to_be_bytes());
+
+        assert_eq!(
+            ClassInfo::parse(&mutated).err(),
+            Some(ClassFileError::InvalidBootstrapArgument {
+                method_index: 0,
+                argument_index: broken as u16,
+                actual: Some("Utf8"),
+            }),
+            "breaking argument #{broken} must report argument #{broken}"
+        );
+    }
+}
+
+/// The other half of the rule: an index that names no entry at all reports `actual: None`, and the
+/// message says "names no constant pool entry" rather than guessing a kind.
+#[test]
+fn test_a_bootstrap_argument_naming_nothing_reports_no_kind() {
+    let string_concat = include_bytes!("../../test-data/indy/StringConcat.class");
+    let class = ClassInfo::parse(string_concat).unwrap();
+    let window = [0u8, 1, 0, 34, 0, 1, 0, 32];
+    let at = string_concat
+        .windows(window.len())
+        .position(|candidate| candidate == window)
+        .expect("test-data/indy/StringConcat.class layout changed; the BootstrapMethods entry moved");
+
+    let past_end = u16::MAX;
+    assert!(class.constant_pool.get(&past_end).is_none(), "the index must name nothing");
+
+    let mut mutated = string_concat.to_vec();
+    mutated[at + 6..at + 8].copy_from_slice(&past_end.to_be_bytes());
+
+    assert_eq!(
+        ClassInfo::parse(&mutated).err(),
+        Some(ClassFileError::InvalidBootstrapArgument {
+            method_index: 0,
+            argument_index: 0,
+            actual: None,
+        })
+    );
+}
+
+/// The cost of the variant, measured rather than asserted in prose: it stays `Copy` and the enum
+/// does not grow, because two `u16`s and a `&'static str` fit in the space `InvalidFormat` already
+/// needed for its string.
+#[test]
+fn test_the_structured_variant_does_not_grow_the_error_type() {
+    assert_eq!(size_of::<ClassFileError>(), size_of::<&'static str>() + size_of::<usize>());
+    fn assert_copy<T: Copy>() {}
+    assert_copy::<ClassFileError>();
+}