Added generation for OptionSets and generated a few low-hanging fruit.

Author: harlanhaskins

Sources/Clang/CTypes.swift

@@ -21,7 +21,7 @@ public struct RecordType: ClangTypeBacked {
         }
         return Int(val)
     }
-    
+
     /// Gathers and returns all the fields of this record.
     func fields() -> [Cursor] {
         let fields = Box([Cursor]())

Sources/Clang/Cursors.swift

@@ -96,11 +96,6 @@ public struct ClassDecl: RecordDecl {
 public struct EnumConstantDecl: ClangCursorBacked {
     let clang: CXCursor
 
-    /// Retrieve the integer type of an enum declaration.
-    var integerType: CType {
-        return convertType(clang_getEnumDeclIntegerType(clang))!
-    }
-
     /// Retrieve the integer value of an enum constant declaration as an `Int`.
     var value: Int {
         return Int(clang_getEnumConstantDeclValue(clang))
@@ -118,6 +113,11 @@ public struct EnumDecl: ClangCursorBacked {
     func constants() -> [EnumConstantDecl] {
         return children() as! [EnumConstantDecl]
     }
+
+    /// Retrieve the integer type of an enum declaration.
+    var integerType: CType {
+        return convertType(clang_getEnumDeclIntegerType(clang))!
+    }
 }
 
 protocol TypeAliasCursor: ClangCursorBacked {}

Sources/Clang/Diagnostic.swift

@@ -31,3 +31,88 @@ public enum DiagnosticSeverity {
         }
     }
 }
+
+/// Describes the kind of error that occurred (if any) in a call to
+/// loadDiagnostics
+public enum LoadDiagError: Error {
+    /// Indicates that an unknown error occurred while attempting to deserialize
+    /// diagnostics.
+    case unknown
+
+    /// Indicates that the file containing the serialized diagnostics could not be
+    /// opened.
+    case cannotLoad
+
+    /// Indicates that the serialized diagnostics file is invalid or corrupt.
+    case invalidFile
+
+    init?(clang: CXLoadDiag_Error) {
+        switch clang {
+        case CXLoadDiag_None: return nil
+        case CXLoadDiag_Unknown: self = .unknown
+        case CXLoadDiag_CannotLoad: self = .cannotLoad
+        case CXLoadDiag_InvalidFile: self = .invalidFile
+        default: fatalError("invalid CXLoadDiag_Error \(clang)")
+        }
+    }
+}
+
+/// Options to control the display of diagnostics.
+/// The values in this enum are meant to be combined to customize the
+/// behavior of
+/// `clang_formatDiagnostic().`
+public struct DiagnosticDisplayOptions: OptionSet {
+    public typealias RawValue = CXDiagnosticDisplayOptions.RawValue
+    public let rawValue: RawValue
+    /// Creates a new DiagnosticDisplayOptions from a raw integer value.
+    public init(rawValue: RawValue) {
+        self.rawValue = rawValue
+    }
+
+    /// Display the source-location information where the diagnostic was located.
+    /// When set, diagnostics will be prefixed by the file, line, and (optionally)
+    /// column to which the diagnostic refers. For example,
+    /// ```
+    /// test.c:28: warning: extra tokens at end of #endif directive
+    /// ```
+    /// This option corresponds to the clang flag
+    /// `-fshow-source-location.`
+    public static let sourceLocation = DiagnosticDisplayOptions(rawValue:
+        CXDiagnostic_DisplaySourceLocation.rawValue)
+
+    /// If displaying the source-location information of the diagnostic, also
+    /// include the column number.
+    /// This option corresponds to the clang flag
+    /// `-fshow-column.`
+    public static let column = DiagnosticDisplayOptions(rawValue:
+        CXDiagnostic_DisplayColumn.rawValue)
+
+    /// If displaying the source-location information of the diagnostic, also
+    /// include information about source ranges in a machine-parsable format.
+    /// This option corresponds to the clang flag
+    /// `-fdiagnostics-print-source-range-info.`
+    public static let sourceRanges = DiagnosticDisplayOptions(rawValue:
+        CXDiagnostic_DisplaySourceRanges.rawValue)
+
+    /// Display the option name associated with this diagnostic, if any.
+    /// The option name displayed (e.g., -Wconversion) will be placed in brackets
+    /// after the diagnostic text. This option corresponds to the clang flag
+    /// `-fdiagnostics-show-option.`
+    public static let option = DiagnosticDisplayOptions(rawValue:
+        CXDiagnostic_DisplayOption.rawValue)
+
+    /// Display the category number associated with this diagnostic, if any.
+    /// The category number is displayed within brackets after the diagnostic
+    /// text.
+    /// This option corresponds to the clang flag
+    /// `-fdiagnostics-show-category=id.`
+    public static let categoryId = DiagnosticDisplayOptions(rawValue:
+        CXDiagnostic_DisplayCategoryId.rawValue)
+
+    /// Display the category name associated with this diagnostic, if any.
+    /// The category name is displayed within brackets after the diagnostic text.
+    /// This option corresponds to the clang flag
+    /// `-fdiagnostics-show-category=name.`
+    public static let categoryName = DiagnosticDisplayOptions(rawValue: 
+        CXDiagnostic_DisplayCategoryName.rawValue)
+}

Sources/Clang/File.swift

@@ -0,0 +1,41 @@
+import cclang
+import Foundation
+
+/// Represents a file ID that's unique to each file in a translation unit.
+public struct UniqueFileID: Equatable {
+    let clang: CXFileUniqueID
+
+    public static func ==(lhs: UniqueFileID, rhs: UniqueFileID) -> Bool {
+        return lhs.clang.data == rhs.clang.data
+    }
+}
+
+/// A particular source file that is part of a translation unit.
+public struct File: Equatable {
+    let clang: CXFile
+
+    /// Retrieve the complete file and path name of the given file.
+    public var name: String {
+        return clang_getFileName(clang).asSwift()
+    }
+
+    /// Retrieve the last modification time of the given file.
+    public var lastModified: Date {
+        return Date(timeIntervalSince1970: TimeInterval(clang_getFileTime(clang)))
+    }
+
+    /// Retrieves the unique identifier for this file.
+    /// If it failed, returns `nil`.
+    public var uniqueID: UniqueFileID? {
+        var id = CXFileUniqueID()
+        guard clang_getFileUniqueID(clang, &id) != 0 else {
+            return nil
+        }
+        return UniqueFileID(clang: id)
+    }
+
+    /// Determines if two files are equal.
+    public static func ==(lhs: File, rhs: File) -> Bool {
+        return clang_File_isEqual(lhs.clang, rhs.clang) != 0
+    }
+}

Sources/Clang/Index.swift

@@ -9,7 +9,51 @@ public class Index {
                                        displayDiagnostics.asClang())
     }
 
+    /// The general options associated with an Index.
+    var globalOptions: GlobalOptions {
+        get {
+            return GlobalOptions(rawValue: clang_CXIndex_getGlobalOptions(clang))
+        }
+        set {
+            clang_CXIndex_setGlobalOptions(clang, newValue.rawValue)
+        }
+    }
+
     deinit {
         clang_disposeIndex(clang)
     }
 }
+
+/// Global options used to inform the Index.
+public struct GlobalOptions: OptionSet {
+    public typealias RawValue = CXGlobalOptFlags.RawValue
+    public let rawValue: RawValue
+
+    /// Creates a new GlobalOptions from a raw integer value.
+    public init(rawValue: RawValue) {
+        self.rawValue = rawValue
+    }
+
+    /// Used to indicate that no special CXIndex options are needed.
+    public static let none = GlobalOptions(rawValue:
+        CXGlobalOpt_None.rawValue)
+
+    /// Used to indicate that threads that libclang creates for indexing purposes
+    /// should use background priority.
+    /// Affects #clang_indexSourceFile, #clang_indexTranslationUnit,
+    /// #clang_parseTranslationUnit, #clang_saveTranslationUnit.
+    public static let threadBackgroundPriorityForIndexing = GlobalOptions(rawValue:
+        CXGlobalOpt_ThreadBackgroundPriorityForIndexing.rawValue)
+
+    /// Used to indicate that threads that libclang creates for editing purposes
+    /// should use background priority.
+    /// Affects #clang_reparseTranslationUnit, #clang_codeCompleteAt,
+    /// #clang_annotateTokens
+    public static let threadBackgroundPriorityForEditing = GlobalOptions(rawValue:
+        CXGlobalOpt_ThreadBackgroundPriorityForEditing.rawValue)
+
+    /// Used to indicate that all threads that libclang creates should use
+    /// background priority.
+    public static let threadBackgroundPriorityForAll = GlobalOptions(rawValue:
+        CXGlobalOpt_ThreadBackgroundPriorityForAll.rawValue)
+}

Sources/Clang/Token.swift

@@ -21,44 +21,6 @@ public struct Token {
     }
 }
 
-/// Represents a file ID that's unique to each file in a translation unit.
-public struct UniqueFileID: Equatable {
-    let clang: CXFileUniqueID
-
-    public static func ==(lhs: UniqueFileID, rhs: UniqueFileID) -> Bool {
-        return lhs.clang.data == rhs.clang.data
-    }
-}
-
-/// A particular source file that is part of a translation unit.
-public struct File: Equatable {
-    let clang: CXFile
-
-    /// Retrieve the complete file and path name of the given file.
-    public var name: String {
-        return clang_getFileName(clang).asSwift()
-    }
-
-    /// Retrieve the last modification time of the given file.
-    public var lastModified: Date {
-        return Date(timeIntervalSince1970: TimeInterval(clang_getFileTime(clang)))
-    }
-
-    /// Retrieves the unique identifier for this file.
-    /// If it failed, returns `nil`.
-    public var uniqueID: UniqueFileID? {
-        var id = CXFileUniqueID()
-        guard clang_getFileUniqueID(clang, &id) != 0 else {
-            return nil
-        }
-        return UniqueFileID(clang: id)
-    }
-
-    public static func ==(lhs: File, rhs: File) -> Bool {
-        return clang_File_isEqual(lhs.clang, rhs.clang) != 0
-    }
-}
-
 public struct SourceLocation {
     let clang: CXSourceLocation
 

Sources/Clang/TranslationUnit.swift

@@ -1,31 +1,104 @@
 import cclang
 
+/// Flags that control the creation of translation units.
+/// The enumerators in this enumeration type are meant to be bitwise ORed
+/// together to specify which options should be used when constructing the
+/// translation unit.
 public struct TranslationUnitOptions: OptionSet {
-    public typealias RawValue = UInt32
-    public let rawValue: UInt32
-
-    public init(rawValue: UInt32) { self.rawValue = rawValue }
-
-    public static let detailedPreprocessingRecord =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_DetailedPreprocessingRecord.rawValue)
-    public static let incomplete =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_Incomplete.rawValue)
-    public static let precompiledPreamble =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_PrecompiledPreamble.rawValue)
-    public static let cacheCompletionResults =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_CacheCompletionResults.rawValue)
-    public static let forSerialization =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_ForSerialization.rawValue)
-    public static let cxxChainedPCH =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_CXXChainedPCH.rawValue)
-    public static let skipFunctionBodies =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_SkipFunctionBodies.rawValue)
-    public static let includeBriefCommentsInCodeCompletion =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_IncludeBriefCommentsInCodeCompletion.rawValue)
-    public static let createPreambleOnFirstParse =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_CreatePreambleOnFirstParse.rawValue)
-    public static let keepGoing =
-        TranslationUnitOptions(rawValue: CXTranslationUnit_KeepGoing.rawValue)
+    public typealias RawValue = CXTranslationUnit_Flags.RawValue
+    public let rawValue: RawValue
+
+    /// Creates a new TranslationUnitOptions from a raw integer value.
+    public init(rawValue: RawValue) {
+        self.rawValue = rawValue
+    }
+
+    /// Used to indicate that no special translation-unit options are needed.
+    public static let none = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_None.rawValue)
+
+    /// Used to indicate that the parser should construct a "detailed"
+    /// preprocessing record, including all macro definitions and instantiations.
+    /// Constructing a detailed preprocessing record requires more memory and time
+    /// to parse, since the information contained in the record is usually not
+    /// retained. However, it can be useful for applications that require more
+    /// detailed information about the behavior of the preprocessor.
+    public static let detailedPreprocessingRecord = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_DetailedPreprocessingRecord.rawValue)
+
+    /// Used to indicate that the translation unit is incomplete.
+    /// When a translation unit is considered "incomplete", semantic analysis that
+    /// is typically performed at the end of the translation unit will be
+    /// suppressed. For example, this suppresses the completion of tentative
+    /// declarations in C and of instantiation of implicitly-instantiation
+    /// function templates in C++. This option is typically used when parsing a
+    /// header with the intent of producing a precompiled header.
+    public static let incomplete = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_Incomplete.rawValue)
+
+    /// Used to indicate that the translation unit should be built with an
+    /// implicit precompiled header for the preamble.
+    /// An implicit precompiled header is used as an optimization when a
+    /// particular translation unit is likely to be reparsed many times
+    /// when the sources aren't changing that often. In this case, an
+    /// implicit precompiled header will be built containing all of the
+    /// initial includes at the top of the main file (what we refer to as
+    /// the "preamble" of the file). In subsequent parses, if the
+    /// preamble or the files in it have not changed,
+    /// `clang_reparseTranslationUnit()`
+    /// will re-use the implicit
+    /// precompiled header to improve parsing performance.
+    public static let precompiledPreamble = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_PrecompiledPreamble.rawValue)
+
+    /// Used to indicate that the translation unit should cache some
+    /// code-completion results with each reparse of the source file.
+    /// Caching of code-completion results is a performance optimization that
+    /// introduces some overhead to reparsing but improves the performance of
+    /// code-completion operations.
+    public static let cacheCompletionResults = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_CacheCompletionResults.rawValue)
+
+    /// This option is typically used when parsing a header with the intent of
+    /// producing a precompiled header.
+    /// Used to indicate that the translation unit will be serialized with
+    /// `clang_saveTranslationUnit.`
+    public static let forSerialization = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_ForSerialization.rawValue)
+
+    /// DEPRECATED: Enabled chained precompiled preambles in C++.
+    /// Note: this is a *temporary* option that is available only while we are
+    /// testing C++ precompiled preamble support. It is deprecated.
+    public static let cxxChainedPCH = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_CXXChainedPCH.rawValue)
+
+    /// Used to indicate that function/method bodies should be skipped while
+    /// parsing.
+    /// This option can be used to search for declarations/definitions while
+    /// ignoring the usages.
+    public static let skipFunctionBodies = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_SkipFunctionBodies.rawValue)
+
+    /// Used to indicate that brief documentation comments should be included into
+    /// the set of code completions returned from this translation unit.
+    public static let includeBriefCommentsInCodeCompletion = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_IncludeBriefCommentsInCodeCompletion.rawValue)
+
+    /// Used to indicate that the precompiled preamble should be created on the
+    /// first parse. Otherwise it will be created on the first reparse. This
+    /// trades runtime on the first parse (serializing the preamble takes time)
+    /// for reduced runtime on the second parse (can now reuse the preamble).
+    public static let createPreambleOnFirstParse = TranslationUnitOptions(rawValue:
+        CXTranslationUnit_CreatePreambleOnFirstParse.rawValue)
+
+    /// Do not stop processing when fatal errors are encountered.
+    /// When fatal errors are encountered while parsing a translation unit,
+    /// semantic analysis is typically stopped early when compiling code. A common
+    /// source for fatal errors are unresolvable include files. For the purposes
+    /// of an IDE, this is undesirable behavior and as much information as
+    /// possible should be reported. Use this flag to enable this behavior.
+    public static let keepGoing = TranslationUnitOptions(rawValue: 
+        CXTranslationUnit_KeepGoing.rawValue)
 }
 
 public class TranslationUnit {