Added a few more enums

Author: harlanhaskins

Sources/Clang/Cursor.swift

@@ -248,6 +248,19 @@ extension Cursor {
                             platforms: platforms)
     }
 
+    /// Returns the storage class for a function or variable declaration.
+    public var storageClass: StorageClass? {
+        return StorageClass(clang: clang_Cursor_getStorageClass(asClang()))
+    }
+
+    /// Returns the access control level for the referenced object.
+    /// If the cursor refers to a C++ declaration, its access control level
+    /// within its parent scope is returned. Otherwise, if the cursor refers to
+    /// a base specifier or access specifier, the specifier itself is returned.
+    public var accessSpecifier: CXXAccessSpecifierKind? {
+        return CXXAccessSpecifierKind(clang: clang_getCXXAccessSpecifier(asClang()))
+    }
+
     /// Given a cursor that represents a documentable entity (e.g.,
     /// declaration), return the associated parsed comment
     public var fullComment: FullComment? {
@@ -321,3 +334,46 @@ public enum TemplateArgumentKind {
         }
     }
 }
+
+/// Represents the C++ access control level to a base class for a cursor.
+public enum CXXAccessSpecifierKind {
+    case `public`
+    case protected
+    case `private`
+
+    init?(clang: CX_CXXAccessSpecifier) {
+        switch clang {
+        case CX_CXXInvalidAccessSpecifier: return nil
+        case CX_CXXPublic: self = .public
+        case CX_CXXProtected: self = .protected
+        case CX_CXXPrivate: self = .private
+        default: fatalError("invalid CX_CXXAccessSpecifier \(clang)")
+        }
+    }
+}
+
+/// Represents the storage classes as declared in the source. CX_SC_Invalid was
+/// added for the case that the passed cursor in not a declaration.
+public enum StorageClass {
+    case none
+    case extern
+    case `static`
+    case privateExtern
+    case openCLWorkGroupLocal
+    case auto
+    case register
+
+    init?(clang: CX_StorageClass) {
+        switch clang {
+        case CX_SC_Invalid: return nil
+        case CX_SC_None: self = .none
+        case CX_SC_Extern: self = .extern
+        case CX_SC_Static: self = .static
+        case CX_SC_PrivateExtern: self = .privateExtern
+        case CX_SC_OpenCLWorkGroupLocal: self = .openCLWorkGroupLocal
+        case CX_SC_Auto: self = .auto
+        case CX_SC_Register: self = .register
+        default: fatalError("invalid CX_StorageClass \(clang)")
+        }
+    }
+}

Sources/Clang/Cursors.swift

@@ -97,16 +97,21 @@ public struct EnumConstantDecl: ClangCursorBacked {
     let clang: CXCursor
 
     /// Retrieve the integer value of an enum constant declaration as an `Int`.
-    var value: Int {
+    public var value: Int {
         return Int(clang_getEnumConstantDeclValue(clang))
     }
 
     /// Retrieve the integer value of an enum constant declaration as a `UInt`.
-    var unsignedValue: UInt {
+    public var unsignedValue: UInt {
         return UInt(clang_getEnumConstantDeclUnsignedValue(clang))
     }
 }
 
+/// An access specifier.
+public struct CXXAccessSpecifier: ClangCursorBacked {
+    let clang: CXCursor
+}
+
 public struct EnumDecl: ClangCursorBacked {
     let clang: CXCursor
 
@@ -285,22 +290,14 @@ public struct ObjCDynamicDecl: ClangCursorBacked {
     let clang: CXCursor
 }
 
-/// An access specifier.
-public struct CXXAccessSpecifier: ClangCursorBacked {
-    let clang: CXCursor
-}
-
-/// An access specifier.
 public struct ObjCSuperClassRef: ClangCursorBacked {
     let clang: CXCursor
 }
 
-/// An access specifier.
 public struct ObjCProtocolRef: ClangCursorBacked {
     let clang: CXCursor
 }
 
-/// An access specifier.
 public struct ObjCClassRef: ClangCursorBacked {
     let clang: CXCursor
 }

Sources/Clang/TranslationUnit.swift

@@ -112,13 +112,13 @@ public class TranslationUnit {
     /// Creates a `TranslationUnit` by parsing the file at the specified path,
     /// passing optional command line arguments and options to clang.
     ///
-    /// - Parameters:
+    /// - parameters:
     ///   - index: The index
     ///   - filename: The path you're going to parse
     ///   - args: Optional command-line arguments to pass to clang
     ///   - options: Options for how to handle the parsed file
-    /// - throws: `ClangError` if the translation unit could not
-    ///           be created successfully.
+    /// - throws: `ClangError` if the translation unit could not be created
+    ///           successfully.
     public init(index: Index, filename: String,
                 commandLineArgs args: [String] = [],
                 options: TranslationUnitOptions = []) throws {

Tests/ClangTests/ClangTests.swift

@@ -214,7 +214,16 @@ func convert(_ comment: FullComment, indent: Int = 0) -> [String] {
                    .map { "/// \($0)" }
 }
 
-
+extension TranslationUnit {
+    func findComment(symbol: String) -> FullComment? {
+        for child in cursor.children() {
+            if "\(child)".contains(symbol) {
+                return child.fullComment
+            }
+        }
+        return nil
+    }
+}
 
 class ClangTests: XCTestCase {
     func testExample() {
@@ -227,8 +236,8 @@ class ClangTests: XCTestCase {
                                             "-I/usr/local/opt/llvm/include"
                                         ])
             let typesToMake: [String: (type: String, prefix: String, suffix: String)] = [
-                "CXTranslationUnit_Flags": (type: "TranslationUnitOptions",
-                                            prefix: "CXTranslationUnit_",
+                "CX_StorageClass": (type: "StorageClass",
+                                            prefix: "CX_SC_",
                                             suffix: "")
             ]
             for child in tu.cursor.children() {
@@ -239,9 +248,14 @@ class ClangTests: XCTestCase {
 //                    generateSwiftOptionSet(forEnum: enumDecl, prefix: "CXTranslationUnit_", name: "TranslationUnitOptions")
 //                }
                 guard let enumDecl = child as? EnumDecl else { continue }
+//                print(enumDecl)
+//                for constant in enumDecl.constants() {
+//                    print("  \(constant)")
+//                }
+//                print()
                 if let values = typesToMake["\(enumDecl)"] {
-                    generateSwiftOptionSet(forEnum: enumDecl, prefix: values.prefix, name: values.type)
-//                    generateSwiftEnum(forEnum: enumDecl, prefix: values.prefix, name: values.type)
+//                    generateSwiftOptionSet(forEnum: enumDecl, prefix: values.prefix, name: values.type)
+                    generateSwiftEnum(forEnum: enumDecl, prefix: values.prefix, name: values.type)
 //                    generateStructs(forEnum: enumDecl, type: values.type,
 //                                    prefix: values.prefix, suffix: values.suffix)
                 }