Xcode preso na indexação

Um projeto em que estou trabalhando há 2 meses parou de funcionar sem motivo porque o Xcode travou em "Indexação". Não consigo mais construir o projeto. Se tento construir, o Xcode congela e tenho que forçar o encerramento. Isso acontece apenas com este projeto.

Tentei limpar todos os dados derivados, mas não ajudou.

Estou usando o Xcode 4.5.2.

Alguma ideia?

1. Abra sua pasta de projeto.
2. Encontre o arquivo ProjectName.xcodeproj.
3. Clique com o botão direito em Copiar e colar em um local seguro.
4. Clique com o botão direito em Mostrar conteúdo do pacote.
5. Encontre o arquivo project.xcworkspace e exclua esse arquivo.
6. Reabra seu projeto, limpe e reconstrua.

Se o seu problema não for resolvido, substitua o arquivo pelo arquivo de backup.

1. Feche esse projeto do Xcode
2. Abra o Xcode Organizer, encontre o projeto problemático
3. Exclua a pasta de Dados Derivados no Organizer
4. Fechar / reabrir o Xcode

Nuking Derived Data é a primeira coisa a tentar em todos os casos de comportamento incorreto do Xcode

Eu tive esse mesmo problema, foi causado por um literal de matriz de 20 itens. Tive que mudar para uma sintaxe diferente. Muito bobo.

1. Feche qualquer Xcode aberto
2. rm -rf ~/Library/Developer/Xcode/DerivedData
3. Clique com o botão direito no seu PROJECT_NAME.xcworkspace, escolha 'mostrar conteúdo' e exclua a pasta 'xcuserdata'

Tive um problema semelhante e descobri que acidentalmente defini uma classe como sua própria subclasse. Não recebi nenhum aviso ou erro para isso, mas a compilação travou.

class mainClass : mainClass
{
    ...
}

Ao usar o Xcode 6 e ele diz

Esperando fazer

Pode ser que uma instância de make já esteja em execução. Elimine o processo e a indexação continua. Tolo, mas funcionou para mim.

Outra coisa a tentar se você está tentando resolver problemas de indexação e você está tão adiantado na página!

Tente adicionar este sinalizador às suas configurações de construção.

-Xfrontend -warn-long-expression-type-checking=400

Isso causará um aviso quando o compilador levar muito tempo para deduzir uma expressão complexa.

Isso pode causar um erro de construção que desaparecerá depois que você encontrar as expressões lentas e remover o sinalizador de construção.

Segure alt> Produto> Limpar pasta de compilação

É um bug do Xcode (Xcode 8.2.1) e relatei à Apple que isso acontecerá quando você tiver um grande literal de dicionário ou um literal de dicionário aninhado. Você tem que quebrar seu dicionário em partes menores e adicioná-las com o método append até que a Apple conserte o bug.

• Primeiro, desconecte-se da rede. Tanto a rede com fio quanto a rede sem fio devem ser desligadas.
• Em segundo lugar, elimine o com.apple.dt.SourceKitServiceprocesso. Então o XCode começaria a indexar novamente em vez de travar.

Para mim, fechar completamente o Xcode e reiniciar o projeto funcionou.

Esta não é a solução para a pergunta original, não acredito, mas é mais uma coisa simples de tentar antes de excluir arquivos e pastas, etc. Crédito a esta resposta pela ideia.

Isso aconteceu comigo. Se você estiver usando cocoapods, faça o seguinte:

1. Excluir project.xcworkspace
2. Reinstale pods usando 'pod install' no terminal
3. Isso criará um novo project.xcworkspace
4. Abra o novo project.xcworkspace -> Limpar -> Construir

Tive um problema semelhante em que o Xcode gastava muito tempo indexando e frequentemente travava a construção do projeto, ponto em que tive que forçar o encerramento e reiniciar o Xcode. Foi muito chato.

Então, percebi um aviso no projeto sobre a atribuição indevida de selfdelegado. Com certeza, havia um protocolo ausente na declaração da classe. Observe que há uma atribuição semelhante no código de amostra do OP (embora seja impossível dizer a partir da amostra se o protocolo correto foi declarado):

leaderboardController.leaderboardDelegate == self;

Depois de resolver esse aviso (declarando corretamente o protocolo implementado), o Xcode parou de se comportar mal. Além disso, devo observar que o projeto foi executado corretamente desde que os métodos de protocolo foram implementados. Acontece que o Xcode não pôde confirmar se o protocolo deveria de fato ser implementado pela classe.

Nada funcionou para mim, meu projeto é muito grande (fusão objetivas c, c++, swift, e javaarquivos com j2obj). Desativei a indexação do Xcode e trabalhei sem completar código por meses (e é uma dor). Mas finalmente encontrei uma solução alternativa. A ideia é manter o Xcode indexando o código, mas limitar o uso da CPU com uma ferramenta externa comocputhrottle .

Então, primeiro você precisa instalar o cputhrottle no terminal

brew instalar cputhrottle

Em seguida, limite o processo de indexação do Xcode assim (20 = 20%)

sudo cputhrottle $ (pgrep -f com.apple.dt.SKAgent) 20

Expus minha "solução" aqui com detalhes de modo: Como evitar que o Xcode use 100% da CPU ao indexar grandes projetos

Teve problema semelhante no Xcode 6.4. A barra de progresso indicava que "Indexação" estava "Pausada". Tentei excluir project.xcworkspace e, em seguida, excluir os Dados Derivados conforme descrito acima. Não pareceu ajudar. Observando que os posts acima também sugerem consertar os avisos, e como eu havia herdado esse enorme projeto com 180 avisos, disse a mim mesmo: "Que diabos este parece ser um bom dia para corrigir os avisos". Enquanto corrigia os avisos, meia hora depois, percebi que a barra de progresso "Indexação" havia aumentado de 10% para cerca de 20%. Uma hora depois, estava a 50%, depois outra hora a 80%, e depois de meia hora estava feito! Conclusão: Acrescente "almoçar ou tirar uma soneca" às sugestões acima.

Eu tive o mesmo problema com o Xcode 7.0 beta. No meu caso, os valores para "Provisioning Profile" e "Product bundle identifier" de "Build Settings" diferiram entre PROJECT e TARGETS. Eu defino os mesmos valores para eles. E também usei os mesmos valores para TARGETS de "appName" e "appNameTest". Em seguida, fechou o projeto e o reabriu. Isso resolveu meu caso.

No meu caso, excluir o diretório de dados derivados não ajudou. Aparentemente, eu tinha um arquivo bloqueado por outro processo, porque depois de fechar algumas janelas de terminal e emacs e encerrar um processo de empacotador reagente nativo, tudo foi resolvido.

Para mim, cometi um erro estúpido. Eu escrevo uma aula como esta:

class A: A {
.......
}

Uma classe herda a si mesma que causa o congelamento. Não há dica de mensagem do Xcode.

Eu experimentei esse problema em alguns projetos com o Xcode 9.3.1 e no meu caso o problema é devido a algum código rápido que por algum motivo o Xcode não gosta. Esse problema é difícil de resolver porque é difícil descobrir qual arquivo está causando o problema.

Quando tenho esse problema, removo alguns arquivos do projeto Xcode (removendo referências) e tento testar se a indexação funciona. Meu processo para fazer isso

1. Remova alguns arquivos
2. Fechar Xcode
3. Abra o Xcode
4. Se a indexação terminar tente renomear algum método se funcionar provavelmente os arquivos que você removeu possuem algo estranho para o Xcode.

No meu caso, eu tinha uma definição de classe com uma extensão reativa no mesmo arquivo e por algum motivo o Xcode não gostou, movi a extensão reativa para outro arquivo e agora a indexação funciona bem.

Também pare de executar o aplicativo. se você tiver outro aplicativo em execução com seu xcode, interrompa-o primeiro e deverá continuar com a indexação.

Para mim, a causa foi que eu abri o mesmo arquivo no Editor Principal e no Editor Assistente ao mesmo tempo. Assim que fechei o Editor Assistente, ele veio. (Xcode Versão 7.2.1)

Feche seu Xcode, feche qualquer cliente git (árvore de origem ou terminal) se ele estiver aberto e finalmente reinicie seu projeto.

Enfrentei isso recentemente no XCode 7.3.1 - para mim, notei o uso de RAM indo para 100% no CleanMyMac3. O problema se resolveu magicamente depois que reiniciei minha máquina. Com toda a justiça, entretanto, eu já havia tentado a resposta aceita, então você vai querer fazer o mesmo antes de reiniciar, apenas no caso :-)

Corrigi isso simplesmente excluindo o aplicativo do meu dispositivo e reconstruindo.

Eu tive o mesmo problema no Swift 2.2

Tinha a ver com uma função sobrecarregada de função genérica

func warnLog() {
    print("Warning line: \(#line) file: \(#file) ")
}

func warnLog<T>(input:T? = nil) -> T? {
    print("Warning line: \(#line) file: \(#file) ")
    return input
}

func warnLog<T>(input:T) -> T {
    print("Warning line: \(#line) file: \(#file) ")
    return input
}

tudo que eu precisava fazer é remover uma das sobrecargas não usadas

func warnLog<T>(input:T? = nil) -> T? {
    print("Warning line: \(#line) file: \(#file) ")
    return input
}

Meu caso: não era o arquivo project.xcworkspace, não era a pasta Derived Data.

Eu perdi muito tempo. Pior, nenhuma mensagem de erro. Nenhuma pista da parte do Xcode. Totalmente perdida.

Finalmente esta função (com mais de 10 parâmetros) é a responsável.

func animationFrames(level: Float,
                     image: String,
                     frame0: String,
                     frame1: String,
                     frame2: String,
                     frame3: String,
                     frame4: String,
                     frame5: String,
                     frame6: String,
                     frame7: String,
                     frame8: String,
                     frame9: String,
                     frame10: String) {
}

Ficar louco! A verdade é que é preocupante (porque não há erro de sintaxe, nem de qualquer tipo)

Para problema de indexação do XCode 9.3 - Desinstale o XCode e instale novamente do zero. Funciona para mim.

Esse problema aconteceu comigo quando minha máquina estava sem espaço de troca. Fechou vários programas e guias do navegador e a compilação de repente teve sucesso após 30 minutos de estar travada no lugar. Nada a ver com dados derivados, arquivos bloqueados, etc. do meu lado.

Eu tentei todas as coisas listadas, a indexação continua congelando. Isso me ajudou: se sua indexação estiver congelada e você tiver um ou mais processos rápidos consumindo 99% de sua CPU - apenas elimine esta (s) tarefa (s) rápida (s), espere um pouco e o progresso deve avançar. Pode se repetir, até chegar ao fim, no meu caso matei o processo 7 vezes, mas no final a indexação foi concluída!

Tive esse problema em um projeto SwiftUI. Descobri que uma das minhas visualizações SwiftUI tinha uma variável declarada incorretamente. Eu tinha:

@EnvironmentObject var roomViewModel

onde eu precisava:

@EnvironmentObject var roomViewModel: RoomViewModel

Não houve erro do compilador, apenas indexação sem fim. Depois de corrigir o erro, o projeto foi construído rapidamente.