Added custom protocol for macros.

Author: harlanhaskins

Sources/Clang/Cursors.swift

@@ -109,6 +109,30 @@ public struct EnumConstantDecl: ClangCursorBacked {
     }
 }
 
+protocol MacroCursor: ClangCursorBacked {}
+extension MacroCursor {
+    /// Determine whether a macro is function like.
+    public var isFunctionLike: Bool {
+        return clang_Cursor_isMacroFunctionLike(clang) != 0
+    }
+
+    /// Determine whether a macro is a built-in macro.
+    public var isBuiltin: Bool {
+        return clang_Cursor_isMacroBuiltin(clang) != 0
+    }
+}
+public struct MacroExpansion: MacroCursor {
+    let clang: CXCursor
+}
+
+public struct MacroInstantiation: MacroCursor {
+    let clang: CXCursor
+}
+
+public struct MacroDefinition: MacroCursor {
+    let clang: CXCursor
+}
+
 /// An access specifier.
 public struct CXXAccessSpecifier: ClangCursorBacked {
     let clang: CXCursor
@@ -1183,21 +1207,6 @@ public struct PreprocessingDirective: ClangCursorBacked {
     let clang: CXCursor
 }
 
-
-public struct MacroDefinition: ClangCursorBacked {
-    let clang: CXCursor
-}
-
-
-public struct MacroExpansion: ClangCursorBacked {
-    let clang: CXCursor
-}
-
-
-public struct MacroInstantiation: ClangCursorBacked {
-    let clang: CXCursor
-}
-
 /// A module import declaration.
 public struct ModuleImportDecl: ClangCursorBacked {
     let clang: CXCursor

Sources/Clang/Token.swift

@@ -1,15 +1,15 @@
 #if !NO_SWIFTPM
 import cclang
 #endif
+
 import Foundation
 
-public struct Token {
-    internal let clang: CXToken
+/// Represents a C, C++, or Objective-C token.
+public protocol Token {
+    var clang: CXToken { get }
+}
 
-    /// Retrieves the kind of the receiver.
-    public var kind: TokenKind {
-        return TokenKind(clang: clang_getTokenKind(clang))
-    }
+extension Token {
 
     /// Determine the spelling of the given token.
     /// The spelling of a token is the textual representation of that token,
@@ -18,8 +18,57 @@ public struct Token {
         return clang_getTokenSpelling(translationUnit.clang, clang).asSwift()
     }
 
-    public func asClang() -> CXToken {
-        return clang
+    /// Retrieve the source location of the given token.
+    /// - param translationUnit: The translation unit in which you're looking
+    ///                          for this token.
+    func location(in translationUnit: TranslationUnit) -> SourceLocation {
+        return SourceLocation(clang: clang_getTokenLocation(translationUnit.clang,
+                                                            clang))
+    }
+
+    /// Retrieve a source range that covers the given token.
+    /// - param translationUnit: The translation unit in which you're looking
+    ///                          for this token.
+    func range(in translationUnit: TranslationUnit) -> SourceRange {
+        return SourceRange(clang: clang_getTokenExtent(translationUnit.clang,
+                                                       clang))
+    }
+}
+
+/// A token that contains some kind of punctuation.
+public struct PunctuationToken: Token {
+    public let clang: CXToken
+}
+
+/// A language keyword.
+public struct KeywordToken: Token {
+    public let clang: CXToken
+}
+
+/// An identifier (that is not a keyword).
+public struct IdentifierToken: Token {
+    public let clang: CXToken
+}
+
+/// A numeric, string, or character literal.
+public struct LiteralToken: Token {
+    public let clang: CXToken
+}
+
+/// A comment.
+public struct CommentToken: Token {
+    public let clang: CXToken
+}
+
+/// Converts a CXToken to a Token, returning `nil` if it was unsuccessful
+func convertToken(_ clang: CXToken) -> Token {
+    switch clang_getTokenKind(clang) {
+    case CXToken_Punctuation: return PunctuationToken(clang: clang)
+    case CXToken_Keyword: return KeywordToken(clang: clang)
+    case CXToken_Identifier: return IdentifierToken(clang: clang)
+    case CXToken_Literal: return LiteralToken(clang: clang)
+    case CXToken_Comment: return CommentToken(clang: clang)
+    default: fatalError("invalid CXTokenKind \(clang)")
     }
 }
 
@@ -78,42 +127,3 @@ public struct SourceRange {
         return SourceLocation(clang: clang_getRangeEnd(clang))
     }
 }
-
-/// Represents the different kinds of tokens in C/C++/Objective-C
-public enum TokenKind {
-    /// A piece of punctuation, like `{`, `;`, and `:`
-    case punctuation
-
-    /// A keyword, like `if`, `else`, and `case`
-    case keyword
-
-    /// An identifier, like a variable's name or type name
-    case identifier
-
-    /// A literal, either character, string, or number
-    case literal
-
-    /// A C comment
-    case comment
-
-    init(clang: CXTokenKind) {
-        switch clang {
-        case CXToken_Comment: self = .comment
-        case CXToken_Literal: self = .literal
-        case CXToken_Identifier: self = .identifier
-        case CXToken_Keyword: self = .keyword
-        case CXToken_Punctuation: self = .punctuation
-        default: fatalError("unknown CXTokenKind \(clang)")
-        }
-    }
-
-    func asClang() -> CXTokenKind {
-        switch self {
-        case .comment: return CXToken_Comment
-        case .literal: return CXToken_Literal
-        case .identifier: return CXToken_Identifier
-        case .keyword: return CXToken_Keyword
-        case .punctuation: return CXToken_Punctuation
-        }
-    }
-}

Sources/Clang/TranslationUnit.swift

@@ -165,7 +165,7 @@ public class TranslationUnit {
         guard let tokensPtr = tokensPtrOpt else { return [] }
         var tokens = [Token]()
         for i in 0..<Int(numTokens) {
-            tokens.append(Token(clang: tokensPtr[i]))
+            tokens.append(convertToken(tokensPtr[i]))
         }
         clang_disposeTokens(clang, tokensPtr, numTokens)
         return tokens

Tests/ClangTests/ClangTests.swift

@@ -126,7 +126,7 @@ func generateStructs(forEnum decl: EnumDecl,
                      prefix: String,
                      suffix: String = "") {
     let protocolDecl = [
-        "protocol \(type) {",
+        "public protocol \(type) {",
         "  var clang: CX\(type) { get }",
         "}",
         ""
@@ -238,9 +238,9 @@ class ClangTests: XCTestCase {
                                             "-I/usr/local/opt/llvm/include"
                                         ])
             let typesToMake: [String: (type: String, prefix: String, suffix: String)] = [
-                "CX_StorageClass": (type: "StorageClass",
-                                            prefix: "CX_SC_",
-                                            suffix: "")
+                "CXTokenKind": (type: "Token",
+                                            prefix: "CXToken_",
+                                            suffix: "Token")
             ]
             for child in tu.cursor.children() {
 //                if let decl = child as? TypedefDecl,
@@ -257,9 +257,9 @@ class ClangTests: XCTestCase {
 //                print()
                 if let values = typesToMake["\(enumDecl)"] {
 //                    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)
+//                    generateSwiftEnum(forEnum: enumDecl, prefix: values.prefix, name: values.type)
+                    generateStructs(forEnum: enumDecl, type: values.type,
+                                    prefix: values.prefix, suffix: values.suffix)
                 }
             }
 //            for child in tu.cursor.children() {