Errore di segmentazione rapida del compilatore durante la creazione

L'aggiunta di una (comoda) heightproprietà calcolata al UIViewmio UIViewExtension.swiftfile sta causando il segfault del compilatore Swift ... Cosa potrebbe andare storto qui?

0  swift                    0x00000001061e5608 llvm::sys::PrintStackTrace(__sFILE*) + 40
1  swift                    0x00000001061e5af4 SignalHandler(int) + 452
2  libsystem_platform.dylib 0x00007fff894da5aa _sigtramp + 26
3  libsystem_platform.dylib 0xb03939841e997c88 _sigtramp + 2504775416
4  swift                    0x00000001064c8bb9 swift::NominalTypeDecl::getMembers(bool) const + 41
5  swift                    0x00000001055efab9 swift::irgen::ClassMetadataLayout<(anonymous namespace)::FindClassMethodIndex>::addClassMembers(swift::ClassDecl*) + 329
6  swift                    0x00000001055e97b2 swift::irgen::emitVirtualMethodValue(swift::irgen::IRGenFunction&, llvm::Value*, swift::SILType, swift::SILDeclRef, swift::CanTypeWrapper<swift::SILFunctionType>, swift::ResilienceExpansion) + 434
7  swift                    0x00000001056550d3 swift::SILVisitor<(anonymous namespace)::IRGenSILFunction, void>::visit(swift::ValueBase*) + 42611
8  swift                    0x000000010564a266 swift::irgen::IRGenModule::emitSILFunction(swift::SILFunction*) + 8678
9  swift                    0x00000001055cb6f8 swift::irgen::IRGenModule::emitGlobalTopLevel() + 184
10 swift                    0x00000001056376e3 performIRGeneration(swift::IRGenOptions&, swift::Module*, swift::SILModule*, llvm::StringRef, llvm::LLVMContext&, swift::SourceFile*, unsigned int) + 1859
11 swift                    0x0000000105638033 swift::performIRGeneration(swift::IRGenOptions&, swift::SourceFile&, swift::SILModule*, llvm::StringRef, llvm::LLVMContext&, unsigned int) + 51
12 swift                    0x00000001055aa65a frontend_main(llvm::ArrayRef<char const*>, char const*, void*) + 4842
13 swift                    0x00000001055a935d main + 1533
14 libdyld.dylib            0x00007fff8a82e5fd start + 1

1.  While emitting IR SIL function @_TFCSo6UIViewg6heightSd for 'anonname=0x7ff422892fd0' at <path redacted>/UIViewExtension.swift:60:5
<unknown>:0: error: unable to execute command: Segmentation fault: 11
<unknown>:0: error: swift frontend command failed due to signal (use -v to see invocation)
Command /Applications/Xcode6-Beta.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift failed with exit code 254

Se sono necessarie ulteriori informazioni per risolvere questo problema, commenta. Grazie!

Modificare:

Ecco un .xcodeproj correlato che restituisce l'errore del compilatore di questa domanda. Scarica qui

Ho avuto questo errore perché stavo facendo questo:

if(currentMeal?.State == .Deleted){

}

invece di

if(currentMeal!.State == .Deleted){

}

quindi penso che un optional non scartato nella condizione if possa causare questo errore

Quando ti imbatti in un segfault del compilatore in Swift, non ottieni un numero di riga a portata di mano e un messaggio di errore. Ecco come puoi rintracciare il problema:

1. Crea un nuovo file chiamato SegFaultDebugger.swiftnel tuo progetto.
2. In questo nuovo file, definisci un'estensione per la classe che ti dà problemi.
3. Sposta un gruppo di metodi dal file principale a SegFaultDebugger.swift.
4. Compilare.

A questo punto, accade una delle tre cose:

• Hai ancora il segfault nel file originale : sposta i metodi dal SegFaultDebugger.swiftretro al file originale e sposta un diverso set di metodi in SegFaultDebugger.swift. Ripetere
• Ottieni un segfault inSegFaultDebugger.swift : Fantastico! Ora usa la ricerca binaria per fissare il segfault a un metodo specifico finché non riesci a capire quale costrutto lo sta causando.
• Ottieni errori significativi del compilatore : fantastico! Correggi gli errori. Una volta compilato tutto, riporta i metodi nel file originale.

Ho ricevuto questo errore durante l'estensione di uno dei miei protocolli e un argomento di tipo errato e facoltativo.

protocol SomeProtocolName: class {
    var someProtocolVariable: String { get set }

    func someProtocolFunction(someProtocolVariable: String)
}

// MARK:
extension SomeProtocolName {
    func someProtocolFunction(someProtocolVariable: String?) {
        self.someProtocolVariable = someProtocolVariable
    }
}

La differenza negli argomenti della funzione Stringnel prototipo e String?nell'estensione ha causato l' errore di segmentazione 11 .

Ho avuto anche questo errore e l'ho risolto in questo modo:

Controlla il tuo progetto e scopri quali file vengono utilizzati due volte e rimuovine uno, oppure eliminali e aggiungili di nuovo tutti.

Errori nel mio Xcode:

: 0: errore: nome file "AttributedString.swift" utilizzato due volte: "/Users/.../CNJOB/CNJOB/AttributedString.swift" e "/Users/.../CNJOB/CNJOB/AttributedString.swift"

: 0: nota: i nomi dei file sono usati per distinguere dichiarazioni private con lo stesso nome

: 0: errore: nome file "APIClient.swift" utilizzato due volte: "/Users/.../CNJOB/CNJOB/APIClient.swift" e "/Users/.../CNJOB/CNJOB/APIClient.swift"

: 0: nota: i nomi dei file sono usati per distinguere dichiarazioni private con lo stesso nome

Comando / Applications / Xcode 3.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swiftc non riuscito con codice di uscita 1

In Xcode 7, puoi fare clic sull'errore nel Navigatore di debug e ti verrà mostrata una vista espansa degli arresti anomali. Facendo clic sul pulsante dell'hamburger a destra si espande l'errore e se scorri fino in fondo al messaggio di errore espanso, vedrai da dove proviene.

Per me, ho avuto due di questi errori di segmentazione. Nell'immagine sopra, il primo è come appare quando è compresso, il secondo è quando espandi il pulsante dell'hamburger. Nella parte inferiore della casella grigia espansa, vedrai un messaggio che dice dove si è arrestato il compilatore.

Nota tuttavia che il messaggio di errore a volte potrebbe non essere abbastanza informativo, quindi mentre ti dice dove si è verificato l'arresto anomalo, non sempre dice perché e come risolverlo. Eliminare questo errore è ancora una questione di supposizioni.

Ho scoperto una semplice soluzione alternativa fino a quando il problema non viene risolto in una futura build Xcode / Swift:

• Posiziona semplicemente tutte le estensioni che causano il problema nel .swiftfile che viene utilizzato.

Nel progetto di esempio che hai fornito, inserisci il contenuto di UIViewExtension.swift e CALayerExtension.swift sopra AppDelegate.swift

Speriamo che questo possa portarci a scrivere codice Swift funzionante fino a quando il problema non sarà risolto.

Per quanto mi riguarda, aggiungendo privatea static var fixed clang crash:

private static var taskId = 0

Ho avuto un errore di segmentazione del compilatore su un'istruzione come questa:

someFunction(isFlagged ? "String1" : "String2")

Ho solo fatto un'istruzione if-else e funziona.

Puoi anche avere questo problema se dichiari una condizione con un Bool non imballato come proprietà

Nel mio caso, un colon fuori posto durante l'interpolazione delle stringhe ha rotto il mio (XCode 6.1.1).

Esempio:

println("\(value1:value2)") 

quando intendevo fare:

println("\(value1) : \(value2)")

Questo errore mi è successo quando ho provato a sovrascrivere la variabile debole dalla classe genitore.

Nella classe base:

weak var stripeViewDelegate : StripeViewDelegate? = nil    

Classe derivata:

override weak var stripeViewDelegate : StripeViewDelegate? = nil {
    didSet {
        self.stripeView.delegate = stripeViewDelegate

    }

L'errore è scomparso quando ho rimosso =nildalla classe derivata.

Oggi prendo qualche eccezione

class func createByAny(instance: Any?) -> ApiCollectionResponse { ... }

e questo lo ha risolto:

class func createByAny(instance: Any) -> ApiCollectionResponse { ... }

Perché il tipo "Any" è qualsiasi tipo di evento "nil", "AnyObject", opzionale, ... :) Non è opzionale, è già opzionale.

typealias Any = protocol<>

Questo errore si verifica anche se dichiari accidentalmente una variabile con un tipo che corrisponde al suo nome:

    var sectionGroup: sectionGroup? { ... }

Sono incappato in questo errore a causa di un tipo generico estraneo su una funzione operatore, ad es

func ==<T>(lhs: Foo, rhs: Foo) -> Bool {
  return lhs.bar == rhs.bar
}

Nel mio caso, la rimozione ha <T>risolto il problema.

Nel mio caso avevo dichiarato un structinterno a func. Spostando il filestruct al livello di classe ha risolto il problema.

Ora che scrivo questo ricordo di aver avuto problemi con i messaggi structinterni funcprima. Era qualcos'altro rispetto al difetto di segmentazione (che sembra diventare famoso con la beta di Swift 1.2). OMG Apple, cosa ci fai lì?

Nel mio caso, questo errore perché uso il nome della classe per la variabile

var MYClass : MYClass {
    get {
        return.....
    }
}

E questo risolve il mio problema

var myClass : MYClass {
    get {
        return.....
    }
}

Nel mio caso, questo è successo quando ho eseguito un'inizializzazione statica errata in un protocollo. Ho trovato un modo per aggirare, ma un compilatore non dovrebbe mai produrre un errore di segmentazione durante la costruzione.

Ci sono tre file coinvolti. Un protocollo NamedSegues.swift, un TableViewController personalizzato che tra le altre cose implementa il protocollo che contiene un callback, un TableViewCell personalizzato che contiene il riferimento a questo protocollo per chiamare il callback.

//file1
import Foundation
protocol NamedSegues {
    func  executeSegueWithId(id: String) -> Void
    static func getDefault() -> NamedSegues  // This was required because of init requirement in CustomCellView
}


//file2
class CustomController: UITableViewController, NamedSegues {
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
            let cell = tableView.dequeueReusableCellWithIdentifier("CustomCellID", forIndexPath: indexPath ) as! CustomCellView

        // Configure the cell...
       //App logic...

        cell.parent = self
}

 //Mark: NamedSegues
     func executeSegueWithId(id: String) ->() {
        NSLog("Received callback to execute segue: \(id)")
        //
    }

    static func getDefault() -> NamedSegues { // I think this must be where it threw up.
        return self as! NamedSegues
    }

}


//file3

import UIKit

class CustomCellView: UITableViewCell {

    var id: String = "NoName"
    var parent: NamedSegues = NamedSegues.getDefault() // This is where it was needed.


override func touchesBegan(touches: Set<NSObject>, withEvent event: UIEvent) {
        NSLog("Touched id: \(id)")


             parent.executeSegueWithId(id) // This is where parent was used.
     }
}

Ho aggirato usando?

Nel file del protocollo, file1: elimina la dichiarazione di getDefault () Nel file2 CustomController: elimina l'implementazione di getDefault. In CustomCellView, file3:

    var parent: NamedSegues?
    ...
    parent?.executeSegueWithId(id)

Il compilatore dovrebbe averlo rilevato e fornito un messaggio di errore invece di lanciare un errore di segmentazione durante la compilazione!

Sembra che il compilatore Swift 2 non fosse ancora pronto per la prima serata! Nel caso in cui questo aiuti qualcuno, stavo ricevendo un errore di segmentazione: 11 a causa di una mancata corrispondenza con il tipo di variabile in un'intestazione di chiusura, in particolare in un metodo Parse,PFQuery.query.findObjectsInBackgroundWithBlock .

Puoi vedere il problema in modo più dettagliato qui: https://github.com/ParsePlatform/Parse-SDK-iOS-OSX/issues/280

Come ha detto @Fjohn , questo era un problema relativo allo scartare un optional per me (rotto sia in Xcode 7.0 beta 6 che in Xcode 7). Nel mio caso, non stavo scartando l'opzionale dell'opzionale (ciò che mi ha avvisato era doppio ?? nel descrittore. Utilizzando if let risolto il problema

Come altri hanno scritto sopra, per me questo è accaduto quando utilizzo un'estensione su un protocollo ma la firma dei metodi nel protocollo non corrisponde alle implementazioni in un'estensione.

Nel mio caso, avevo aggiunto un nuovo parametro all'implementazione (nell'estensione) ma mi ero dimenticato di aggiungerlo anche alla firma del metodo nel protocollo.

nel mio caso, ho provato ad aggiungere un parametro di funzione dopo un parametro variadic.

Invertire la sequenza dei parametri e rendere il parametro variadico l'ultimo parametro nell'elenco dei parametri lo ha risolto.

Ciò accade in genere quando il compilatore non dispone di informazioni sufficienti (nonostante ciò che si pensa) per garantire / determinare lo stato di un'istruzione o di una variabile all'interno di un'istruzione.

Ad esempio, immagina di avere un dizionario di tipo [String: String] che inserisci con i nomi delle città come chiavi e un elenco separato da virgole di codici postali / codici postali corrispondenti.

Immagina di voler aggiornare da qualche parte nel tuo codice l'elenco dei codici corrispondenti:

myDict[town] += newZipCode + ","

In questo caso, il compilatore risponderà con un errore di segmentazione poiché townpotrebbe non essere presente nel dizionario e quindi non può garantire che l'istruzione precedente abbia un valore valido.

Per risolvere questo problema, è necessario memorizzare lo stato corrente di myDict[town]in una variabile separata che consente di gestire il caso di key not in dicte quindi aggiornare il valore per la chiave data:

myDict[town] = guaranteedValue + "," newZipCode + ","

Sfortunatamente, non è sempre semplice determinare la causa principale, quindi spero che questo semplice esempio sia d'aiuto.

Swift 3.0 (Xcode 8.1) presenta questo problema quando un protocollo dichiara una variabile opzionale e un implementatore implementa quella variabile come una variabile inizializzata pigra.

Il bug è segnalato qui: https://bugs.swift.org/browse/SR-1825

Xcode 8.2.

L'aggiunta @nonobjcdell'implementazione del protocollo all'estensione causa errori di segmentazione. Spostare l' @nonobjcimplementazione del protocollo nell'implementazione della classe.

Nel mio caso il colpevole stava sovraccaricando accidentalmente una funzione aspettandosi un argomento di matrice con uno con un argomento variadico :

public required init(_ args: Node...) {
}

Quando la superclasse l'ha definita come un array:

public required init(_ args: [Node]) {
}

Per me quanto segue ha causato un segfault mentre typeè un optional:

switch type {
    case .aType:
        // Do Something
    default:
        break
}

e questo lo ha risolto:

switch type {
    case .Some(.aType):
        // Do Something
    default:
        break
}

Ho ricevuto questo errore con la seguente firma del metodo in un UITableViewController personalizzato.

func filterContentForSearchText(searchText: String)

cambiando in:

func filterContentForSearchText(searchText: String!)

risolto il problema.

Ho avuto lo stesso problema in un'estensione. La mia estensione aveva due inizializzatori di convenienza:

convenience init(context: NSManagedObjectContext) {
    let entityDescription = NSEntityDescription.entityForName("PropertyEntity", inManagedObjectContext: context)!
    self.init(entity: entityDescription, insertIntoManagedObjectContext: context)
}

convenience init(dictionary: NSDictionary, context: NSManagedObjectContext) {
    self.init(context: context)
    property1 = (dictionary["key"] as? String) ?? ""
    // More properties...
}

Per eliminare l'errore ho aggiunto una mappa del metodo di istanza (dizionario: NSDictionary) e l'errore di errore di segmentazione è scomparso.

convenience init(dictionary: NSDictionary, context: NSManagedObjectContext) {
    self.init(context: context)
    map(dictionary)
}

Per me il problema era che le mie architetture non erano impostate sullo standard. Avevo aggiunto i386 o qualcosa del genere, basta impostarlo di nuovo sull'arch xcodeproject predefinito e compilato bene.

Ho avuto lo stesso problema in un progetto veloce. Il problema era una funzione che avrebbe dovuto restituire un oggetto, ma non aveva un ritorno in esso. Questo tipo di errore veniva segnalato durante l'editing con Obj-C. Sembra che non sia così in Swift.