1 files changed, 104 insertions, 0 deletions
diff --git a/src/parse.rs b/src/parse.rs
new file mode 100644
index 00000000..0e4164f0
--- /dev/null
+++ b/src/parse.rs
@@ -0,0 +1,104 @@
+//! Common traits and types related to parsing our IR from Clang cursors.
+
+use clang;
+use ir::context::{BindgenContext, ItemId};
+use ir::ty::TypeKind;
+
+/// Not so much an error in the traditional sense, but a control flow message
+/// when walking over Clang's AST with a cursor.
+#[derive(Debug)]
+pub enum ParseError {
+    /// Recurse down the current AST node's children.
+    Recurse,
+    /// Continue on to the next sibling AST node, or back up to the parent's
+    /// siblings if we've exhausted all of this node's siblings (and so on).
+    Continue,
+}
+
+/// The result of parsing a Clang AST node.
+#[derive(Debug)]
+pub enum ParseResult<T> {
+    /// We've already resolved this item before, here is the extant `ItemId` for
+    /// it.
+    AlreadyResolved(ItemId),
+
+    /// This is a newly parsed item. If the cursor is `Some`, it points to the
+    /// AST node where the new `T` was declared.
+    New(T, Option<clang::Cursor>),
+}
+
+/// An intermediate representation "sub-item" (i.e. one of the types contained
+/// inside an `ItemKind` variant) that can be parsed from a Clang cursor.
+pub trait ClangSubItemParser: Sized {
+    /// Attempt to parse this type from the given cursor.
+    ///
+    /// The fact that is a reference guarantees it's held by the context, and
+    /// allow returning already existing types.
+    fn parse(cursor: clang::Cursor,
+             context: &mut BindgenContext)
+             -> Result<ParseResult<Self>, ParseError>;
+}
+
+/// An intermediate representation item that can be parsed from a Clang cursor.
+pub trait ClangItemParser: Sized {
+    /// Parse this item from the given Clang cursor.
+    fn parse(cursor: clang::Cursor,
+             parent: Option<ItemId>,
+             context: &mut BindgenContext)
+             -> Result<ItemId, ParseError>;
+
+    /// Parse this item from the given Clang type.
+    fn from_ty(ty: &clang::Type,
+               location: Option<clang::Cursor>,
+               parent: Option<ItemId>,
+               ctx: &mut BindgenContext)
+               -> Result<ItemId, ParseError>;
+
+    /// Identical to `from_ty`, but use the given `id` as the `ItemId` for the
+    /// newly parsed item.
+    fn from_ty_with_id(id: ItemId,
+                       ty: &clang::Type,
+                       location: Option<clang::Cursor>,
+                       parent: Option<ItemId>,
+                       ctx: &mut BindgenContext)
+                       -> Result<ItemId, ParseError>;
+
+    /// Parse this item from the given Clang type, or if we haven't resolved all
+    /// the other items this one depends on, an unresolved reference.
+    fn from_ty_or_ref(ty: clang::Type,
+                      location: Option<clang::Cursor>,
+                      parent_id: Option<ItemId>,
+                      context: &mut BindgenContext)
+                      -> ItemId;
+
+    /// Identical to `from_ty_or_ref`, but use the given `potential_id` as the
+    /// `ItemId` for the newly parsed item.
+    fn from_ty_or_ref_with_id(potential_id: ItemId,
+                              ty: clang::Type,
+                              location: Option<clang::Cursor>,
+                              parent_id: Option<ItemId>,
+                              context: &mut BindgenContext)
+                              -> ItemId;
+
+    /// Create a named template type.
+    fn named_type<S>(name: S,
+                     parent: ItemId,
+                     context: &mut BindgenContext)
+                     -> ItemId
+        where S: Into<String>;
+
+    /// Identical to `named_type`, but use `id` as the resulting item's
+    /// `ItemId`.
+    fn named_type_with_id<S>(id: ItemId,
+                             name: S,
+                             parent: ItemId,
+                             context: &mut BindgenContext)
+                             -> ItemId
+        where S: Into<String>;
+
+    /// Create a builtin type.
+    fn builtin_type(kind: TypeKind,
+                    is_const: bool,
+                    context: &mut BindgenContext)
+                    -> ItemId;
+}