[rustjava-adopt-ldc-tags-real-world-generator-survey-p1] test(survey): kotlinc·scalac 를 타깃 형상으로 몰아 «기능 단위» 0 을 잰다

Author: jun0

REPORT.md

@@ -1,4 +1,16 @@
 # REPORT
+## [2026-09-17] kotlinc·scalac 를 «타깃 형상»으로 몰았다 — ★**0. 그러나 «다른 0»** (rustjava-adopt-ldc-tags-real-world-generator-survey-p1)
+- 무엇을: 채택 제안 `2026-09-16-ldc-tags-real-world-generator-survey#p1`. 조사 회차가 자기 표에 **「못 쟀다」**로 적어 둔 칸을 채웠다. ★**제품 Rust 0줄**(조사 입력 2 + 스캐너 docstring).
+- 왜: 종전 축은 **컴파일러의 stdlib**(= 그 컴파일러 산출물)이었다. ★**stdlib 은 호환성을 위해 컴파일되지 백엔드를 훑으려고 컴파일되지 않는다** — 그래서 「이 코퍼스에서 0」과 「이 기능들에서 0」이 다르다.
+- ★**결과**: kotlinc **2.4.20** → 7클래스·23 ldc 자리 · ★**피연산자 15/16/17 = 0** / scalac **3.9.0** → 7·18 · ★**0**.
+  ★★**풀 수치가 이 0 을 읽을 값으로 만든다** — Kotlin `MethodHandle 7 · MethodType 6` · Scala `11 · 6` **(0 이 아니다)** ⇒ ★**indy 경로가 실제로 돌았고 상수도 만들어졌는데 `ldc` 자리에 «닿지 않는다»**. 「안 썼다」가 아니라 「썼는데 안 온다」다.
+  ★**태그 17(Dynamic)은 풀에도 0** ⇒ ★**두 컴파일러 모두 condy 를 아예 내지 않는다**(둘 중 더 센 진술).
+- ★**타깃 형상**: 람다 · 언바운드/바운드 메서드 참조 · SAM 변환(네이티브+Java 둘 다) · enum 주어 · 문자열 연결 · lazy · (Kotlin) reified · (Scala) eta 확장·inline def·구조적 타입. ★**플래그도 «더 많이» indy 로 보내는 쪽으로 골랐다**(`-Xlambdas=indy`·`-Xsam-conversions=indy`·`-Xstring-concat=indy-with-constants` · `scalac -release 21`).
+- ★**양방향**: 같은 스캐너·같은 세션에서 **양성 대조군** `test-data/ldc` → `{MethodHandle 1, MethodType 2, Dynamic 7}` ⇒ ★**이 0 은 「스캐너가 못 본다」가 아니다.** 오차 막대(불가능 피연산자) 두 실행 **0.00%**.
+- ★**제안의 값 전제를 다시 재서 «부분적으로 거짓»임을 찾았다**: 「JVM 툴체인이 의도적으로 없는 맥」이라 했으나 ★**openjdk 26 은 2026-03-11 부터 설치돼 있었다**(조사 회차보다 반년 앞선다) ⇒ 한계 설치는 **formula 하나씩**이었다.
+- ★★**대가**: **머신 상태가 바뀌었다** — `kotlin 2.4.20`·`scala 3.9.0`(+`scala-cli`) 설치. 레인 약 28개가 공유하는 맥이고, **가산적·가역**(`brew uninstall kotlin scala`)이라 **재측정 가능성을 위해 일부러 남겼다**. ★컴파일러당 프로그램 «하나»라 **기능**을 한정할 뿐 **언어**를 한정하지 않는다. ★**CI 에서 못 돈다**(`setup-java` 0건) — 사람이 돌리는 검사다.
+- ★**답은 제안이 예상한 그 0 이다** — 산 것은 **오차 막대**뿐이고, 그것이 이 회차 값의 정직한 회계다.
+
 ## [2026-09-17] base 를 당겼다 — ★**막고 있던 코드 충돌은 «이미 없었다»**(rustjava-adopt-link-stringconcatfactory-p1-fix2)
 - 무엇을: `origin/main` 당김(뒤처짐 **9**) + 그 당김이 만든 `test-data/class-file-versions.txt` **3행**. ★제품 코드 **0줄** · 픽스처 바이트 **불변**.
 - ★★**전제가 반증됐다**: 이 회차는 「`make_indy_fixtures.py` 4구역 코드 충돌」을 풀라고 발권됐는데, 지금 당기면 그 파일은 **충돌하지 않는다**. `-p1-fix` 회차가 **14:10 에 `0f06b93f` 로 이미 합집합 해소**했고 게이트②가 **15:43 에 그 head 를 approve** 했다 — 발권 근거였던 12:12 blocked 회신이 그 사이 **낡았다**.

STATE.md

@@ -7,6 +7,13 @@
  (둘 다 이것보다 오래됐고 MERGEABLE/CONFLICTING 처분이 이미 걸려 있다). 겹침은 전부 **append 형 합집합**이라 해소는 기계적이다)
 
 ## 완료
+- [rustjava-adopt-ldc-tags-real-world-generator-survey-p1] ★★**kotlinc·scalac 타깃 형상 조사 — 0. 그러나 «다른 0».** 채택 제안 `…-survey#p1`(worklog json `adoptedProposals` 기록) · ★**제품 Rust 0줄**.
+  ★조사 회차가 **「못 쟀다」로 비워 둔 칸**을 채웠다 — 종전 축은 stdlib(호환성용 컴파일)이라 「이 코퍼스에서 0」과 「이 기능들에서 0」이 달랐다.
+  ★**kotlinc 2.4.20 → 0 · scalac 3.9.0 → 0**. ★★**풀 수치가 그 0 을 읽을 값으로 만든다**(Kotlin `MH 7·MT 6` · Scala `11·6` = **indy 가 실제로 돌았다**) ⇒ 「안 썼다」가 아니라 **「썼는데 `ldc` 자리에 안 온다」**.
+  ★**태그 17 은 풀에도 0** ⇒ 두 컴파일러 다 **condy 를 아예 안 낸다**.
+  ★**양방향**: 양성 대조군 `test-data/ldc` → `{MH 1, MT 2, Dynamic 7}` ⇒ 「스캐너가 못 본다」 배제 · 오차막대 **0.00%**.
+  ★**제안의 값 전제가 부분적으로 거짓**이었다 — openjdk 26 은 **2026-03-11 부터** 설치돼 있었다(조사보다 반년 전).
+  ★★**대가**: 머신에 `kotlin`·`scala` **설치됨**(가역 · `brew uninstall kotlin scala` · 재측정 위해 남겼다) · 컴파일러당 프로그램 1개 · **CI 불가**.
 - [rustjava-adopt-link-stringconcatfactory-p1-fix2] ★★**base 당김 — 그런데 막고 있던 코드 충돌은 «이미 없었다»(PR #60).**
   ★**전제 반증**: 「`make_indy_fixtures.py` 4구역 충돌」은 `-p1-fix` 가 **14:10 `0f06b93f`** 로 합집합 해소했고 게이트②가 **15:43 그 head 를 approve** 했다.
   발권 근거(12:12 blocked 회신)가 그 사이 낡은 것이다. ★**재발 불가**도 확인 — 뒤진 9커밋 중 그 파일을 만진 것 **0건**.

docs/worklog/2026-09-17-ldc-targeted-shapes-kotlin-scala.json

@@ -0,0 +1,32 @@
+{
+ "schema": "worklog/v1",
+ "date": "2026-09-17",
+ "taskId": "rustjava-adopt-ldc-tags-real-world-generator-survey-p1",
+ "summary": "Adopted: drove kotlinc and scalac over targeted source shapes instead of only their stdlib output, closing the gap the survey named about itself. Result is the same zero the proposal expected — but it is now a zero about features rather than about one corpus, and the constant pool counts prove the invokedynamic paths were actually exercised. Tag 17 (Dynamic) is absent from the pool entirely in both compilers, which is the stronger finding: neither emits condy at all.",
+ "changes": [
+  "scripts/ldc-tag-survey-targets/Targets.kt: Kotlin shapes — lambda, unbound and bound callable references, SAM conversion to a Kotlin fun interface and to a Java interface, enum `when`, string templates, lazy delegate, reified type parameter",
+  "scripts/ldc-tag-survey-targets/Targets.scala: Scala 3 shapes — lambda, eta-expansion, SAM conversion to a Scala trait and to a Java interface, enum match, string interpolation, lazy val, inline def, structural type",
+  "scripts/survey-ldc-constant-tags.py: docstring records the commands, the compiler versions, the numbers, the positive control and what the measurement does not cover"
+ ],
+ "verification": [
+  "kotlinc-jvm 2.4.20 (JRE 26): 7 classes / 23 ldc sites / tags 15,16,17 as an ldc operand: 0; same tags in the pool: MethodHandle 7, MethodType 6",
+  "Scala 3.9.0: 7 classes / 18 ldc sites / tags 15,16,17 as an ldc operand: 0; same tags in the pool: MethodHandle 11, MethodType 6",
+  "the pool counts are the non-vacuity check: they are non-zero, so the invokedynamic machinery really ran and the handles/types really were built — they simply never reach an ldc operand",
+  "tag 17 (Dynamic) is 0 in the pool as well as at ldc sites for both compilers, so neither emits condy at all",
+  "POSITIVE CONTROL, same scanner, same session: `python3 scripts/survey-ldc-constant-tags.py test-data/ldc` -> {MethodHandle 1, MethodType 2, Dynamic 7}. So the 0 above is not 'the scanner cannot see these tags'.",
+  "scanner error bar on both targeted runs: impossible operands 0 (0.00%)",
+  "flags chosen to route *more* through invokedynamic (-Xlambdas=indy, -Xsam-conversions=indy, -Xstring-concat=indy-with-constants; scalac -release 21). Measuring without them would test a compiler configured away from the question.",
+  "cargo test --all: 578 passed / 0 failed / 1 ignored — unchanged, this round adds no Rust",
+  "the proposal's cost premise was re-measured and is partly false: it says the machine is 'deliberately kept free of JVM toolchains', but openjdk 26 has been installed via homebrew since 2026-03-11 (INSTALL_RECEIPT epoch 1784711495), months before the survey. The marginal install was therefore one formula each: brew deps are kotlin->openjdk, scala->openjdk+scala-cli."
+ ],
+ "issues": [
+  "MACHINE STATE CHANGED: kotlin 2.4.20 and scala 3.9.0 (plus scala-cli) are now installed via homebrew on a machine shared by ~28 agent lanes. Additive and reversible — `brew uninstall kotlin scala` — and left in place deliberately so the measurement can be re-run, but it is a change nobody else asked for.",
+  "One program per compiler. This bounds the listed features, not the languages — the survey's own framing of the corpus axis applies here in the other direction.",
+  "Not runnable in CI: no setup-java step exists, and now two more compilers would be needed. Like test-data/src/verify-javac-fixtures.sh this is a check a person runs.",
+  "The answer is the same zero the proposal predicted. What was bought is the error bar, exactly as its tradeoff said — and that is the honest accounting of the round's value."
+ ],
+ "adoptedProposals": [
+  "2026-09-16-ldc-tags-real-world-generator-survey#p1"
+ ],
+ "proposals": []
+}

docs/worklog/2026-09-17-ldc-targeted-shapes-kotlin-scala.md

@@ -0,0 +1,60 @@
+# 2026-09-17 — kotlinc·scalac 를 «타깃 형상»으로 몰았다 (rustjava-adopt-ldc-tags-real-world-generator-survey-p1)
+
+채택 제안 `2026-09-16-ldc-tags-real-world-generator-survey#p1`.
+조사 회차는 **컴파일러의 stdlib**(= 그 컴파일러 자신의 산출물)을 쟀고, ★**「그 컴파일러에게 «문제의 기능»을
+직접 컴파일시키지는 않았다」를 자기 표에 「못 쟀다」로 적어 두었다.** 그 칸을 채운다.
+
+## 결과 — ★**0. 그러나 «다른 0» 이다**
+
+| 컴파일러 | 버전 | 클래스 | ldc 자리 | ★**ldc 피연산자 15/16/17** | 풀에 «존재» |
+|---|---|---|---|---|---|
+| Kotlin | kotlinc-jvm **2.4.20** (JRE 26) | 7 | 23 | ★**0** | MethodHandle **7** · MethodType **6** |
+| Scala 3 | scalac **3.9.0** | 7 | 18 | ★**0** | MethodHandle **11** · MethodType **6** |
+
+★★**풀 수치가 이 0 을 읽을 값으로 만든다** — 0 이 아니다. 즉 **indy 경로가 실제로 돌았고 상수도 실제로 만들어졌다.**
+다만 그것들이 **`ldc` 피연산자에 닿지 않는다.** ⇒ 「안 썼다」가 아니라 ★**「썼는데도 그 자리에 안 온다」**이다.
+
+★**태그 17(Dynamic)은 풀에도 0** 이다 — ⇒ ★**두 컴파일러 모두 condy 를 «아예» 내지 않는다.** 둘 중 더 센 진술이다.
+
+## 무엇을 «타깃 형상»으로 골랐나
+
+두 파일(`scripts/ldc-tag-survey-targets/Targets.{kt,scala}`) — 태그 15·16 이 컴파일러 산출물에서
+**사는 유일한 자리**가 invokedynamic 이므로, **indy 로 가는 기능을 전부** 넣었다:
+
+람다 · **언바운드/바운드 메서드 참조** · SAM 변환(**네이티브 인터페이스 + Java 인터페이스 둘 다**) ·
+enum 주어(`when`/`match`) · 문자열 연결 · lazy · (Kotlin) reified 타입 파라미터 · (Scala) **eta 확장 · inline def · 구조적 타입**.
+
+★**플래그도 «더 많이» indy 로 보내는 쪽으로 골랐다**:
+```
+kotlinc -jvm-target 21 -Xlambdas=indy -Xsam-conversions=indy -Xstring-concat=indy-with-constants -d <out> …/Targets.kt
+scalac  -release 21 -d <out> …/Targets.scala
+python3 scripts/survey-ldc-constant-tags.py <out>
+```
+★**이 플래그를 빼고 재면 「질문에서 비껴 설정된 컴파일러」를 재는 것**이고, 그것이 코퍼스 축이 피할 수 없던 약점이다
+(stdlib 은 **호환성**을 위해 컴파일되지 백엔드를 훑으려고 컴파일되지 않는다).
+
+## ★양방향 — 이 0 이 「스캐너가 못 본다」가 아님을 먼저 보였다
+
+```
+python3 scripts/survey-ldc-constant-tags.py test-data/ldc
+  ★ tags 15/16/17 as an ldc operand: {'MethodHandle': 1, 'MethodType': 2, 'Dynamic': 7}
+```
+같은 스캐너 · 같은 세션에서 **우리 픽스처는 «보인다»** ↔ **타깃 형상은 0**.
+스캐너 오차 막대(불가능 피연산자)는 두 타깃 실행 모두 **0 (0.00%)**.
+
+## ★제안의 «값» 전제를 다시 쟀다 — 부분적으로 거짓이었다
+
+제안의 `tradeoff` 는 「**JVM 툴체인이 의도적으로 없는 맥**에 컴파일러 둘을 설치하는 값」이라 했다.
+실측: ★**openjdk 26 은 2026-03-11 부터 homebrew 로 설치돼 있었다**(`INSTALL_RECEIPT` epoch `1784711495`) —
+조사 회차(**09-16**)보다 **반년 앞선다**. ⇒ 한계 설치 비용은 **formula 하나씩**이었다
+(`kotlin → openjdk` · `scala → openjdk, scala-cli`).
+
+## ★대가 — 숨기지 않는다
+
+- ★★**머신 상태가 바뀌었다**: `kotlin 2.4.20` · `scala 3.9.0`(+`scala-cli`)이 **설치됐다**.
+  에이전트 레인 약 28개가 공유하는 맥이다. **가산적이고 되돌릴 수 있다** — `brew uninstall kotlin scala`.
+  ★**일부러 남겼다**(재측정 가능성). 그러나 **아무도 따로 요청하지 않은 변경**이라 여기 적는다.
+- **컴파일러당 프로그램 «하나»** ⇒ 위에 나열한 **기능들**을 한정할 뿐 **언어**를 한정하지 않는다.
+- ★**CI 에서 못 돈다** — `setup-java` **0건**인데 이제 컴파일러가 둘 더 필요하다.
+  `test-data/src/verify-javac-fixtures.sh` 와 같은 계급: **사람이 돌리는 검사**다.
+- ★**답은 제안이 예상한 그 0 이다.** 산 것은 **오차 막대**뿐이고, 그것이 이 회차 값의 정직한 회계다.

scripts/ldc-tag-survey-targets/Targets.kt

@@ -0,0 +1,44 @@
+// Kotlin shapes most likely to put CONSTANT_MethodHandle (15), MethodType (16) or Dynamic (17)
+// at an `ldc` site. Compiled with every flag that routes a feature through invokedynamic, because
+// that is where those three tags live in compiler output at all.
+//
+//   kotlinc -jvm-target 21 -Xlambdas=indy -Xsam-conversions=indy \
+//           -Xstring-concat=indy-with-constants -d <out> Targets.kt
+import java.util.function.Function
+import java.util.function.Supplier
+
+fun interface Op {
+    fun apply(x: Int): Int
+}
+
+enum class Color { RED, GREEN, BLUE }
+
+class Holder(val n: Int) {
+    fun twice(): Int = n * 2
+}
+
+fun topLevel(x: Int): Int = x + 1
+
+val lazyValue: String by lazy { "computed" }
+
+inline fun <reified T> typeName(): String = T::class.java.name
+
+fun main() {
+    val h = Holder(21)
+    val lambda: (Int) -> Int = { it * 3 }                       // lambda
+    val unbound: (Int) -> Int = ::topLevel                      // unbound callable reference
+    val bound: () -> Int = h::twice                             // bound callable reference
+    val sam: Op = Op { it - 1 }                                 // SAM conversion, Kotlin fun interface
+    val jfun: Function<String, Int> = Function { it.length }    // SAM conversion, Java interface
+    val sup: Supplier<String> = Supplier { "s" }
+    val c = Color.GREEN
+    val w = when (c) {                                          // enum subject
+        Color.RED -> "r"
+        Color.GREEN -> "g"
+        Color.BLUE -> "b"
+    }
+    // string templates: the one construct javac routes through invokedynamic by default
+    val s = "a=${lambda(1)} b=${unbound(2)} c=${bound()} d=${sam.apply(5)} " +
+        "e=${jfun.apply("ab")} f=${sup.get()} g=$w h=${typeName<Holder>()} i=$lazyValue"
+    println(s + Holder::class.java.simpleName)
+}

scripts/ldc-tag-survey-targets/Targets.scala

@@ -0,0 +1,41 @@
+// Scala 3 shapes most likely to put CONSTANT_MethodHandle (15), MethodType (16) or Dynamic (17)
+// at an `ldc` site. Scala routes lambdas, SAM conversion and structural calls through
+// invokedynamic, which is where those tags appear in compiler output at all.
+//
+//   scalac -release 21 -d <out> Targets.scala
+import java.util.function.{Function => JFunction, Supplier}
+import scala.reflect.Selectable.reflectiveSelectable
+
+trait Op:
+  def apply(x: Int): Int
+
+enum Color:
+  case Red, Green, Blue
+
+class Holder(val n: Int):
+  def twice: Int = n * 2
+
+object Targets:
+  def topLevel(x: Int): Int = x + 1
+  inline def inlined(x: Int): Int = x * 2
+  lazy val lazyValue: String = "computed"
+
+  type Named = { def twice: Int }
+
+  def main(args: Array[String]): Unit =
+    val h = Holder(21)
+    val lambda: Int => Int = _ * 3                              // lambda
+    val eta: Int => Int = topLevel                              // eta-expansion
+    val bound: () => Int = () => h.twice
+    val sam: Op = (x: Int) => x - 1                             // SAM conversion, Scala trait
+    val jfun: JFunction[String, Integer] = (s: String) => s.length  // SAM conversion, Java interface
+    val sup: Supplier[String] = () => "s"
+    val c: Color = Color.Green
+    val w = c match                                             // enum subject
+      case Color.Red   => "r"
+      case Color.Green => "g"
+      case Color.Blue  => "b"
+    val struct: Named = h                                       // structural type -> reflective call site
+    val s = s"a=${lambda(1)} b=${eta(2)} c=${bound()} d=${sam.apply(5)} " +
+      s"e=${jfun.apply("ab")} f=${sup.get()} g=$w h=${struct.twice} i=${inlined(4)} j=$lazyValue"
+    println(s)

scripts/survey-ldc-constant-tags.py

@@ -13,6 +13,45 @@
 legally take. That last number is the scanner's own error bar — an instruction walk that loses
 alignment lands on nonsense, so a non-zero share there is a reason to distrust the rest. It is
 *detectable* misdecodes only: a misdecode landing on a plausible tag stays invisible.
+
+## Targeted shapes, not just corpora (2026-09-17)
+
+The first survey measured what kotlinc and scalac had already produced — their own stdlibs — and
+said outright that it had not asked either compiler to compile the features most likely to emit
+these constants. That gap is closed: `ldc-tag-survey-targets/` holds one file per language
+exercising lambdas, unbound and bound method references, SAM conversion to both a native and a
+Java interface, an enum subject, string concatenation, a lazy value, and (Scala) eta-expansion,
+an inline def and a structural type.
+
+    kotlinc -jvm-target 21 -Xlambdas=indy -Xsam-conversions=indy \
+            -Xstring-concat=indy-with-constants -d <out> scripts/ldc-tag-survey-targets/Targets.kt
+    scalac  -release 21 -d <out> scripts/ldc-tag-survey-targets/Targets.scala
+    python3 scripts/survey-ldc-constant-tags.py <out>
+
+Measured with kotlinc-jvm 2.4.20 and Scala 3.9.0 (both on JRE 26):
+
+    Kotlin  7 classes · 23 ldc sites · tags 15/16/17 as an ldc operand: 0
+                                       same tags in the pool: MethodHandle 7, MethodType 6
+    Scala   7 classes · 18 ldc sites · tags 15/16/17 as an ldc operand: 0
+                                       same tags in the pool: MethodHandle 11, MethodType 6
+
+The pool counts are what make that 0 worth reading: they are non-zero, so the invokedynamic paths
+really were exercised and the constants really were built — they just never reach an `ldc`
+operand. Tag 17 (Dynamic) is absent from the pool in both, so neither compiler emits condy at all,
+which is the stronger statement of the two.
+
+The flags are deliberately the ones that route *more* through invokedynamic. A run without them
+measures a compiler configured away from the shapes in question, which is the mistake the corpus
+axis could not avoid: a stdlib is compiled for compatibility, not to exercise the backend.
+
+Positive control, so the 0 is not "the scanner cannot see it":
+
+    python3 scripts/survey-ldc-constant-tags.py test-data/ldc
+    -> tags 15/16/17 as an ldc operand: {MethodHandle 1, MethodType 2, Dynamic 7}
+
+Not covered, said plainly: this is one program per compiler, so it bounds the *features listed
+above* and not the languages. And it needs kotlinc and scalac installed — CI has neither, so like
+`test-data/src/verify-javac-fixtures.sh` this is a check a person runs, not one that runs itself.
 """
 
 import sys