 		add_named_rule("lit-column", rule: ^"lit-column-wrapped" | ^"lit-column-naked")
 
 		add_named_rule("lit-call", rule:
-			Parser.matchLiteral("(") => {
+			Parser.matchLiteral("(") => { [unowned self] in
 				// Turn the column reference into a function call
 				guard case .columnIdentifier(let col) = self.stack.popLast()! else { fatalError() }
 				self.stack.append(.expression(SQLExpression.call(SQLFunction(name: col.name), parameters: [])))
 			}
-			~ (Parser.matchList(^"ex" => {
+			~ (Parser.matchList(^"ex" => { [unowned self] in
 				guard case .expression(let parameter) = self.stack.popLast()! else { fatalError() }
 				guard case .expression(let e) = self.stack.popLast()! else { fatalError() }
 				guard case .call(let fn, parameters: var ps) = e else { fatalError() }

		})/~)

		add_named_rule("ex-case-when", rule:
			Parser.matchLiteralInsensitive("CASE") => {
				self.stack.append(.expression(SQLExpression.when([], else: nil)))
			}
			~~ ((Parser.matchLiteralInsensitive("WHEN") ~~ ^"ex-equality" ~~ Parser.matchLiteralInsensitive("THEN") ~~ ^"ex-equality") => {
				guard case .expression(let then) = self.stack.popLast()! else { fatalError() }
				guard case .expression(let when) = self.stack.popLast()! else { fatalError() }
				guard case .expression(let caseExpression) = self.stack.popLast()! else { fatalError() }

		)

		add_named_rule("insert-dml-statement", rule: (
				Parser.matchLiteralInsensitive("INSERT") => { [unowned self] in
					self.stack.append(.statement(.insert(SQLInsert(orReplace: false, into: SQLTable(name: ""), columns: [], values: []))))
				}
				~~ ((Parser.matchLiteralInsensitive("OR REPLACE") => { [unowned self] in
					guard case .statement(let statement) = self.stack.popLast()! else { fatalError() }
					guard case .insert(var insert) = statement else { fatalError() }
					insert.orReplace = true
					self.stack.append(.statement(.insert(insert)))
				})/~)
				~~ Parser.matchLiteralInsensitive("INTO")
				~~ (^"id-table" => { [unowned self] in
                    self.stack.append(.tableIdentifier(SQLTable(name: self.text)))
                })
				~~ ((Parser.matchLiteral("(") => { [unowned self] in
                    self.stack.append(.columnList([]))
                })
                ~~ ^"column-list" ~~ Parser.matchLiteral(")"))
				~~ Parser.matchLiteralInsensitive("VALUES")
					=> { [unowned self] in
						guard case .columnList(let cs) = self.stack.popLast()! else { fatalError() }
						guard case .tableIdentifier(let tn) = self.stack.popLast()! else { fatalError() }
						guard case .statement(let statement) = self.stack.popLast()! else { fatalError() }
