Swift XCode Index Freezing ou Slow

Peut-être que c’est juste moi qui expérimente une telle “fonctionnalité” ennuyeuse:

Après la mise à niveau de Xcode 6.0.1 vers Xcode 6.1, les choses ont changé. Xcode 6.1 indexe toujours le projet ou comstack les fichiers source. Le projet n’est pas énorme. Il contient juste un tas de fichiers Swift et AWS SDK 2.0 Cocoapods dans l’espace de travail. Je ne pense pas que cela devrait empêcher le tout d’indexer et de comstackr en douceur. J’ai essayé avec quelques échantillons aws-sdk-ios, juste pour voir comment Xcode 6.1 fonctionne sur eux, et il a fini dans la même attente pour toujours.

Quelles solutions j’ai essayé jusqu’à présent:

  1. Suppression de “données dérivées” dans l’organiseur et réouverture et espace de travail. (échec à réparer)
  2. “Afficher le contenu du package” sur le fichier .xcodeproj et supprimer .xcworkspace comme dans ( Xcode 4 – performance lente )

Aucun d’entre eux n’a travaillé, malheureusement.

Une idée? Ou des expériences similaires?

PS je devrais peut-être essayer de recréer le projet? Paramètres de mon ordinateur: MacBook Pro (Retina, 13 pouces, mi-2014), mémoire 8 Go 1600 MHz DDR3, avec Yosemite. (Je pense que cela suffit pour faire fonctionner ce petit projet.)

    J’ai essayé plusieurs des suggestions ci-dessus, notamment le fractionnement de fichiers, l’installation de Xcode 6.2 bêta et la rupture d’instructions de concaténation de chaînes. Ce qui l’a finalement fait pour moi était de diviser un tableau de déclaration littérale de dictionnaires que j’utilisais pour les données de test en plusieurs instructions .append .

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

    En outre, pour ce que cela vaut, la 6ème entrée de ce tableau est la cause du problème pour moi; cinq fonctionne très bien.

    La seule solution qui fonctionne pour moi est de supprimer toutes les données dérivées (pas seulement pour le projet en cours, il suffit de nettoyer tout le dossier) puis de redémarrer Xcode.

    1. Ouvrir Fichier / Préférences dans Xcode

    2. Cliquez sur Emplacements à l’extrême droite de la fenêtre contextuelle

    3. Cliquez sur la petite icône en forme de flèche à côté de “/Users/Mac/Library/Developer/Xcode/DerivedData”….. vous amène à un dossier Xcode contenant un dossier DerivedData (qui contient toutes les données dérivées de vos projets précédents .)

    4. SUPPRIMER le dossier DerivedData

    Utilisez-vous CocoaPods? J’ai rencontré le même problème plus tôt aujourd’hui. (En utilisant xCode 6.1.1)

    Pour résoudre le problème, j’ai tout supprimé dans ~/Library/Developer/Xcode/DerivedData , le dossier Pods dans le répertoire de mon projet et .xcworkspace .

    J’ai ensuite ouvert le terminal, navigué dans le répertoire de mon projet et exécuté à nouveau pod install .

    Eu le même problème aujourd’hui. Xcode 6.3.2, projet Swift de taille moyenne. À un moment donné, il a commencé à indexer et il ne terminerait jamais l’indexation. Le code à l’origine de cette erreur était un dictionnaire de type [Ssortingng: [Ssortingng]], donc un dict de chaîne de caractères avec des tableaux de chaînes en tant que valeurs. J’en ai eu deux avec des touches de A à Z et chacune de ces 26 entrées contient un tableau de chaînes de 5 à 10 chaînes.

    Effacer les données dérivées n’a pas aidé. Seulement commenter ces dicts a fait repartir.

    Honnêtement, c’est ridicule! Apple doit réparer Xcode! C’est déjà horriblement lent lors de la compilation de projets Swift, mais des bugs comme celui-ci constituent un obstacle. Je ne peux pas faire mon travail correctement avec ça!

    Pour ceux qui ont encore ce problème, il s’agit d’une solution de contournement que j’apprécie et qui vous empêche de saisir les objects un par un:

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

    Pour moi, j’ai essayé tout ce qui précède sans succès; mais tout ce que j’avais à faire était de supprimer le dossier de données dérivé, puis d’ouvrir un autre projet au hasard, d’attendre qu’il indexe et maintenant mon projet original (défectueux) fonctionne!

    Est-ce que le monde du développement est une pomme de faveur et que vos compilateurs rapides sont des sources ouvertes – alors nous ne sums pas tous contrariés par votre incompétence.

    J’utilise la version 7.3 de Xcode (7D175)

    Je pense que je pourrais avoir compris un problème sous-jacent. Là où deux cas où je suis resté coincé dans la phase d’indexation:

    • J’ai créé une fermeture que j’ai assignée à une variable et j’ai omis la signature de type. Je pense que xcode a eu des problèmes avec cette étape d’inférence de type. Si je me souviens bien, l’un des arguments était un CGPoint, qui a un constructeur surchargé. Mon hypothèse est que là, trop de possibilités de ce que ma fermeture pourrait accepter comme arguments.

    • J’ai refait une méthode de fabrique telle qu’au lieu de renvoyer des instances d’un type, elle pourrait renvoyer des instances de plusieurs types avec une classe de base commune. Il semble que partout où j’ai utilisé la méthode factory, j’ai dû convertir l’object résultant en un type spécifique (avec as? Ou en l’assignant à une variable qui accepte un type spécifique). Là encore, l’étape d’inférence de type semble être rompue.

    Il semble que la même chose se passe avec les déclarations de dictionnaires mentionnées par les individus précédents. J’ai déposé un rapport de bogue avec apple.

    J’ai rencontré le même problème après la mise à niveau vers 6.1. Xcode serait bloqué lors de la compilation ou de l’indexation sans générer de message d’erreur spécifique.

    Le problème a finalement été résolu en décomposant certaines des expressions les plus longues des fichiers rapides en plusieurs expressions plus courtes. Une partie de mon programme combine plusieurs variables de chaîne différentes pour former une chaîne plus longue. Les tentatives de les combiner dans une seule expression et en utilisant l’opérateur d’affectation par addition ont échoué. J’ai pu le faire fonctionner en faisant quelque chose de similaire à ce qui suit (simplifié):

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

    J’ai eu cette idée de recevoir l’erreur suivante plusieurs fois dans la version précédente de Xcode “L’expression était trop complexe pour être résolue dans un délai raisonnable; envisagez de diviser l’expression en sous-expressions distinctes.”

    J’espère que cela t’aides

    J’ai eu du mal avec le même problème. J’ai essayé les deux solutions mentionnées (suppression des données dérivées et suppression de .xcworkspace) sans succès. J’ai aussi essayé lentement de commenter petit à petit la plupart du code et de supprimer les fichiers jusqu’à ce qu’il ne rest presque plus rien et que l’indexation soit toujours bloquée.

    J’ai trouvé une solution qui a fonctionné pour moi, j’ai ouvert le projet avec une ancienne version Xcode 6.1 (6A1030) qui n’avait aucun problème d’indexation, puis je suis revenu à la dernière version Xcode 6.1 (6A1052d) que j’utilisais auparavant et à l’indexation fixe et continue de bien fonctionner.

    Ma conclusion est qu’il s’agit d’un bogue avec la version 6.1 de Xcode (6A1052d) qui, je l’espère, s’améliorera avec les futures versions.

    Le problème revient de temps en temps, le même correctif fonctionne à chaque fois. Je suppose qu’une autre solution consisterait simplement à conserver l’ancienne version Xcode 6.1 (6A1030), mais elle ne fonctionnerait pas avec les appareils exécutant iOS 8.1 et elle ne comporterait pas les dernières corrections de bogues.

    Enfin, j’ai “résolu” le problème, même si ce n’est qu’une solution de contournement.

    J’ai créé un autre projet et y ai ajouté des fichiers un par un. Ensuite, j’ai repéré un fichier “très long” viewcontroller.swift. Ensuite, j’ai cassé ses codes en modules et les ai utilisés à plusieurs resockets dans des fonctions dans un autre fichier rapide. Et aussi, j’ai pris la suggestion en ligne que l’expression longue devrait être divisée en courtes. Ensuite, l’indexation fonctionne et la compilation fonctionne.

    Donc pour l’instant, je l’ai “résolu”.

    MAIS, je ne pense pas que ce soit correct. Xcode IDE devrait être plus que capable de gérer mon fichier “très long”, seulement 1500 lignes. Je pense que c’est certainement un bug (existant depuis longtemps), bien que Xcode 6.1 soit déjà une mise à jour de Xcode 6.0.1.

    Pour moi, j’ai supprimé l’application Xcode et l’ai téléchargée à nouveau pour l’installer. Cela a résolu le problème, au moins pour le moment.

    Sur mon Xcode, la solution consistait à fermer toutes les fenêtres redondantes. Pour certaines raisons, de nombreuses fenêtres ouvertes ralentissent XCode.

    Indexation Xcode généralement pour votre code pour des suggestions et auto-complétez entre autres choses comme vous aider dans les story-boards et vice versa. Mais pour accélérer votre projet xcode, vous pouvez le désactiver / activer via un terminal

    Désactiver l’indexation
    écriture par défaut com.apple.dt.XCode IDEIndexDisable 1 Activer les valeurs d’indexation par défaut write com.apple.dt.XCode IDEIndexDisable 0

    Mais mieux vaut utiliser un mac rapide avec une bonne mémoire vive.

    Je l’ai essayé avec Xcode 8.3.3. Voici mes résultats:

    Vous pouvez écrire du code Swift parfaitement fin pour bloquer l’indexation.

    Une fois l’indexation suspendue, elle se bloque. Changer le code Swift à quelque chose qui ne provoquerait pas le blocage de l’indexation n’aide pas, il se bloque toujours.

    La fermeture du projet et la réouverture n’aident pas dans cette situation.

    Quitter Xcode et le redémarrer aide. L’indexation ne sera plus bloquée (c’est-à-dire si vous avez modifié le code pour qu’il ne soit plus bloqué).

    Le redémarrage de votre Mac est également utile, bien que cela ne soit pas nécessaire.

    La pendaison est causée par un code Swift parfaitement fin. Un exemple que j’avais ressemblé

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

    L’indexation serait suspendue. J’ai commenté la plupart des “??” lignes et c’était bien (après avoir quitté et relancer Xcode). Décommenté une ligne après l’autre. Avec un certain nombre de lignes, c’était bien, alors décommenter la ligne suivante le ferait se bloquer.

    La seule chose qui aide apparemment change votre code.

    J’ai aussi eu ce problème et l’ai résolu en supprimant / changeant les expressions avec l’opérateur “+”.

    Je jure de changer cela:

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

    Pour ça:

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

    résolu le problème. Je me rends compte que cela semble fou mais c’était vrai pour moi.

    Ma machine est un MBP à la fin de l’année 2013

    Le Xcode 6.2 beta a résolu le problème pour moi. Pas rapide comme l’éclair, mais au moins, il n’est pas indexé pour toujours. La version bêta ne s’installe pas par-dessus votre installation Xcode habituelle, donc si vous n’aimez pas la version bêta, vous pouvez simplement la supprimer.

    Divers téléchargements Xcode, y compris la version bêta>

    Vous pouvez souhaiter mettre à jour vers Xcode 6.1.1

    Il a été officiellement publié et a résolu pour nous le problème de l’indexation. Dans la description de la mise à jour, il est indiqué que des correctifs de stabilité ont été appliqués. Il est donc très probable qu’il se comportera de manière plus stable.

    Je vous souhaite bonne chance avec cette saga!

    Si cela ne vous dérange pas de revenir à la version 6.0.1 jusqu’à ce que les choses se passent, c’est ce qui a fonctionné pour moi. J’avais le même problème avec 6.1 et 6.1.1. Maintenant je vais bien. Je vais essayer 6.2 quand il sortira.

    Vous pouvez trouver les versions précédentes des logiciels Apple sur leur site de développement officiel, ici: https://developer.apple.com/downloads/index.action

    Si vous faites cela, assurez-vous de supprimer votre copie actuelle de Xcode en premier.

    J’utilise Xcode 6.1.1 avec des fichiers rapides sur le même MacBook Pro.

    Comme je continuais à append des lignes dans un tableau de chaînes 3D, Xcode est soudain devenu inutilisable et je ne peux plus rien faire.

    Je vais essayer de revenir à 6.1 et j’espère que le problème disparaîtra.

    Je le vois dans Xcode 6.3.2. J’avais vraiment espéré qu’un an après la sortie, le compilateur fonctionnerait, mais hélas.

    Si aucune des solutions ci-dessus ne fonctionne, essayez de rechercher des erreurs de syntaxe dans votre code. En cours de refactoring, j’ai extrait une fermeture mais j’ai oublié de qualifier les parameters:

      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 } 

    Si j'ai appris quelque chose en travaillant dans Swift, c'est pour travailler de manière incrémentale, pour éviter de trop faire marche arrière pour trouver le code incriminé.

    1. Votre statut d’indexation est-il un “cercle indicateur” ou une “barre de progression”?
    2. S’il s’agit d’un “cercle indicateur”, cela signifie qu’il est déjà bloqué au début.
    3. Ouvrez et vérifiez avec vos autres projets, s’ils sont identiques, cela signifie qu’il s’agit d’un problème système.
    4. Il suffit de redémarrer votre ordinateur et tout ira bien.

    J’utilise Xcode 8.2 et j’ai aussi fini avec ce problème. Il a commencé après avoir défini une variable de tuple complexe – un tableau de tuple avec sous-tableau de tuple. Les choses deviennent vraiment lentes lorsque le sous-tableau de tuple a une propriété qui est calculée par programme.

    Comme d’autres réponses l’ont noté, l’indexation prend une éternité, et j’estime qu’elle essaie de déduire les types de la variable.

    J’ai d’abord résolu le problème en définissant clairement la variable avec les types inclus. Lors de la mise à jour de la propriété, je la calcule d’abord puis l’assigne au tuple, au lieu de calculer en définissant la variable.

    Voici un exemple de code.

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

    L’essentiel est de ne pas laisser Xcode en déduire des structures complexes.

    J’avais le même problème. Mon xCode est 8.2.1. Mais dans mon cas, je voulais créer un tableau de dictionnaire avec 33 paires clé-valeur. Je faisais comme suit qui était coincé dans l’indexation:

      var parameter = [Ssortingng : 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) } 

    Après a travaillé pour moi:

     var parameter = [Ssortingng : 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) }