implement support for type definitions

parser/src/main/kotlin/gay/pizza/pork/parser/Parser.kt

@@ -8,11 +8,12 @@ class Parser(source: TokenSource, attribution: NodeAttribution) :
   ParserBase(source, attribution) {
   override fun parseArgumentSpec(): ArgumentSpec = produce(NodeType.ArgumentSpec) {
     val symbol = parseSymbol()
+    val multiple = next(TokenType.DotDotDot)
     var typeSpec: TypeSpec? = null
     if (next(TokenType.Colon)) {
       typeSpec = parseTypeSpec()
     }
-    ArgumentSpec(symbol, typeSpec = typeSpec, next(TokenType.DotDotDot))
+    ArgumentSpec(symbol, typeSpec = typeSpec, multiple = multiple)
   }
 
   override fun parseBlock(): Block = expect(NodeType.Block, TokenType.LeftCurly) {
@@ -175,6 +176,7 @@ class Parser(source: TokenSource, attribution: NodeAttribution) :
   override fun parseDefinition(): Definition =
     when (val type = peekAheadUntilNotIn(*TokenType.DeclarationModifiers)) {
       TokenType.Func -> parseFunctionDefinition()
+      TokenType.Type -> parseTypeDefinition()
       TokenType.Let -> parseLetDefinition()
       else -> throw ParseError(
         "Failed to parse token: ${type.name} as" +
@@ -330,6 +332,15 @@ class Parser(source: TokenSource, attribution: NodeAttribution) :
     NativeFunctionDescriptor(form, definitions)
   }
 
+  override fun parseNativeTypeDescriptor(): NativeTypeDescriptor = expect(NodeType.NativeTypeDescriptor, TokenType.Native) {
+    val form = parseSymbol()
+    val definitions = mutableListOf<StringLiteral>()
+    while (peek(TokenType.Quote)) {
+      definitions.add(parseStringLiteral())
+    }
+    NativeTypeDescriptor(form = form, definitions = definitions)
+  }
+
   override fun parseNoneLiteral(): NoneLiteral = expect(NodeType.NoneLiteral, TokenType.None) {
     NoneLiteral()
   }
@@ -390,6 +401,15 @@ class Parser(source: TokenSource, attribution: NodeAttribution) :
     SymbolReference(parseSymbol())
   }
 
+  override fun parseTypeDefinition(): TypeDefinition = produce(NodeType.TypeDefinition) {
+    val definitionModifiers = parseDefinitionModifiers()
+    expect(TokenType.Type)
+    val name = parseSymbol()
+    expect(TokenType.Equals)
+    val nativeTypeDescriptor = parseNativeTypeDescriptor()
+    TypeDefinition(modifiers = definitionModifiers, symbol = name, nativeTypeDescriptor = nativeTypeDescriptor)
+  }
+
   override fun parseTypeSpec(): TypeSpec = produce(NodeType.TypeSpec) {
     TypeSpec(parseSymbol())
   }

parser/src/main/kotlin/gay/pizza/pork/parser/Printer.kt

@@ -90,6 +90,18 @@ class Printer(buffer: StringBuilder) : NodeVisitor<Unit> {
     }
   }
 
+  override fun visitNativeTypeDescriptor(node: NativeTypeDescriptor) {
+    append("native ")
+    visit(node.form)
+    append(" ")
+    for ((index, argument) in node.definitions.withIndex()) {
+      visit(argument)
+      if (index + 1 != node.definitions.size) {
+        append(" ")
+      }
+    }
+  }
+
   override fun visitNoneLiteral(node: NoneLiteral) {
     append("none")
   }
@@ -137,6 +149,16 @@ class Printer(buffer: StringBuilder) : NodeVisitor<Unit> {
     visit(node.symbol)
   }
 
+  override fun visitTypeDefinition(node: TypeDefinition) {
+    visitDefinitionModifiers(node.modifiers)
+    append("type ")
+    visit(node.symbol)
+    append(" = ")
+    if (node.nativeTypeDescriptor != null) {
+      visit(node.nativeTypeDescriptor!!)
+    }
+  }
+
   override fun visitTypeSpec(node: TypeSpec) {
     visit(node.symbol)
   }