[rustjava-adopt-link-stringconcatfactory-p2-fix] fix(jvm-bytecode): 포획 «순서»를 값으로 잠그고 적재 시점 호스트 abort 를 없앤다

게이트② 반려 2건(F1·F2)을 받는다. 둘 다 검수자 실측이 옳았다.

F1 — 포획 순서가 전 스위트에 무관측이었다. 픽스처 전건이 포획 1개 이하라
`LambdaBody::call` 의 읽기 순서를 뒤집어도 576 green 이었다(검수자 RM4). 조용히 틀린 답이다.
⇒ LambdaKinds 에 포획 2개 람다 «둘»을 넣었다: (String,int) 는 a:7 로 순서가 «글자»에 보이고,
(int,int) 는 120 으로 «값»에만 보인다 — 후자는 어떤 타입 검사로도 못 잡는 축이다.
개악 대조: RM4 → a:7→7:a · 120→2001 로 red.

F2 — 적재 시점 «호스트 프로세스 abort»(jvm/src/type.rs:74 "Invalid type"). 게스트 예외가 아니다.
★고친 자리를 «골랐고 왜인지 적는다»: 검수자 제안(lambda.rs 2줄)만 하면 진단이
UnsupportedOperationException 이 되는데, ★OpenJDK 26 은 같은 파일을 ClassFormatError 로 거부한다
(Method "run" ... has illegal signature "I"). 즉 그 파일은 «미지원»이 아니라 «파손»이다.
근인은 JVMS 4.4.10 의 규칙이 «사용 지점»에 있다는 것이다 — NameAndType 자체는 필드/메서드
서술자 «둘 다» 적법해야 하고(Fieldref·Methodref 가 같은 항목을 쓴다), 어느 쪽인지는 그것을
«참조하는 태그»가 정한다. ⇒ validation.rs 의 일반 NameAndType 팔은 그대로 두고,
InvokeDynamic=메서드 서술자 · Dynamic=필드 서술자를 «그 팔에서» 요구한다.
비용을 먼저 쟀다: 커밋된 클래스 175개 · indy/condy 참조 44건 중 새로 위법이 되는 것은
이 회차가 만든 픽스처 «1건»뿐이다.
lambda.rs 의 try_parse 도 함께 넣었다 — 검증이 이미 막지만, 틀렸을 때의 대가가 게스트 예외가
아니라 «프로세스 죽음»이라 두 겹으로 둔다(verifier.rs 가 ldc 에 대해 쓴 그 문장).

덤으로 origin/main 의 선행 입구(string concat 의 extract_invoke_params 경로)도 같은 규칙에
막힌다 — 검수자가 「별 티켓 권장」이라 한 자리다. 넓힌 것이 아니라 규칙을 옳은 자리에 둔 결과다.

Author: jun0

classfile/src/validation.rs

@@ -231,9 +231,29 @@ fn validate_constant_pool(constant_pool: &BTreeMap<u16, ConstantPoolItem>) -> bo
         // The bootstrap method index is bounded by `bootstrap_method_indices_resolve`, not here:
         // it needs the class attributes, and this function only gets the pool. What is left for
         // this arm is the half that the pool alone can answer.
-        ConstantPoolItem::Dynamic { name_and_type_index, .. } | ConstantPoolItem::InvokeDynamic { name_and_type_index, .. } => {
-            constant_pool.get(name_and_type_index).and_then(ConstantPoolItem::name_and_type).is_some()
-        }
+        //
+        // JVMS 4.4.10 makes the *kind* of descriptor part of that half, and it differs by tag: a
+        // `CONSTANT_InvokeDynamic` names a method, a `CONSTANT_Dynamic` names a field type. The
+        // `NameAndType` arm above cannot say this — one entry is shared by Fieldref and Methodref,
+        // so "a field *or* method descriptor" is the strongest rule available *there*. The usage
+        // site is where the choice is decided, which is why the check lives here and why the arm
+        // above stays as it is.
+        //
+        // Measured before tightening: of 175 committed class files and 44 invokedynamic/dynamic
+        // references, exactly one is rejected by this — `MetafactoryFieldDescriptorCallSite`, the
+        // fixture written for it. OpenJDK 26 refuses that same file
+        // (`ClassFormatError: Method "run" ... has illegal signature "I"`), so this moves us onto
+        // the real JVM's answer rather than away from it.
+        ConstantPoolItem::InvokeDynamic { name_and_type_index, .. } => constant_pool
+            .get(name_and_type_index)
+            .and_then(ConstantPoolItem::name_and_type)
+            .and_then(|(_, descriptor_index)| constant_pool.get(&descriptor_index).and_then(ConstantPoolItem::utf8))
+            .is_some_and(|descriptor| is_method_descriptor(&descriptor)),
+        ConstantPoolItem::Dynamic { name_and_type_index, .. } => constant_pool
+            .get(name_and_type_index)
+            .and_then(ConstantPoolItem::name_and_type)
+            .and_then(|(_, descriptor_index)| constant_pool.get(&descriptor_index).and_then(ConstantPoolItem::utf8))
+            .is_some_and(|descriptor| is_field_descriptor(&descriptor)),
         _ => true,
     })
 }

jvm-bytecode/src/lambda.rs

@@ -103,10 +103,22 @@ pub(crate) fn lower(class: &mut ClassInfo) {
                 };
                 // The call site's return type is the interface being implemented. Anything else
                 // is not a `metafactory` call site whatever its bootstrap says.
-                let call_site_type = JavaType::parse(descriptor);
-                let (captures, JavaType::Class(interface)) = call_site_type.as_method() else {
+                //
+                // Parsed with `try_parse`, not `parse`, and that is not a style choice: a call
+                // site's descriptor is a string out of the class file. `validation.rs` now requires
+                // it to be a method descriptor at this usage site (JVMS 4.4.10), so a bad one is
+                // refused before reaching here — but this stays `try_parse` anyway, because the
+                // cost of being wrong is not a guest exception, it is a host abort:
+                // `JavaType::parse` panics with "Invalid type". `verifier.rs` writes the same
+                // sentence about `ldc` — "reaching it would abort the host, not the guest". Two
+                // checks for one rule is cheap; one missing check is a crashed process.
+                let Some(JavaType::Method(captures, returns)) = JavaType::try_parse(descriptor) else {
                     continue;
                 };
+                let JavaType::Class(interface) = &*returns else {
+                    continue;
+                };
+                let captures = &captures[..];
                 if !adapts(captures, &linked.sam_descriptor, &linked.implementation) {
                     continue;
                 }