Swift compiler or framework bug?

Below is some simple code to insert additional points into a 2D polygon. It never terminates (on Xcode 14.3, iOS 16.4.1(a)). The cause is explained in the comments — it appears that polygon.count returns the wrong value after polygon.insert when the insertion index equals polygon.count. This can't really be a compiler/framework bug surely, what am I missing?

//
//  ViewController.swift
//  CompilerBug?
//

import UIKit
import simd

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        var polygon =  [SIMD3<Float>(1.345, 0.0, 0.002),SIMD3<Float>(1.181, 0.0, -0.171),SIMD3<Float>(1.185, 0.0, -0.206),SIMD3<Float>(1.141, 0.0, -0.255),SIMD3<Float>(1.121, 0.0, -0.257),SIMD3<Float>(0.848, 0.0, -0.636),SIMD3<Float>(0.777, 0.0, -0.604),SIMD3<Float>(0.692, 0.0, -0.532),SIMD3<Float>(0.677, 0.0, -0.5),SIMD3<Float>(0.6976719, 0.0, -0.46364594),SIMD3<Float>(0.903, 0.0, -0.188),SIMD3<Float>(1.1739755, 0.0, 0.12979852)]
        
        ViewController.addPoints(to: &polygon, every: 0.05)
    }

    static func addPoints(to polygon: inout [simd_float3], every d: Float) {
        let threshold = d * d
        var i = 0
        while i < polygon.count {
            let j = (i + 1) % polygon.count // "A"
            while polygon[i].distanceSquared2D(polygon[j]) > threshold {
                let new = simd_float3(x: (polygon[i].x + polygon[j].x) / 2.0,
                                      y: 0.0,
                                      z: (polygon[i].z + polygon[j].z) / 2.0)
                // when i+1 equals polygon.count, the subsequent call to polygon.count at "A"
                // after insertion returns the count prior to the insertion!
                polygon.insert(new, at: i + 1)
            }
            
            i += 1
        }
    }
}

extension simd_float3
{
    public func distanceSquared2D(_ b: simd_float3) -> Float {
        return (self.x - b.x) * (self.x - b.x) + (self.z - b.z) * (self.z - b.z)
    }
}

Unclear what you think your code is supposed to do, but if you instrument it with print statements you will see it is behaving logically and consistently:

    while i < polygon.count {
        print(i, polygon.count)
        let j = (i + 1) % polygon.count
        while polygon[i].distanceSquared2D(polygon[j]) > threshold {
            let new = simd_float3(x: (polygon[i].x + polygon[j].x) / 2.0,
                                  y: 0.0,
                                  z: (polygon[i].z + polygon[j].z) / 2.0)
            print("insert")
            polygon.insert(new, at: i + 1)
        }
        i += 1
    }

Every time the first print statement prints, we see that the number of times "insert" was printed and the increase in polygon.count are always the same. So one insert is one increment in polygon.count, which is as expected (and, I presume, desired).

Then when we reach i at 60 and polygon.count at 61, the inner while loop runs forever (we get a steady stream of "insert" without every coming round to the first print again) and so the app hangs.

So the only bug I see, if that's not the outcome you expect, is in your program itself. I suppose that the problem is that the condition

polygon[i].distanceSquared2D(polygon[j]) > threshold

just runs away with you, because neither i nor j changes and the insertions are now taking place at the j position.