Swift Xcode Index Freezing or Slow

101

Talvez seja apenas eu experimentando um "recurso" tão irritante:

Após a atualização do Xcode 6.0.1 para o Xcode 6.1, as coisas mudaram. O Xcode 6.1 está sempre indexando o projeto ou compilando os arquivos fonte. O projeto não é grande. Ele contém apenas um monte de arquivos Swift e AWS SDK 2.0 Cocoapods no espaço de trabalho. Não acho que isso deva impedir que o todo seja indexado e compilado sem problemas. Eu tentei com alguns aws-sdk-ios-samples, só para ver como o Xcode 6.1 funciona neles, e acabou ficando do mesmo jeito para sempre.

Que soluções tentei até agora:

  1. Excluindo "Dados Derivados" no Organizer e reabra um espaço de trabalho. (falha ao consertar)
  2. "Mostrar conteúdo do pacote" no arquivo .xcodeproj e excluir .xcworkspace como em ( Xcode 4 - desempenho lento )

Nenhum deles funcionou, infelizmente.

PS: talvez eu deva tentar recriar o projeto? Configurações do meu computador: MacBook Pro (Retina, 13 polegadas, meados de 2014), Memória 8 GB 1600 MHz DDR3, com Yosemite. (Acho que isso é o suficiente para executar este pequeno projeto.)

leonardo
fonte
Experiências semelhantes? Sim: indexação Xcode beta 3 Swift para sempre
zisoft
2
Não vou ser de grande ajuda, mas o que eu faço é ... Eu apenas deixei o xcode 6.x demorar. Se eu lutar contra isso, isso me ferrará muito, então eu só espero até o xcode 6 começar. Eu deixei executar sua indexação estúpida. Então eu inicio o simulador iOS separadamente e espero até que seu trampolim estúpido apareça. Finalmente, quando executo um projeto, ignoro o fato de que muitas vezes a Indexação diz "Pausado" e eu oro para <# godObject #>, bebo café e tento entrar no modo zen. Mas * suspiro *, é difícil: / e eu realmente gostei do xcode 5.1.1: |
staticVoidMan
Esta resposta funcionou para mim: stackoverflow.com/a/33395844/242933
ma11hew28

Respostas:

72

Tentei muitas das sugestões acima, incluindo divisão de arquivos, instalação do Xcode 6.2 beta e quebra de instruções de concatenação de strings. O que finalmente funcionou para mim foi dividir em várias .appendinstruções uma matriz de declaração literal de dicionários que eu estava usando para dados de teste .

// This causes indexing/building to hang...
var test = [ [ "a": false, "b": "c" ],
             [ "a": false, "b": "c" ],
             [ "a": false, "b": "c" ],
             [ "a": false, "b": "c" ],
             [ "a": false, "b": "c" ],
             [ "a": false, "b": "c" ] ]

// This works fine.
var test = [ [ "a": false, "b": "c" ] ]
test.append([ "a": false, "b": "c" ])
test.append([ "a": false, "b": "c" ])
test.append([ "a": false, "b": "c" ])
test.append([ "a": false, "b": "c" ])
test.append([ "a": false, "b": "c" ])

Além disso, pelo que vale a pena, a sexta entrada nesta matriz é o que causa o problema para mim; cinco funcionam bem.

zen
fonte
A mesma solução funcionou para mim com um dicionário. Inicializá-lo diretamente causava uma indexação em execução contínua. Inicializá-lo init()passo a passo funciona perfeitamente. Vale a pena mencionar que tive que deletar o .xcworkspacearquivo também.
jboi
Corrigido para mim sem dicionários envolvidos. Apenas uma matriz de tuplas que estava bem com 8 elementos na declaração. Tive que reverter para anexos com 11 elementos. Não se preocupou em encontrar o ponto de ruptura exato, mas constrói 10 vezes mais rápido. Xcode versão 6.1.1 (6A2008a) no Mavericks.
Josh
Eu acertei o problema com exatamente 6 elementos também. 5 estava bem.
Justin Lau
Este é um problema de XCode ou um problema de compilador?
Sljux
4
Eu experimentei isso no Xcode 7.3 com uma matriz literal de 229 itens. Em vez de dividi-lo, adicionei uma declaração de tipo em vez de deixar o Swift inferir o tipo. Depois que fiz isso, funcionou.
Brigham
34

A única solução de trabalho para mim é excluir todos os dados derivados (não apenas para o projeto atual, apenas limpar a pasta inteira) e, em seguida, reiniciar o Xcode.

  1. Abrir arquivo / preferências no Xcode

  2. Clique em Locais na extrema direita da janela pop-up

  3. Clique no pequeno ícone de seta ao lado de "/Users/Mac/Library/Developer/Xcode/DerivedData".... leva você a uma pasta Xcode que contém uma pasta DerivedData (que contém todos os dados derivados de seus projetos anteriores .)

  4. DELETE a pasta DerivedData

Remy Cilia
fonte
1
@TravisM. Você seguiu os passos? Se você for para Janela, Organizador, Projetos, Excluir dados derivados, não funcionará. Você precisa passar por Preferências.
ericgu
@ericgu Sim, mas não funcionou. Corrigi meu problema, no entanto, ele estava relacionado à inicialização de um dicionário com dados codificados permanentemente de uma só vez. Quando movi o código para adicionar os dados codificados permanentemente uma linha por vez, os problemas de congelamento / lentidão desapareceram imediatamente.
Travis M.
Pasta em ~ / Library / Developer / Xcode / DerivedData / na minha máquina. Você também pode encontrá-lo acessando Janela> Projetos no Xcode.
Suragch
Obrigado. Isso ajuda. O problema da "indexação permanente" começa logo após eu atualizar minha versão do cocoaPod e executar uma instalação de pod.
WKL
11

Você está usando CocoaPods? Encontrei o mesmo problema hoje cedo. (Usando xCode 6.1.1)

Para corrigir o problema, excluí tudo em ~/Library/Developer/Xcode/DerivedData, a Podspasta no diretório do meu projeto e <project>.xcworkspace.

Em seguida, abri o terminal, naveguei até o diretório do meu projeto e executei pod installnovamente.

Michael Schinis
fonte
1
Sim eu quero. Por enquanto o Xcode está se comportando bem. Mas de vez em quando dá erro de travamento do sourcekit. Minha solução é excluir a pasta de dados derivados.
leonard
Fico feliz em ver que isso funcionou para outra pessoa também :). Parece que o xCode está tentando indexar as bibliotecas CocoaPod e fica preso em algum lugar.
Michael Schinis,
1
Excluir a pasta Pods e o arquivo <project> .xcworkspace e, em seguida, executar a instalação do pod novamente funcionou.
KML
9

Tive o mesmo problema hoje. Xcode 6.3.2, projeto Swift de tamanho médio. Em um ponto, ele começou a indexar e nunca iria terminar de indexar. O código que causou isso foi um dicionário do tipo [String: [String]], portanto, um dicionário de chave de string com arrays de string como valores. Eu tinha dois deles com chaves de A a Z e cada uma dessas 26 entradas contém uma matriz de string com 5 a 10 strings.

Limpar dados derivados não ajudou. Apenas comentar esses dictos o fez ir de novo.

Honestamente, isso é ridículo! A Apple precisa consertar o Xcode! Já é terrivelmente lento ao compilar projetos Swift, mas bugs como este são um obstáculo. Não consigo fazer meu trabalho direito com isso!

BadmintonCat
fonte
6

Para aqueles que ainda têm esse problema, esta é uma solução alternativa que eu gosto que evita que você tenha que inserir os objetos um por um:

// instead of this, which freezes indexing
let keys = [keyQ, keyW, keyE, keyR, keyT, keyY, ... keyM]    

// and instead of this, which is ugly & lengthy
var keys = [KeyboardKey]()
keys.append(keyQ)
keys.append(keyW)
...
keys.append(keyM)

// use this:
var keys = [KeyboardKey]()
keys.appendContentsOf([keyQ, keyW, keyE, keyR, keyT, keyY, ... keyM])
Andrew Robinson
fonte
1
Uau ... Eu tive exatamente o mesmo problema. Obrigado! Eu relatei isso como um bug para a Apple. Fazer o que você disse não funcionou para mim. Tive que dividir meu longo array em arrays menores, cada um com cinco ou menos elementos.
ma11hew28
5

Para mim, tentei tudo acima sem sucesso; mas tudo que eu tive que fazer foi deletar a pasta de dados derivados, então abrir outro projeto aleatório, esperar que ele indexe e agora meu projeto original (com defeito) funciona!

Faça um favor ao mundo do desenvolvimento e torne seus compiladores rápidos de código-fonte aberto - para que não fiquemos todos frustrados por sua incompetência.

Gmeister4
fonte
3

Estou usando o Xcode versão 7.3 (7D175)

Acho que posso ter descoberto um problema subjacente. Houve duas instâncias em que fiquei preso na fase de indexação:

  • Criei um encerramento que atribuí a uma variável e omiti a assinatura de tipo. Acho que o xcode teve problemas com essa etapa de inferência de tipo. Se bem me lembro, um dos argumentos era um CGPoint, que tem um construtor sobrecarregado. Minha hipótese é que há muitas possibilidades do que meu encerramento pode aceitar como argumentos.

  • Refatorei um método de fábrica de forma que, em vez de retornar instâncias de um tipo, ele pudesse retornar instâncias de muitos tipos com uma classe base comum. Parece que sempre que usei o método de fábrica, tive que converter o objeto resultante para um tipo específico (com as? Ou atribuindo-o a uma variável que aceita um tipo específico). Novamente, a etapa de inferência de tipo parece estar quebrada.

Parece que o mesmo está acontecendo com as declarações do dicionário mencionadas por indivíduos anteriores. Eu preenchi um relatório de bug com a apple.

DudeOnRock
fonte
2

Tive o mesmo problema após atualizar para o 6.1. O Xcode travaria na compilação ou indexação sem gerar uma mensagem de erro específica.

O problema foi finalmente resolvido dividindo algumas das expressões mais longas nos arquivos swift em várias expressões mais curtas. Parte do meu programa combina muitas variáveis ​​de string diferentes para formar uma string mais longa. As tentativas de combiná-los em uma única expressão e o uso do operador de atribuição de adição falharam. Consegui fazer funcionar fazendo algo semelhante ao seguinte (simplificado):

var a = "Hello"
var b = " "
var c = "World"
var d = "!"
var partA = a + b
var partB = c + d
var result = partA + partB

Tive essa ideia ao receber o seguinte erro muitas vezes na versão anterior do Xcode "A expressão era muito complexa para ser resolvida em um tempo razoável; considere dividir a expressão em subexpressões distintas."

Espero que isto ajude

Adam137
fonte
Sim, obrigado, na verdade aceitei este tipo de sugestões. E também diminuí o comprimento de um dos meus arquivos de 1.500 linhas para cerca de 1.200. E, claro, criei um novo projeto e importei todos os arquivos um por um para ele. Então, finalmente, tudo volta. Não tenho certeza de qual é o salvador final.
leonard
Separar uma longa expressão em Swift funcionou para mim.
MandisaW
2

Eu lutei com o mesmo problema. Tentei as duas soluções mencionadas (exclusão de dados derivados e exclusão de .xcworkspace) sem sucesso. Também tentei comentar lentamente a maior parte do código aos poucos e remover os arquivos até que não houvesse quase nada e a indexação ainda estivesse travada.

Eu encontrei uma solução que funcionou para mim, abri o projeto com um Xcode versão 6.1 mais antigo (6A1030) que não tinha problemas de indexação, em seguida, voltei para a versão mais recente do Xcode 6.1 (6A1052d) que eu estava usando antes e a indexação estava corrigido e continuou a funcionar bem.

Minha conclusão é que esse é um bug do Xcode versão 6.1 (6A1052d) que espero que melhore com versões futuras.

O problema volta de vez em quando, a mesma correção sempre funciona. Acho que outra solução seria apenas ficar com a versão mais antiga do Xcode 6.1 (6A1030), mas não funcionará com dispositivos que executam o iOS 8.1 e não terá as últimas correções de bugs.

Jorge Costa
fonte
Tentei a maioria das sugestões para resolver o problema perpétuo da indexação e esta foi a única que funcionou para mim. Eu não tinha um Xcode 6 antigo, mas tinha o Xcode 5. Não construía, mas indexava e depois disso o Xcode 6.1 indexava com sucesso.
SarahR
Eu esqueci de dizer que esta era apenas uma solução temporária e eu tive que fazer novamente algumas horas depois.
SarahR
2

Eu tentei isso com o Xcode 8.3.3. Aqui estão meus resultados:

Você pode escrever um código Swift perfeitamente bom que fará com que a indexação trave.

Uma vez que a indexação trava, ela trava. Alterar o código Swift de volta para algo que não faria com que a indexação travasse não ajuda, ele ainda trava.

Fechar o projeto e reabrir não ajuda nessa situação.

Sair do Xcode e reiniciá-lo ajuda. A indexação não travará mais (isto é, se você alterou o código de volta para algo que não o faz travar).

Reiniciar o Mac também ajuda, embora não seja necessário.

O travamento é causado por um código Swift perfeitamente bom. Um exemplo que eu parecia

if let date = function1()
?? function2()
?? function3()
?? function4()
?? function5()
?? function6()
?? function7()
?? function8()
?? function9()
?? function10() {
    return date
}

A indexação travaria. Eu comentei a maior parte do "??" linhas e estava bem (depois de sair e relançar o Xcode). Sem comentários, uma linha após a outra. Com um certo número de linhas estava bom, então descomentar a próxima linha o faria travar.

Aparentemente, a única coisa que ajuda é mudar seu código.

gnasher729
fonte
2

No meu Xcode a solução foi fechar todas as janelas redundantes. Por alguma razão, muitas janelas abertas tornam o Xcode muito lento.

Arik Halperin
fonte
para mim, essa também foi a solução, surpreendente, pois funcionou bem por um longo tempo antes com o mesmo número de janelas abertas
Christian
1

Finalmente, "resolvi" o problema, embora seja apenas uma solução alternativa.

Criei outro projeto e adicionei arquivos um por um a ele. Então eu localizei um arquivo viewcontroller.swift "muito longo". Então, quebrei seus códigos em módulos e transformei esses códigos usados ​​repetidamente em funções em outro arquivo swift. E também peguei a sugestão online de que a expressão longa deve ser dividida em mais curta. Então, a indexação funciona e a compilação funciona.

Por enquanto, "resolvi".

MAS, eu não acho que isso esteja certo. O Xcode IDE deve ser mais do que capaz de lidar com meu arquivo swift "muito longo", apenas 1500 linhas. Acredito que isso seja definitivamente um bug (existente há muito tempo), embora o Xcode 6.1 já seja uma atualização do Xcode 6.0.1.

leonardo
fonte
1

Para mim, excluí o aplicativo Xcode, baixei-o novamente e instalei-o. Isso resolveu o problema, pelo menos agora.

Tzegenos
fonte
1

A indexação do Xcode geralmente para seu código para sugestões e preenchimento automático, entre outras coisas, como ajudá-lo em storyboards e vice-versa. Mas para tornar seu projeto xcode mais rápido, você pode desligá-lo / ligá-lo via terminal

Desative os
padrões de indexação write com.apple.dt.XCode IDEIndexDisable 1 Ative os padrões de indexação write com.apple.dt.XCode IDEIndexDisable 0

Mas melhor abordagem para usar um mac rápido com boa RAM.

Ballu
fonte
2
Desativar a indexação prejudica gravemente o Xcode e não deve ser feito. Dizer a alguém para comprar um novo Mac nunca deve ser a resposta, um laptop de 2 anos deve ser capaz de lidar com o Xcode mais recente.
Knight0fDragon
O macOS 10.13 Beta 7 introduziu algo que trava tanto o Xcode 9 Beta 6 quanto o Xcode 8 assim que o indexador é executado. Desligá-lo era a única maneira de continuar usando o Xcode, mesmo com uma versão inválida.
Pegolon de
0

Se você não se importa em voltar para 6.0.1 até que eles descubram, foi isso que funcionou para mim. Eu estava tendo o mesmo problema com 6.1 e 6.1.1. Agora estou bem. Vou tentar 6.2 quando for lançado.

Você pode encontrar versões anteriores do software da apple em seu site oficial de desenvolvimento, aqui: https://developer.apple.com/downloads/index.action

Se você fizer isso, certifique-se de excluir sua cópia atual do Xcode primeiro.

JeremyGranger
fonte
0

Estou usando o Xcode 6.1.1 com arquivos swift exatamente no mesmo MacBook Pro.

Conforme eu continuava adicionando linhas em um array de string 3D, o Xcode de repente se tornou inutilizável e agora eu não posso fazer nada.

Tentarei reverter para 6.1 e esperançosamente o problema irá embora.

Gardner888
fonte
Eu tenho o mesmo problema. Depois de adicionar uma série de dicionários, o xcode se tornou inutilizável ... Você encontrou a solução?
Almazini de
Voltei para o Xcode 6.1, que funcionou melhor. Não parava para sempre na indexação, mas às vezes eu digitava e pegava a bola de praia por 4 segundos. No geral, fui capaz de codificar o suficiente para fazer as coisas. Não mudei nada do meu código. Embora no Xcode 6.1 a bateria do macbook pro não parecesse muito afetada, mas no meu macbook air em meados de 2013 rodando 6.1.1, a duração da bateria está absolutamente esgotada. Vai de aproximadamente 12 horas a 2 horas restantes depois que eu inicio o Xcode.
Gardner888
0

Estou vendo isso no Xcode 6.3.2. Eu realmente esperava que um ano após o lançamento, eles tivessem o compilador funcionando, mas, infelizmente.

Se nenhuma das soluções acima funcionar, tente verificar se há erros sintáticos em seu código. No processo de refatoração, extraí um encerramento, mas esqueci de qualificar os parâmetros:

    let hangsInsteadOfError = { l, r in
        return l.nameFirst < r.nameFirst
        || l.nameFirst == r.nameFirst && l.nameLast < r.nameLast }

    let fixingErrorAvoidsHang = { (l:User, r:User) -> Bool in
        return l.nameFirst < r.nameFirst
            || l.nameFirst == r.nameFirst && l.nameLast < r.nameLast }

Se aprendi alguma coisa trabalhando em Swift, foi trabalhar de forma incremental, para evitar ter que voltar atrás para encontrar o código ofensivo.

Chris Conover
fonte
0
  1. O seu status de indexação é um "Círculo indicador" ou "Barra de progresso"?
  2. Se for um "círculo indicador", significa que já travou no início.
  3. Abra e verifique com seus outros projetos, se eles são todos iguais, isso significa que é um problema de sistema.
  4. Basta reiniciar o computador e tudo ficará bem.
Weidian Huang
fonte
0

Eu uso o Xcode 8.2 e também terminei com esse problema. Tudo começou depois que eu defini uma variável de tupla complexa - uma matriz de tupla com subarray de tupla. As coisas ficam muito lentas quando o subarray da tupla tem uma propriedade que é calculada programaticamente.

Como algumas outras respostas observaram, a indexação leva uma eternidade e acredito que está tentando inferir os tipos da variável.

Resolvi o problema primeiro definindo claramente a variável com os tipos incluídos. Ao atualizar a propriedade, eu a calculo primeiro e depois a atribuo à tupla, em vez de calcular na definição da variável.

Aqui está um código de exemplo.

var sectionTuples: [(section: String, rows: [(name: String, subtitle: String)])] = []
let subtitle1: String = "" // something calculated dynamically
let subtitle2: String = "" // something calculated dynamically
sectionTuples = [(
section: "Section 1", rows: [
(name: "name1", subtitle: subtitle1),
(name: "name2", subtitle: subtitle2)
])]

O ponto principal é que não deixe o Xcode inferir estruturas complexas.

Q Liu
fonte
0

Eu estava tendo o mesmo problema. Meu Xcode é 8.2.1. Mas, no meu caso, eu queria criar uma matriz de dicionário com 33 pares de valores-chave. Eu estava fazendo da seguinte maneira que estava travada na indexação:

var parameter = [String : AnyObject]()
var finalArray = [parameter]

for item in listArray
{
    parameter = ["A": item.a as AnyObject, "B": item.b as AnyObject, "C": item.c as AnyObject, ... , "Z": item.z as AnyObject]

    finalArray.append(parameter)
}

O seguinte funcionou para mim:

var parameter = [String: AnyObject]()
var finalArray = [parameter]

for item in listArray
{
    parameter["A"] = listArray.a as AnyObject
    parameter["B"] = listArray.b as AnyObject
    parameter["C"] = listArray.c as AnyObject
    parameter["D"] = listArray.d as AnyObject 
    .
    .
    .
    parameter["Z"] = listArray.z as AnyObject 
    finalArray.append(parameter)
}
Trup
fonte
0

Eu também tive esse problema e o resolvi removendo / alterando expressões com o operador "+".

Eu mudei isso:

var mainArray = arrayOne + arrayTwo + arrayThree + arrayFour + arrayFive

Para isso:

var mainArray = arrayOne
mainArray += arrayTwo
mainArray += arrayThree
mainArray += arrayFour
mainArray += arrayFive

Isso resolveu o problema.

Minha máquina é um MBP no máximo no final de 2013

Casey Laris
fonte
Exatamente minha experiência. Ele trava com um código Swift perfeitamente fino, e a única maneira de consertá-lo é alterando o código.
gnasher729
0

Você pode querer atualizar para o Xcode 6.1.1

Foi lançado oficialmente e resolvido para nós o problema de indexação. Na descrição da atualização, ele diz que foram aplicadas correções de estabilidade, então é muito provável que se comporte de uma maneira mais estável.

Angel Naydenov
fonte
7
Interessante. Para mim, o 6.1.1 introduziu o problema de indexação sem fim, com um projeto que estava abrindo bem no 6.1. placa
Pascal Bourque
Entendo. Em nosso caso, também simplificamos as expressões e reduzimos o tamanho das classes usando classes de extensão. O que é ridículo termos que fazer isso, mas é o que tivemos que fazer. E parece estar funcionando por enquanto. Além disso, ao comentar as linhas, estreitamos qual parte do código realmente é "excessivamente complexa" de acordo com o que o compilador Swift pensa e reduzimos a complexidade tanto quanto possível. Espero que eles consigam isso logo, pois é muito chato.
Angel Naydenov
0

O Xcode 6.2 beta resolveu o problema para mim. Não muito rápido, mas pelo menos não está indexando para sempre. O beta não instala sobre a instalação regular do Xcode, então se você não gosta do beta, você pode simplesmente excluí-lo.

Vários downloads de Xcode, incluindo o beta>

Warren Whipple
fonte
0

Eu tinha expressões como:

let x = (value as? Int) ?? someDefault

Além disso

guard let x = (dateFormatter().string(from: Date()) + msg + "\n").addingPercentEncoding(...) else { ... }

Portanto, o objetivo é reescrever seu arquivo para conter apenas expressões de nível de jardim de infância e o problema de indexação irá embora.

soger
fonte
0

Xcode 11.5 (11E608c) e ainda os mesmos problemas, 6 anos após a pergunta original. Eu gostaria de poder "marcar" a maçã nesta questão para que eles possam ver essa bagunça. Este é um grande projeto (> 1000 arquivos) e eu estava abaixo do relógio, então quando eu notei o índice de congelamento eu estava com mais de 100 arquivos alterados e não posso voltar atrás.

Já tentei de tudo:

  1. limpar dados derivados e construir
  2. Reinicie o xcode, reinicie o mac
  3. remover e adicionar fonte
  4. Pesquisado por dicionários literais etc etc

O problema era a criação de um array:

private var overlayColors: [UIColor] = [UIColor(hex: "#b71c1c"), UIColor(hex: "#4a148c"),
                                        UIColor(hex: "#880e4f"), UIColor(hex: "#1de9b6"),
                                        UIColor(hex: "#f50057"), UIColor(hex: "#311b92"),
                                        UIColor(hex: "#f44336"), UIColor(hex: "#651fff"),
                                        UIColor(hex: "#d500f9"), UIColor(hex: "#3d5afe"),
                                        UIColor(hex: "#bf360c"), UIColor(hex: "#0d47a1"),
                                        UIColor(hex: "#006064"), UIColor(hex: "#2979ff"),
                                        UIColor(hex: "#ff6f00"), UIColor(hex: "#1a237e"),
                                        UIColor(hex: "#795548"), UIColor(hex: "#004d40"),
                                        UIColor(hex: "#00e676"), UIColor(hex: "#01579b"),
                                        UIColor(hex: "#33691e"), UIColor(hex: "#827717"),
                                        UIColor(hex: "#76ff03"), UIColor(hex: "#ffc400"),
                                        UIColor(hex: "#e65100"), UIColor(hex: "#00b0ff"),
                                        UIColor(hex: "#ff3d00"), UIColor(hex: "#616161"),
                                        UIColor(hex: "#263238"), UIColor(hex: "#ff1744")]

O que me ajudou a descobrir o arquivo swift ruim foi quando o xcode congelou a indexação, eu fiz as seguintes etapas

  1. monitor de atividade aberto -> processo "rápido" -> mostrar informações do processo -> abrir arquivos e portas. Isso lhe dará uma lista de quais arquivos este processo está executando, detalhando sua lista de possíveis arquivos corrompidos
  2. Outra ferramenta útil é este script SOURCEKIT_LOGGING=3 /Applications/Xcode.app/Contents/MacOS/Xcode &> ~/Documents/xcode.logque iniciará o Xcode com nível 3 detalhado e iniciará o registro no arquivo de log.
  3. Pesquise no arquivo de log as últimas entradas para seus arquivos swift, ex: "my_project / Source / App /"

Não é uma solução completa, mas é útil se aprofundar e saber onde procurar.

monitor de atividade aberto -> processo "rápido" -> mostrar informações do processo -> abrir arquivos e portas.

armadilha de fogo
fonte