Swift XCode Index Congelación o lento

indexing osx-yosemite (23)

Tal vez esto es solo yo experimentando una "característica" tan molesta:

Después de actualizar de Xcode 6.0.1 a Xcode 6.1, las cosas cambiaron. Xcode 6.1 siempre indexa el proyecto o compila los archivos fuente. El proyecto no es muy grande. Solo contiene un grupo de archivos Swift y AWS SDK 2.0 Cocoapods en el área de trabajo. No creo que deba evitar que el conjunto indexe y compile sin problemas. Intenté con algunos aws-sdk-ios-samples, solo para ver cómo Xcode 6.1 funciona en ellos, y terminó en la misma espera de siempre.

Qué soluciones he intentado hasta ahora:

Eliminar "Datos derivados" en el Organizador, y volver a abrir y espacio de trabajo. (no corregir)
"Mostrar contenido del paquete" en el archivo .xcodeproj y eliminar .xcworkspace como en ( Xcode 4 - rendimiento lento )

Ninguno de ellos funcionó, desafortunadamente.

¿Alguna idea? O alguna experiencia similar?

PD tal vez debería intentar volver a crear el proyecto? La configuración de mi computadora: MacBook Pro (Retina, 13 pulgadas, mediados de 2014), memoria 8 GB 1600 MHz DDR3, con Yosemite. (Creo que esto es suficiente para ejecutar este pequeño proyecto).

¿Su estado de indexación es un "círculo indicador" o "barra de progreso"?
Si se trata de un "círculo indicador", eso significa que ya está bloqueado al principio.
Abra y consulte con sus otros proyectos, si son todos iguales, eso significa que es un problema del sistema.
Simplemente reinicie su computadora y todo estará bien.

¿Estás usando CocoaPods? Me encontré con el mismo problema el día de hoy. (Usando xCode 6.1.1)

Para solucionar el problema, eliminé todo en ~/Library/Developer/Xcode/DerivedData , la carpeta Pods en el directorio de mi proyecto y <project>.xcworkspace .

Luego abrí el terminal, navegué hasta el directorio de mi proyecto y pod install .

El Xcode 6.2 beta resolvió el problema para mí. No es muy rápido, pero al menos no está indexando para siempre. La versión beta no se instala en la parte superior de su instalación regular de Xcode, por lo que si no le gusta la versión beta, puede simplemente eliminarla.

Varias descargas de Xcode, incluida la versión beta>

En mi Xcode, la solución fue cerrar todas las ventanas redundantes. Por alguna razón, muchas ventanas abiertas hacen que XCode sea muy lento.

Es posible que desee actualizar a Xcode 6.1.1

Se ha lanzado oficialmente y se resolvió para nosotros el problema de indexación. En la descripción de la actualización, dice que han aplicado arreglos de estabilidad, por lo que es muy probable que se comporte de una manera más estable.

¡Te deseo suerte con esta saga!

Estaba teniendo el mismo problema. Mi código x es 8.2.1. Pero en mi caso, quería crear una matriz de diccionario con 33 pares clave-valor. Lo estaba haciendo de la siguiente manera, que estaba estancada en la indexación:

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

Lo siguiente funcionó para mí:

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

Estoy usando Xcode 6.1.1 con archivos rápidos en la misma MacBook Pro exacta.

A medida que continuaba agregando filas en una matriz de cadenas 3D, Xcode de repente se volvió inutilizable y ahora no puedo hacer nada.

Tratará de volver a 6.1 y con suerte el problema desaparecerá.

Estoy usando Xcode Version 7.3 (7D175)

Creo que podría haber descubierto un problema subyacente. Hubo dos casos en los que me quedé atrapado en la fase de indexación:

Creé un cierre que asigné a una variable y omití la firma de tipo. Creo que xcode tuvo problemas con ese tipo de paso de inferencia. Si mal no recuerdo, uno de los argumentos fue un CGPoint, que tiene un constructor sobrecargado. Mi hipótesis es que hay demasiadas posibilidades de lo que mi cierre podría aceptar como argumentos.
Refactoré un método de fábrica para que, en lugar de devolver instancias de un tipo, pudiera devolver instancias de muchos tipos con una clase base común. Parece que cada vez que utilicé el método de fábrica, tuve que convertir el objeto resultante a un tipo específico (ya sea con as? O asignándolo a una variable que acepta un tipo específico) De nuevo, el paso de inferencia de tipo parece estar roto.

Parece que sucede lo mismo con las declaraciones del diccionario mencionadas por individuos anteriores. Archivé un informe de error con Apple.

Estoy viendo esto en Xcode 6.3.2. Realmente había esperado que un año después del lanzamiento, tendrían el compilador funcionando, pero por desgracia.

Si ninguna de las soluciones anteriores funciona, intente verificar si hay errores sintácticos en su código. En el proceso de refactorización, extraje un cierre pero olvidé calificar los 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 }

Si he aprendido algo al trabajar en Swift, es trabajar de forma incremental, para evitar tener que retroceder demasiado para encontrar el código ofensivo.

Experimenté este mismo problema después de actualizar a 6.1. Xcode se quedaría atrapado compilando o indexando sin generar un mensaje de error específico.

El problema finalmente se resolvió al dividir algunas de las expresiones más largas en los archivos rápidos en varias expresiones más cortas. Parte de mi programa combina muchas variables de cadena para formar una cadena más larga. Los intentos de combinarlos en una sola expresión y usar el operador de asignación de suma fallaron. Pude hacer que funcione haciendo algo similar a lo siguiente (simplificado):

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

Recibí esta idea al recibir el siguiente error muchas veces en la versión anterior de Xcode "La expresión era demasiado compleja para ser resuelta en un tiempo razonable, considere dividir la expresión en distintas expresiones secundarias".

Espero que esto ayude

Finalmente, "resolví" el problema, aunque es solo una solución.

Creé otro proyecto y agregué archivos uno por uno a él. Luego vi un archivo "muy largo" viewcontroller.swift. Luego rompí sus códigos en módulos y convertí esos códigos repetidamente usados en funciones en otro archivo veloz. Y también, tomé la sugerencia en línea de que la expresión larga se dividiera en otras más cortas. Luego, la indexación funciona y la compilación funciona.

Así que por ahora, lo tengo "resuelto".

PERO, no creo que esto sea correcto. Xcode IDE debería ser más que capaz de manejar mi archivo rápido "muy largo", solo 1500 líneas. Creo que esto definitivamente es un error (que existe desde hace mucho tiempo), aunque Xcode 6.1 ya es una actualización de Xcode 6.0.1.

He intentado esto con Xcode 8.3.3. Aquí están mis resultados:

Puede escribir perfectamente el código Swift que hará que la indexación se cuelgue.

Una vez que la indexación se bloquea, se cuelga. Cambiar el código de Swift a algo que no haría que la indexación se cuelgue no ayuda, todavía se cuelga.

Cerrar el proyecto y volver a abrir no ayuda en esa situación.

Salir de Xcode y reiniciarlo ayuda. La indexación ya no se bloqueará (es decir, si cambió el código a algo que no lo cuelga).

Reiniciar tu Mac también ayuda, aunque no es necesario.

El ahorcamiento es causado por un código Swift perfectamente fino. Un ejemplo que me había parecido

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

La indexación se cuelga. Comenté la mayoría de los "??" líneas y estaba bien (después de salir y relanzar Xcode). Sin comentar una línea después de la otra. Con algunas líneas, estaba bien, luego sin comentarios, la siguiente línea lo colgaría.

Lo único que ayuda aparentemente es cambiar tu código.

He luchado con el mismo problema. Probé las dos soluciones mencionadas (eliminar datos derivados y eliminar .xcworkspace) sin éxito. También intenté comentar lentamente la mayor parte del código poco a poco y eliminar los archivos hasta que casi no quedaba nada y la indexación todavía estaba atascada.

Encontré una solución que funcionó para mí, abrí el proyecto con una Xcode versión 6.1 anterior (6A1030) que no tenía problemas de indexación y luego volví a la última versión de Xcode 6.1 (6A1052d) que estaba usando antes y la indexación era arreglado y continuó trabajando bien.

Mi conclusión es que este es un error con Xcode versión 6.1 (6A1052d) que espero mejore con lanzamientos futuros.

El problema vuelve de vez en cuando, el mismo arreglo funciona cada vez. Creo que otra solución sería quedarse con la Xcode versión 6.1 anterior (6A1030), pero no funcionará con dispositivos con iOS 8.1 y no tendrá las últimas correcciones de errores.

La única solución de trabajo para mí es eliminar todos los datos derivados (no solo para el proyecto actual, simplemente limpiar toda la carpeta) y luego reiniciar Xcode.

Abrir archivo / Preferencias en Xcode
Haga clic en Ubicaciones en el extremo derecho de la ventana emergente
Haga clic en el pequeño icono de flecha al lado de "/Users/Mac/Library/Developer/Xcode/DerivedData"....it lo lleva a una carpeta Xcode que contiene una carpeta DerivedData (que contiene todos los datos derivados de sus proyectos anteriores) .)
ELIMINAR la carpeta DerivedData

La indexación de Xcode suele incluir sugerencias para su código y autocompletarlo, entre otras cosas, como ayudarlo en story boards y viceversa. Pero para hacer que su proyecto xcode sea más rápido, puede apagarlo / encenderlo a través del terminal

Desactivar indexación
valores predeterminados write com.apple.dt.XCode IDEIndexDisable 1 Active los valores predeterminados de indexación write com.apple.dt.XCode IDEIndexDisable 0

Pero mejor enfoque para usar un Mac veloz con buena RAM.

Para aquellos que aún tienen este problema, esta es una solución que he disfrutado y que evita tener que ingresar los objetos uno por 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])

Para mí, eliminé la aplicación Xcode y la descargué nuevamente e instálela. Eso resolvió el problema, al menos ahora.

Para mí, intenté todo lo anterior sin éxito; pero todo lo que tuve que hacer fue eliminar la carpeta de datos derivados, luego abrir otro proyecto aleatorio, esperar a que indexe y ¡ahora funciona mi proyecto original (mal funcionamiento)!

Haz que el mundo del desarrollo sea un favorito de las manzanas y haz que tus veloces compiladores sean de código abierto, para que no nos veamos frustrados por tu incompetencia.

Si no te importa volver a 6.0.1 hasta que lo resuelvan, eso es lo que funcionó para mí. Estaba teniendo el mismo problema con 6.1 y 6.1.1. Ahora estoy bien. Trataré de 6.2 cuando salga.

Puede encontrar versiones anteriores del software de Apple en su sitio oficial de desarrollo, aquí: https://developer.apple.com/downloads/index.action

Si haces esto, asegúrate de eliminar tu copia actual de Xcode primero.

También tuve este problema y lo resolví eliminando / cambiando expresiones con el operador "+".

Juro cambiar esto:

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

A esto:

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

resuelve el problema. Me doy cuenta de que suena loco, pero fue cierto para mí.

Mi máquina está al máximo de MBP a finales de 2013

Tuve el mismo problema hoy. Xcode 6.3.2, proyecto Swift de tamaño mediano. En un momento dado comenzó a indexar y nunca terminaría de indexar. El código que causó esto fue un diccionario de tipo [String: [String]], por lo que una cadena de caracteres dict con matrices de cadenas como valores. Tenía dos de estos con claves de la A a la Z y cada una de estas 26 entradas contiene una matriz de cadenas con 5 a 10 cadenas.

La eliminación de los datos derivados no ayudó. Solo comentar esos dictados lo hizo funcionar nuevamente.

Honestamente, esto es ridículo! ¡Apple necesita arreglar Xcode! Ya es terriblemente lento cuando se compilan proyectos de Swift, pero los errores como este son sorprendentes. ¡No puedo hacer bien mi trabajo con esto!

Yo uso Xcode 8.2 y también terminé en este problema. Comenzó después de que definí una variable de tupla compleja: una matriz de tupla con subcampo de tupla. Las cosas se vuelven realmente lentas cuando el subcampo de la tupla tiene una propiedad que se calcula mediante programación.

Como se señaló en otras respuestas, la indexación lleva mucho tiempo, y creo que está tratando de inferir los tipos de la variable.

Primero resolví el problema definiendo claramente la variable con los tipos incluidos. Al actualizar la propiedad, primero la calculo y luego la asigno a la tupla, en lugar de calcularla al definir la variable.

Aquí hay un código de ejemplo.

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 conclusión es que no permita que Xcode infiera estructuras complejas.

Intenté muchas de las sugerencias anteriores, incluida la división de archivos, la instalación de Xcode 6.2 beta y las declaraciones de concatenación de cadena de bits. Lo que finalmente hizo por mí fue dividir una declaración literal de un conjunto de diccionarios que estaba usando para los datos de prueba en múltiples declaraciones .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" ])

Además, por lo que vale, la sexta entrada en este conjunto es lo que me causa el problema; cinco funciona bien.