Indice Swift Xcode congelamento o lento

Forse sono solo io a sperimentare una "caratteristica" così fastidiosa:

Dopo l'aggiornamento da Xcode 6.0.1 a Xcode 6.1, le cose sono cambiate. Xcode 6.1 indicizza per sempre il progetto o compila i file sorgente. Il progetto non è enorme. Contiene solo una serie di file Swift e Cocoapod 2.0 dell'SDK AWS nell'area di lavoro. Non penso che dovrebbe impedire all'intero di indicizzare e compilare senza problemi. Ho provato con alcuni esempi di aws-sdk-ios, solo per vedere come funziona Xcode 6.1 su di essi, ed è finito nello stesso per sempre.

Quali soluzioni ho provato finora:

1. Eliminazione di "Dati derivati" nell'Organizer e riapertura e area di lavoro. (fallire nel risolvere)
2. "Mostra contenuto pacchetto" sul file .xcodeproj ed elimina .xcworkspace come in ( Xcode 4 - prestazioni lente )

Nessuno di loro ha funzionato, sfortunatamente.

PS forse dovrei provare a ricreare il progetto? Impostazioni del mio computer: MacBook Pro (Retina, 13 pollici, metà 2014), memoria 8 GB 1600 MHz DDR3, con Yosemite. (Penso che questo sia sufficiente per eseguire questo piccolo progetto.)

Ho provato molti dei suggerimenti sopra, tra cui la divisione dei file, l'installazione di Xcode 6.2 beta e le istruzioni di concatenazione delle stringhe. Quello che alla fine ha fatto per me è stato dividere una serie di dichiarazioni letterali di dizionari che stavo usando per i dati di test in più .appendistruzioni.

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

Inoltre, per quello che vale, la sesta voce in questo array è ciò che causa il problema per me; cinque funziona bene.

L'unica soluzione funzionante per me è eliminare tutti i dati derivati ​​(non solo per il progetto corrente, basta pulire l'intera cartella) e quindi riavviare Xcode.

1. Apri File / Preferenze in Xcode

2. Fare clic su Posizioni all'estrema destra della finestra a comparsa

3. Fai clic sulla piccola icona freccia accanto a "/Users/Mac/Library/Developer/Xcode/DerivedData"....it ti porta a una cartella Xcode che contiene una cartella DerivedData (che contiene tutti i dati derivati ​​dai tuoi progetti precedenti .)

4. ELIMINA la cartella DerivedData

Stai usando CocoaPods? Oggi mi sono imbattuto nello stesso problema. (Utilizzo di xCode 6.1.1)

Per risolvere il problema, ho eliminato tutto in ~/Library/Developer/Xcode/DerivedData, la Podscartella nella directory del mio progetto e <project>.xcworkspace.

Ho quindi aperto il terminale, sono passato alla directory del mio progetto e sono corso di pod installnuovo.

Oggi ha avuto lo stesso problema. Xcode 6.3.2, progetto Swift di medie dimensioni. A un certo punto ha iniziato a indicizzare e non avrebbe mai finito di indicizzare. Il codice che ha causato questo era un dizionario di tipo [String: [String]], quindi una stringa chiave con matrici di stringhe come valori. Ne avevo due con i tasti dalla A alla Z e ciascuna di queste 26 voci contiene un array di stringhe con 5-10 stringhe.

La cancellazione dei dati derivati ​​non ha aiutato. Solo commentare quei dict lo ha fatto andare di nuovo.

Onestamente, questo è ridicolo! Apple ha bisogno di riparare Xcode! È già terribilmente lento durante la compilazione di progetti Swift, ma bug come questo sono un ostacolo. Non posso fare il mio lavoro correttamente con questo!

Per coloro che hanno ancora questo problema, questa è una soluzione alternativa che mi è piaciuta che ti impedisce di dover inserire gli oggetti uno per uno:

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

Per me, ho provato tutto quanto sopra senza successo; ma tutto quello che dovevo fare era cancellare la cartella dei dati derivati, quindi aprire un altro progetto casuale, aspettare che fosse indicizzato e ora il mio progetto originale (malfunzionante) funziona!

Fai un favore al mondo dello sviluppo e rendi i tuoi veloci compilatori open source, quindi non siamo tutti ostacolati dalla tua incompetenza.

Sto usando Xcode versione 7.3 (7D175)

Penso di aver capito un problema di fondo. Ci sono due casi in cui sono rimasto bloccato nella fase di indicizzazione:

• Ho creato una chiusura che ho assegnato a una variabile e ho omesso la firma del tipo. Penso che xcode abbia avuto problemi con quel passaggio di inferenza del tipo. Se ricordo bene uno degli argomenti era un CGPoint, che ha un costruttore sovraccarico. La mia ipotesi è che ci fossero troppe possibilità di ciò che la mia chiusura potrebbe accettare come argomenti.

• Ho riformattato un metodo factory in modo tale che invece di restituire istanze di un tipo, potrebbe restituire istanze di molti tipi con una classe base comune. Sembra che ovunque ho utilizzato il metodo factory, ho dovuto eseguire il cast dell'oggetto risultante a un tipo specifico (con as? O assegnandolo a una variabile che accetta un tipo specifico) Anche in questo caso il passaggio di inferenza del tipo sembra essere interrotto.

Sembra che lo stesso stia succedendo con le dichiarazioni del dizionario menzionate da individui precedenti. Ho presentato una segnalazione di bug a Apple.

Ho riscontrato lo stesso problema dopo l'aggiornamento a 6.1. Xcode si bloccherebbe durante la compilazione o l'indicizzazione senza generare un messaggio di errore specifico.

Il problema è stato finalmente risolto suddividendo alcune delle espressioni più lunghe nei file swift in più espressioni più brevi. Parte del mio programma combina molte variabili stringa diverse per formare una stringa più lunga. I tentativi di combinarli in una singola espressione e l'utilizzo dell'operatore di assegnazione di addizione non sono riusciti. Sono stato in grado di farlo funzionare facendo qualcosa di simile al seguente (semplificato):

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

Ho avuto questa idea ricevendo più volte il seguente errore nella versione precedente di Xcode "L'espressione era troppo complessa per essere risolta in un tempo ragionevole; considera di suddividere l'espressione in sottoespressioni distinte."

Spero che questo ti aiuti

Ho lottato con lo stesso problema. Ho provato le due soluzioni menzionate (eliminazione dei dati derivati ​​ed eliminazione di .xcworkspace) senza successo. Ho anche provato a commentare lentamente la maggior parte del codice bit per bit e rimuovere i file fino a quando non era rimasto quasi nulla e l'indicizzazione era ancora bloccata.

Ho trovato una soluzione che ha funzionato per me, ho aperto il progetto con una versione precedente di Xcode 6.1 (6A1030) che non aveva problemi di indicizzazione, quindi sono tornata all'ultima versione di Xcode 6.1 (6A1052d) che stavo usando prima e l'indicizzazione era riparato e ha continuato a funzionare bene.

La mia conclusione è che questo è un bug con Xcode versione 6.1 (6A1052d) che spero migliorerà con le versioni future.

Il problema si ripresenta di tanto in tanto, la stessa soluzione funziona ogni volta. Immagino che un'altra soluzione sarebbe quella di restare con la versione precedente di Xcode 6.1 (6A1030) ma non funzionerà con i dispositivi con iOS 8.1 e non avrà le ultime correzioni di bug.

L'ho provato con Xcode 8.3.3. Ecco i miei risultati:

Puoi scrivere codice Swift perfettamente corretto che causerà il blocco dell'indicizzazione.

Una volta che l'indicizzazione si blocca, si blocca. Cambiare il codice Swift in qualcosa che non causerebbe il blocco dell'indicizzazione non aiuta, si blocca ancora.

Chiudere il progetto e riaprirlo non aiuta in quella situazione.

Uscire da Xcode e riavviarlo aiuta. L'indicizzazione non si bloccherà più (cioè se hai cambiato il codice in qualcosa che non lo blocca).

Anche il riavvio del Mac aiuta, sebbene non sia necessario.

L'impiccagione è causata da un codice Swift perfettamente corretto. Un esempio che mi era sembrato

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

L'indicizzazione si bloccherebbe. Ho commentato la maggior parte dei "??" ed è andato tutto bene (dopo aver chiuso e riavviato Xcode). Non commentato una riga dopo l'altra. Con un certo numero di righe andava bene, quindi rimuovere il commento dalla riga successiva l'avrebbe bloccata.

L'unica cosa che a quanto pare aiuta è cambiare il codice.

Sul mio Xcode la soluzione era chiudere tutte le finestre ridondanti. Per qualche motivo molte finestre aperte rendono Xcode molto lento.

Infine, ho "risolto" il problema, anche se è solo una soluzione alternativa.

Ho creato un altro progetto e ho aggiunto i file uno per uno. Quindi ho individuato un file viewcontroller.swift "molto lungo". Quindi ho suddiviso i suoi codici in moduli e ho trasformato quei codici usati ripetutamente in funzioni in un altro file rapido. Inoltre, ho preso online il suggerimento che le espressioni lunghe dovrebbero essere suddivise in quelle più brevi. Quindi, l'indicizzazione funziona e la compilazione funziona.

Quindi per ora ho "risolto".

MA, non penso che sia giusto. L'IDE Xcode dovrebbe essere più che in grado di gestire il mio file swift "molto lungo", solo 1500 righe. Credo che questo sia sicuramente un bug (esistente da molto tempo), sebbene Xcode 6.1 sia già un aggiornamento da Xcode 6.0.1.

Per quanto mi riguarda, ho eliminato l'app Xcode, l'ho scaricata di nuovo e installata. Questo ha risolto il problema, almeno adesso.

Indicizzazione Xcode di solito per il tuo codice per suggerimenti e completamento automatico tra le altre cose come aiutarti negli storyboard e viceversa. Ma per rendere più veloce il tuo progetto xcode puoi spegnerlo / riaccenderlo tramite terminale

Disattiva l'indicizzazione
valori predefiniti di scrivi com.apple.dt.XCode IDEIndexDisable 1 Attiva i valori predefiniti di indicizzazione scrivi com.apple.dt.XCode IDEIndexDisable 0

Ma un approccio migliore per utilizzare un Mac veloce con una buona RAM.

Se non ti dispiace tornare alla 6.0.1 finché non lo capiscono, è quello che ha funzionato per me. Avevo lo stesso problema sia con 6.1 che con 6.1.1. Adesso sto bene. Proverò la 6.2 quando uscirà.

Puoi trovare le versioni precedenti del software Apple sul loro sito di sviluppo ufficiale, qui: https://developer.apple.com/downloads/index.action

In tal caso, assicurati di eliminare prima la copia corrente di Xcode.

Sto usando Xcode 6.1.1 con file swift sullo stesso identico MacBook Pro.

Mentre continuavo ad aggiungere righe in un array di stringhe 3D, Xcode è diventato improvvisamente inutilizzabile e ora non posso fare nulla.

Proverò a tornare alla 6.1 e si spera che il problema scompaia.

Lo vedo in Xcode 6.3.2. Avevo davvero sperato che un anno dopo il rilascio, avrebbero fatto funzionare il compilatore, ma purtroppo.

Se nessuna delle soluzioni di cui sopra funziona, prova a controllare il codice per errori sintattici. Nel processo di refactoring, ho estratto una chiusura ma ho dimenticato di qualificare i parametri:

    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 ho imparato qualcosa lavorando in Swift, è lavorare in modo incrementale, per evitare di dover tornare indietro troppo per trovare il codice offensivo.

1. Il tuo stato di indicizzazione è un "cerchio indicatore" o una "barra di avanzamento"?
2. Se è un "cerchio indicatore", significa che è già bloccato all'inizio.
3. Apri e controlla con gli altri tuoi progetti, se sono tutti uguali, significa che è un problema di sistema.
4. Riavvia il computer e tutto andrà bene.

Uso Xcode 8.2 e anche questo problema è finito. È iniziato dopo che ho definito una variabile di tupla complessa: un array di tupla con sottoarray di tuple. Le cose diventano molto lente quando il sottoarray della tupla ha una proprietà calcolata a livello di codice.

Come notato da altre risposte, l'indicizzazione richiede un'eternità e credo che stia cercando di dedurre i tipi della variabile.

Ho risolto il problema prima definendo chiaramente la variabile con i tipi inclusi. Quando aggiorno la proprietà, la calcolo prima e poi la assegno alla tupla, invece di calcolare nella definizione della variabile.

Ecco un esempio di codice.

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

La linea di fondo è che non lasciate che Xcode deduca strutture complesse.

Stavo avendo lo stesso problema. Il mio Xcode è 8.2.1. Ma nel mio caso, volevo creare un array di dizionario con 33 coppie chiave-valore. Stavo facendo nel modo seguente che era bloccato nell'indicizzazione:

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

Di seguito ha funzionato per me:

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

Ho riscontrato anche questo problema e l'ho risolto rimuovendo / modificando le espressioni con l'operatore "+".

Ho cambiato questo:

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

A questa:

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

Ha risolto il problema.

La mia macchina è un MBP al massimo alla fine del 2013

Potresti voler aggiornare a Xcode 6.1.1

È stato ufficialmente rilasciato e risolto per noi il problema dell'indicizzazione. Nella descrizione dell'aggiornamento, si dice che hanno applicato correzioni di stabilità, quindi è molto probabile che si comporterà in modo più stabile.

La beta di Xcode 6.2 ha risolto il problema per me. Non fulminea, ma almeno non si indicizza per sempre. La beta no installa sopra la normale installazione di Xcode, quindi se non ti piace la beta, puoi semplicemente eliminarla.

Vari download di Xcode inclusa la beta>

Avevo espressioni come:

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

anche

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

Quindi il punto è riscrivere il file in modo che contenga solo espressioni a livello di scuola materna e il problema di indicizzazione scomparirà.

Xcode 11.5 (11E608c) e sempre gli stessi problemi, 6 anni dopo la domanda originale. Vorrei poter "contrassegnare" la mela in questa domanda in modo che possano vedere questo pasticcio. Questo è un progetto di grandi dimensioni (> 1000 file) ed ero sotto il tempo, quindi quando ho notato l'indice di congelamento ero con più di 100 file modificati e non posso tornare indietro.

Ho provato di tutto:

1. cancellare i dati derivati ​​e costruire
2. Riavvia xcode, riavvia mac
3. rimuovere e aggiungere fonte
4. Ricerca di dizionari letterali ecc. Ecc

Il problema era la creazione di un 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")]

Ciò che mi ha aiutato a scoprire il file swift danneggiato è stato quando xcode ha bloccato l'indicizzazione e ho eseguito i seguenti passaggi

1. apri monitor attività -> processo "rapido" -> mostra informazioni sul processo -> apri file e porte. Questo ti darà un elenco di quali file sta eseguendo questo processo, approfondendo l'elenco dei possibili file danneggiati
2. Un altro strumento utile è questo script SOURCEKIT_LOGGING=3 /Applications/Xcode.app/Contents/MacOS/Xcode &> ~/Documents/xcode.log che avvierà Xcode con livello 3 dettagliato e inizierà ad accedere al file di registro.
3. Cerca nel file di registro le ultime voci per i tuoi file swift es: "my_project / Source / App /"

Non è una soluzione completa, ma è utile approfondire e sapere dove cercare.