refactor(go): pin the type-kind parse blocker beside the other model tests

The alias fix stays bundled with this branch rather than shipping separately.
Prompted by prototyping the standalone version, which surfaced two things
worth keeping:

The two kind tests assert a property of the model over -a 1 output, with
nothing to do with the L3/L4 overlays, so they move from test_go_dataflow.py
to test_go_analysis.py beside the other model tests. The second now pins
ValidationError specifically rather than bare Exception, and says why the fix
listed the missing kind instead of widening the field to str -- widening
would have turned a loud failure into silence for every future kind.

GoType's docstring now names the analyzer file rather than a line number that
will drift, and states the consequence that makes this severe: an unlisted
kind fails the whole document, not just the one type.

Verified the regression test fails without the one-line fix and passes with
it, so it measures the fix rather than merely accompanying it.

Refs #436

Author: sinha108

cldk/models/go/models.py

@@ -281,11 +281,15 @@ class GoType(_NullSafeBase):
     discriminated by ``kind`` rather than a ``Union`` of subclasses. ``base_types`` are embedded
     types; ``fields`` are the struct's data fields (empty for every other kind).
 
-    The four kinds the analyzer emits (``symbol_table.go:432``): ``struct``, ``interface``,
-    ``defined`` (``type Celsius float64``) and ``alias`` (``type Alias = int``). This is a
-    ``Literal`` rather than an open ``str`` so a *new* kind is a loud failure and not a silent
-    mis-read — ``extra="ignore"`` does not cover a ``Literal`` mismatch, which is exactly why the
-    narrower spelling refused to parse real ``-a 1`` output (python-sdk#436).
+    The four kinds the analyzer emits (``internal/syntactic_analysis/symbol_table.go``):
+    ``struct``, ``interface``, ``defined`` (``type Celsius float64``) and ``alias``
+    (``type Alias = int``).
+
+    This stays a ``Literal`` rather than an open ``str`` so a *new* kind is a loud failure and not
+    a silent mis-read — but note what that costs: ``extra="ignore"`` does not cover a ``Literal``
+    mismatch, so an unlisted kind fails the **whole document**, not just the one type. That is why
+    omitting ``alias`` refused real ``-a 1`` output from any project declaring a type alias
+    (python-sdk#436), independently of the analysis level or the dataflow overlays.
     """
 
     id: str

tests/analysis/go/test_go_analysis.py

@@ -270,3 +270,44 @@ def test_real_corpus_call_graph_dangling_free(litestream_facade):
     assert g.number_of_edges() == 3082
     for src, dst in g.edges():
         assert "id" in g.nodes[src] and "id" in g.nodes[dst]
+
+
+# -----[ GoType.kind accepts every kind the analyzer emits ]-----
+#
+# ``kind`` is a ``Literal``, and ``extra="ignore"`` does not cover a ``Literal`` mismatch: an
+# unlisted kind fails the WHOLE document rather than dropping one field. So the listed set has to
+# be exactly the analyzer's, and a gap there is not a cosmetic omission — it is a project that does
+# not load at all. These live here rather than with the dataflow tests because the fact is about
+# ``-a 1`` output and the model that mirrors it, not about the L3/L4 overlays.
+FOUR_KINDS = Path(__file__).resolve().parents[2] / "resources" / "go" / "dataflow" / "four_type_kinds.json"
+
+
+def test_all_four_type_kinds_parse():
+    """``type Alias = int`` and ``type Celsius float64`` are ordinary Go, and cango emits them as
+    ``alias`` / ``defined`` (``internal/syntactic_analysis/symbol_table.go``). Listing only
+    ``struct``/``interface``/``defined`` made ``GoAnalysis`` refuse real ``-a 1`` output from any
+    project declaring an alias — nothing to do with the analysis level or the dataflow overlays.
+    """
+    from cldk.models.go import GoAnalysis
+
+    analysis = GoAnalysis.model_validate_json(FOUR_KINDS.read_text(encoding="utf-8"))
+    kinds = {ty.kind for module in analysis.application.symbol_table.values() for ty in module.types.values()}
+    assert kinds == {"struct", "interface", "defined", "alias"}
+
+
+def test_an_unknown_fifth_kind_still_fails_loudly():
+    """The ``Literal`` is a deliberate choice, not an oversight, so this pins the cost side of it:
+    a kind the analyzer adds must be a *visible* failure rather than a value silently coerced or
+    ignored, because every accessor keyed on ``kind`` would otherwise be quietly wrong.
+
+    Which is also why the fix was to list the missing kind rather than to widen the field to
+    ``str``: widening would have turned this failure into silence for every future kind too.
+    """
+    from cldk.models.go import GoAnalysis
+    from pydantic import ValidationError
+
+    doc = json.loads(FOUR_KINDS.read_text(encoding="utf-8"))
+    module = next(iter(doc["application"]["symbol_table"].values()))
+    next(iter(module["types"].values()))["kind"] = "type_parameter"
+    with pytest.raises(ValidationError, match="kind"):
+        GoAnalysis(**doc)

tests/analysis/go/test_go_dataflow.py

@@ -73,30 +73,12 @@ def backend(httpsql):
 
 
 # ======================================================================================
-# The parse blocker (#436's first commit): GoType.kind is a Literal, so a kind the SDK
-# does not list fails the WHOLE document rather than dropping a field.
+# The L3/L4 overlays survive validation. The *parse blocker* that shipped alongside them
+# (GoType.kind omitting "alias") is a model-level fact about -a 1 output with nothing to
+# do with dataflow, so it is pinned in test_go_analysis.py beside the other model tests.
 # ======================================================================================
 
 
-def test_all_four_type_kinds_parse():
-    """``type Alias = int`` made ``GoAnalysis(**doc)`` raise, which blocked ``-a 1`` output from any
-    project declaring an alias — nothing to do with dataflow. All four kinds must load."""
-    analysis = GoAnalysis.model_validate_json(FOUR_KINDS.read_text(encoding="utf-8"))
-    kinds = {ty.kind for module in analysis.application.symbol_table.values() for ty in module.types.values()}
-    assert kinds == {"struct", "interface", "defined", "alias"}
-
-
-def test_a_fifth_kind_is_refused_loudly_rather_than_dropped():
-    """The ``Literal`` is deliberate, not an oversight: a kind the analyzer adds must be a visible
-    failure here and not a value silently coerced or ignored, because every accessor keyed on
-    ``kind`` would then be quietly wrong. ``extra="ignore"`` does not cover a ``Literal``."""
-    doc = json.loads(FOUR_KINDS.read_text(encoding="utf-8"))
-    module = next(iter(doc["application"]["symbol_table"].values()))
-    next(iter(module["types"].values()))["kind"] = "type_parameter"
-    with pytest.raises(Exception, match="kind"):
-        GoAnalysis(**doc)
-
-
 def test_the_level_four_fixture_round_trips_losslessly():
     """Every overlay the dataflow surface reads must survive validation — the regression that
     matters is the *silent* one, where a level-4 document parses and the graph is simply gone."""