Mutação, compartilhamento e aliasing inesperado

Referências compartilhadas ocorrem quando duas variáveis se referem ao mesmo objeto. Com tipos de valor, isso é impossível; com tipos de referência, pode causar erros inesperados. Entender essa distinção é fundamental.

```swift var a = [1,2,3] var b = a // independent copy a.append(4) print(b) // [1,2,3] — unchanged ``` Cada atribuição de um tipo de valor cria uma cópia independente.

```swift class Counter { var value = 0 } let a = Counter() let b = a // SAME object a.value += 1 print(b.value) // 1 — b sees the change! ``` Tanto `a` quanto `b` apontam para o mesmo objeto na memória dinâmica.

```swift func increment(_ c: Counter) { c.value += 1 } let shared = Counter() increment(shared) print(shared.value) // 1 — mutated by the function ``` As classes são passadas por referência — a função altera o original.

```swift class Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // aliased! cache.items.append("data") print(cache2.items) // ["data"] — unexpected! ``` É assim que partes aparentemente não relacionadas do código afetam umas às outras.

```swift struct Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // independent copy cache.items.append("data") print(cache2.items) // [] — unaffected ```

```swift func process(_ c: Counter) { var local = Counter() local.value = c.value // copy values, not reference local.value += 1 } ``` Quando precisar de semântica de referência, mas não de referências compartilhadas, copie os valores explicitamente.

A aliasação se torna especialmente perigosa entre linhas de execução: ```swift // Thread 1: cache.items.append("a") // Thread 2 simultaneously: cache.items.append("b") // ❌ data race! ``` Os tipos de valor na Concorrência do Swift evitam isso por padrão — somente os atores podem compartilhar estado mutável.

O Sanitizador de Linhas de Execução (TSan) do Xcode detecta condições de corrida em tempo de execução. Ative-o em Esquema > Diagnóstico > Sanitizador de Linhas de Execução. A Verificação de Exclusividade do Swift detecta, em tempo de execução, violações de aliasação em uma única linha de execução para parâmetros `inout`.

Às vezes, a aliasação é intencional — por exemplo, um cache global: ```swift class AppCache { static let shared = AppCache() // intentional shared reference var data: [String: Any] = [:] } ``` Documente claramente o compartilhamento intencional; por padrão, evite a aliasação preferindo tipos de valor.

Principais conclusões: • Tipos de valor (estruturas) — a atribuição faz uma cópia; não é possível haver aliasação • Tipos de referência (classes) — a atribuição compartilha a referência; pode haver aliasação • Aliasação entre linhas de execução = condição de corrida • Prefira estruturas por padrão; use classes somente quando for necessária uma identidade compartilhada • Use o TSan e a Verificação de Exclusividade do Swift para detectar problemas A seguir: grafos mistos de valores e referências.