Clamp syntax version to v1.13 minimum in get_project_syntax_version

Fix issue where packages with ancient compat declarations like
`julia = "1"` would have their syntax version set to v1.0, causing
the parser to reject newer syntax features like `import ... as`.

Since syntax versioning was introduced in Julia 1.14, we now clamp
the syntax version to at least v1.13 (NON_VERSIONED_SYNTAX) to match
the logic in Base.loading.jl.

This also fixes a bug in the original function where it referenced
`syntax_table["julia_version"]` instead of `p.julia_syntax_version`.

Fixes JuliaLang/julia#60273

Author: claude

src/Operations.jl

@@ -22,6 +22,12 @@ import ...Pkg: usable_io, discover_repo, create_cachedir_tag, manifest_rel_path
 # Utils #
 #########
 
+# Syntax versioning was first introduced in Julia 1.14, so we clamp the
+# syntax version to this minimum to avoid enforcing old syntax rules for
+# packages with ancient compat declarations (e.g., compat.julia = "1").
+# This mirrors Base.NON_VERSIONED_SYNTAX in loading.jl.
+const NON_VERSIONED_SYNTAX = v"1.13"
+
 # Helper functions for yanked package checking
 function is_pkgversion_yanked(uuid::UUID, version::VersionNumber, registries::Vector{Registry.RegistryInstance} = Registry.reachable_registries())
     for reg in registries
@@ -386,29 +392,44 @@ this precedence order:
 2. If `compat.julia` is specified, use the minimum version from the compat range
 3. Otherwise, default to the current Julia VERSION
 
+The result is clamped to at least `NON_VERSIONED_SYNTAX` (v1.13) since syntax
+versioning was introduced in Julia 1.14. This prevents packages with ancient
+compat declarations (e.g., `julia = "1"`) from having their syntax version set
+too low, which would cause the parser to reject newer syntax features.
+
 This information is used to populate the `syntax.julia_version` field in the
 Manifest.toml, allowing Base's loading system to parse each package with the
 correct syntax version.
 """
 function get_project_syntax_version(p::Project)::VersionNumber
+    sv = nothing
+
     # First check syntax.julia_version entry in Project.other
     if p.julia_syntax_version !== nothing
-        return VersionNumber(syntax_table["julia_version"])
-    end
-
-    # If not found, default to minimum(compat["julia"])
-    if haskey(p.compat, "julia")
+        sv = p.julia_syntax_version
+    elseif haskey(p.compat, "julia")
+        # If not found, default to minimum(compat["julia"])
         julia_compat = p.compat["julia"]
         # Get the minimum version from the first range
         if !isempty(julia_compat.val.ranges)
             first_range = first(julia_compat.val.ranges)
             lower_bound = first_range.lower
-            return VersionNumber(lower_bound.t[1], lower_bound.t[2], lower_bound.t[3])
+            sv = VersionNumber(lower_bound.t[1], lower_bound.t[2], lower_bound.t[3])
         end
     end
 
-    # Finally, if neither of those are set, default to the current Julia version
-    return VERSION
+    # If no version was found, default to the current Julia version
+    if sv === nothing
+        sv = VERSION
+    end
+
+    # Clamp to at least NON_VERSIONED_SYNTAX since syntax versioning was
+    # introduced in Julia 1.14
+    if sv <= NON_VERSIONED_SYNTAX
+        sv = NON_VERSIONED_SYNTAX
+    end
+
+    return sv
 end
 
 # This has to be done after the packages have been downloaded

test/manifests.jl

@@ -648,4 +648,91 @@ end
     end
 end
 
+@testset "Syntax version clamping" begin
+    @testset "get_project_syntax_version clamps to NON_VERSIONED_SYNTAX" begin
+        # Test that old compat declarations are clamped to v1.13
+        # This prevents packages with ancient compat like "julia = 1" from
+        # having their syntax version set too low (which would cause the parser
+        # to reject newer syntax features like `import ... as`)
+
+        mktempdir() do test_dir
+            # Test 1: compat.julia = "1" should be clamped to v1.13
+            ancient_compat_dir = joinpath(test_dir, "ancient_compat")
+            mkpath(ancient_compat_dir)
+            write(joinpath(ancient_compat_dir, "Project.toml"), """
+                name = "AncientCompat"
+                uuid = "12345678-1234-1234-1234-123456789012"
+                version = "0.1.0"
+
+                [compat]
+                julia = "1"
+                """)
+            ancient_project = Pkg.Types.read_project(joinpath(ancient_compat_dir, "Project.toml"))
+            syntax_version = Pkg.Operations.get_project_syntax_version(ancient_project)
+            @test syntax_version == Pkg.Operations.NON_VERSIONED_SYNTAX
+            @test syntax_version == v"1.13"
+
+            # Test 2: compat.julia = "1.6" should also be clamped to v1.13 (since 1.6 < 1.13)
+            old_compat_dir = joinpath(test_dir, "old_compat")
+            mkpath(old_compat_dir)
+            write(joinpath(old_compat_dir, "Project.toml"), """
+                name = "OldCompat"
+                uuid = "12345678-1234-1234-1234-123456789013"
+                version = "0.1.0"
+
+                [compat]
+                julia = "1.6"
+                """)
+            old_project = Pkg.Types.read_project(joinpath(old_compat_dir, "Project.toml"))
+            syntax_version = Pkg.Operations.get_project_syntax_version(old_project)
+            @test syntax_version == v"1.13"
+
+            # Test 3: compat.julia = "1.14" should NOT be clamped (since 1.14 > 1.13)
+            new_compat_dir = joinpath(test_dir, "new_compat")
+            mkpath(new_compat_dir)
+            write(joinpath(new_compat_dir, "Project.toml"), """
+                name = "NewCompat"
+                uuid = "12345678-1234-1234-1234-123456789014"
+                version = "0.1.0"
+
+                [compat]
+                julia = "1.14"
+                """)
+            new_project = Pkg.Types.read_project(joinpath(new_compat_dir, "Project.toml"))
+            syntax_version = Pkg.Operations.get_project_syntax_version(new_project)
+            @test syntax_version == v"1.14"
+
+            # Test 4: explicit syntax.julia_version = "1.0" should also be clamped
+            explicit_old_dir = joinpath(test_dir, "explicit_old")
+            mkpath(explicit_old_dir)
+            write(joinpath(explicit_old_dir, "Project.toml"), """
+                name = "ExplicitOld"
+                uuid = "12345678-1234-1234-1234-123456789015"
+                version = "0.1.0"
+
+                [syntax]
+                julia_version = "1.0"
+                """)
+            explicit_old_project = Pkg.Types.read_project(joinpath(explicit_old_dir, "Project.toml"))
+            syntax_version = Pkg.Operations.get_project_syntax_version(explicit_old_project)
+            @test syntax_version == v"1.13"
+
+            # Test 5: explicit syntax.julia_version = "1.14" should NOT be clamped
+            explicit_new_dir = joinpath(test_dir, "explicit_new")
+            mkpath(explicit_new_dir)
+            write(joinpath(explicit_new_dir, "Project.toml"), """
+                name = "ExplicitNew"
+                uuid = "12345678-1234-1234-1234-123456789016"
+                version = "0.1.0"
+
+                [syntax]
+                julia_version = "1.14"
+                """)
+            explicit_new_project = Pkg.Types.read_project(joinpath(explicit_new_dir, "Project.toml"))
+            syntax_version = Pkg.Operations.get_project_syntax_version(explicit_new_project)
+            @test syntax_version == v"1.14"
+        end
+    end
+end
+
 end # module