Add support for interfacing with C libraries

This adds support for linking against C libraries and using their types
and functions. The FFI is fairly strict and a bit limited, such as not
performing automatic type conversions, but this is a deliberate choice:
it keeps the compiler's complexity at a reasonable level, and it should
(hopefully) further drive home the idea that one should avoid
interfacing with C as much as they can, as all of Inko's safety
guarantees are thrown out of the window when doing so.

As part of this work, the precedence of type casts (`x as Type`) is
changed to be the same as binary operators. This means expressions such
as `x as Foo + y` are now valid, instead of resulting in a syntax error.
This makes working with type casts (something you'll need to use more
often when working with C code) less painful.

This commit also introduces support for conditional compilation at the
import level. Based on the build target, a set of build tags is
produced. `import` statements support a condition, and when given the
`import` is only included if all the tags match. For example:

    import foo if mac and amd64

This would only import `foo` if the tags "mac" and "amd64" are present.
OR and NOT expressions aren't supported, as one can simply use multiple
imports.

This fixes #290.

Changelog: added

ast/src/lexer.rs

@@ -170,6 +170,7 @@ pub enum TokenKind {
     UnsignedShrAssign,
     While,
     Whitespace,
+    Extern,
 }
 
 impl TokenKind {
@@ -274,6 +275,7 @@ impl TokenKind {
             TokenKind::Recover => "the 'recover' keyword",
             TokenKind::Nil => "the 'nil' keyword",
             TokenKind::Replace => "a '=:'",
+            TokenKind::Extern => "the 'extern' keyword",
         }
     }
 }
@@ -340,6 +342,7 @@ impl Token {
                 | TokenKind::False
                 | TokenKind::Case
                 | TokenKind::Enum
+                | TokenKind::Extern
         )
     }
 
@@ -995,6 +998,7 @@ impl Lexer {
                 "import" => TokenKind::Import,
                 "return" => TokenKind::Return,
                 "static" => TokenKind::Static,
+                "extern" => TokenKind::Extern,
                 _ => TokenKind::Identifier,
             },
             7 => match value.as_str() {
@@ -2073,6 +2077,7 @@ mod tests {
         assert_token!("import", Import, "import", 1..=1, 1..=6);
         assert_token!("return", Return, "return", 1..=1, 1..=6);
         assert_token!("static", Static, "static", 1..=1, 1..=6);
+        assert_token!("extern", Extern, "extern", 1..=1, 1..=6);
 
         assert_token!("builtin", Builtin, "builtin", 1..=1, 1..=7);
         assert_token!("recover", Recover, "recover", 1..=1, 1..=7);

ast/src/nodes.rs

@@ -324,11 +324,25 @@ impl Node for ImportPath {
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct BuildTags {
+    pub values: Vec<Identifier>,
+    pub location: SourceLocation,
+}
+
+impl Node for BuildTags {
+    fn location(&self) -> &SourceLocation {
+        &self.location
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct Import {
     pub path: ImportPath,
     pub symbols: Option<ImportSymbols>,
     pub location: SourceLocation,
+    pub tags: Option<BuildTags>,
+    pub include: bool,
 }
 
 impl Node for Import {
@@ -337,6 +351,24 @@ impl Node for Import {
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct ExternImportPath {
+    pub path: String,
+    pub location: SourceLocation,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ExternImport {
+    pub path: ExternImportPath,
+    pub location: SourceLocation,
+}
+
+impl Node for ExternImport {
+    fn location(&self) -> &SourceLocation {
+        &self.location
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct DefineConstant {
     pub public: bool,
@@ -359,6 +391,7 @@ pub enum MethodKind {
     Moving,
     Mutable,
     AsyncMutable,
+    Extern,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -419,6 +452,7 @@ pub enum ClassKind {
     Builtin,
     Enum,
     Regular,
+    Extern,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -501,6 +535,7 @@ pub enum TopLevelExpression {
     ReopenClass(Box<ReopenClass>),
     ImplementTrait(Box<ImplementTrait>),
     Import(Box<Import>),
+    ExternImport(Box<ExternImport>),
 }
 
 impl Node for TopLevelExpression {
@@ -513,6 +548,7 @@ impl Node for TopLevelExpression {
             TopLevelExpression::ReopenClass(ref typ) => typ.location(),
             TopLevelExpression::ImplementTrait(ref typ) => typ.location(),
             TopLevelExpression::Import(ref typ) => typ.location(),
+            TopLevelExpression::ExternImport(ref typ) => typ.location(),
         }
     }
 }