Swift Xcode Index Freezing or Slow

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.)

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.

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

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.

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!

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])

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.

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.

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

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.

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.

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

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.

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

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.

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.

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.

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.

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.

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.

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)
}

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

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.

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>

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.

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.