Handle none

Sources/Ast.swift

@@ -120,3 +120,7 @@ struct KeywordArgumentExpression: Expression {
     var key: Identifier
     var value: any Expression
 }
+
+struct NullLiteral: Literal {
+  var value: Any? = nil
+}

Sources/Environment.swift

@@ -165,13 +165,17 @@ class Environment {
             }
 
             return ObjectValue(value: object)
+        case is NullValue:
+            return NullValue()
+        case Optional<Any>.none:
+            return NullValue()
         default:
             throw JinjaError.runtime("Cannot convert to runtime value: \(input) type:\(type(of: input))")
         }
     }
 
     @discardableResult
-    func set(name: String, value: Any) throws -> any RuntimeValue {
+    func set(name: String, value: Any?) throws -> any RuntimeValue {
         try self.declareVariable(name: name, value: self.convertToRuntimeValues(input: value))
     }
 

Sources/Lexer.swift

@@ -13,6 +13,7 @@ enum TokenType: String {
     case numericLiteral = "NumericLiteral"
     case booleanLiteral = "BooleanLiteral"
     case stringLiteral = "StringLiteral"
+    case nullLiteral = "NullLiteral"
     case identifier = "Identifier"
     case equals = "Equals"
     case openParen = "OpenParen"
@@ -71,6 +72,8 @@ let keywords: [String: TokenType] = [
     "not": .not,
     "true": .booleanLiteral,
     "false": .booleanLiteral,
+    "none": .nullLiteral,
+    "None": .nullLiteral,
 ]
 
 func isWord(char: String) -> Bool {

Sources/Parser.swift

@@ -187,21 +187,18 @@ func parse(tokens: [Token]) throws -> Program {
         while typeof(.is) {
             current += 1
             let negate = typeof(.not)
-
             if negate {
                 current += 1
             }
-
             var filter = try parsePrimaryExpression()
-
-            if let boolLiteralFlter = filter as? BoolLiteral {
-                filter = Identifier(value: String(boolLiteralFlter.value))
+            if let boolLiteralFilter = filter as? BoolLiteral {
+                filter = Identifier(value: String(boolLiteralFilter.value))
+            } else if let nullLiteralFilter = filter as? NullLiteral {
+                filter = Identifier(value: "none")
             }
-
             if let test = filter as? Identifier {
                 operand = TestExpression(operand: operand as! Expression, negate: negate, test: test)
-            }
-            else {
+            } else {
                 throw JinjaError.syntax("Expected identifier for the test")
             }
         }
@@ -415,6 +412,9 @@ func parse(tokens: [Token]) throws -> Program {
             current += 1
 
             return ObjectLiteral(value: values)
+        case .nullLiteral:
+            current += 1
+            return NullLiteral()
         default:
             throw JinjaError.syntax("Unexpected token: \(token.type)")
         }

Sources/Runtime.swift

@@ -35,7 +35,7 @@ struct BooleanValue: RuntimeValue {
 }
 
 struct NullValue: RuntimeValue {
-    var value: (any RuntimeValue)?
+    var value: Any? = nil
     var builtins: [String: any RuntimeValue] = [:]
 
     func bool() -> Bool {
@@ -693,8 +693,10 @@ struct Interpreter {
                 return BooleanValue(value: statement.value)
             case let statement as FilterExpression:
                 return try self.evaluateFilterExpression(node: statement, environment: environment)
+            case is NullLiteral:
+                return NullValue()
             default:
-                throw JinjaError.runtime("Unknown node type: \(type(of:statement))")
+                throw JinjaError.runtime("Unknown node type: \(type(of:statement)), statement: \(String(describing: statement))")
             }
         }
         else {

Sources/Template.swift

@@ -20,6 +20,7 @@ public struct Template {
 
         try env.set(name: "false", value: false)
         try env.set(name: "true", value: true)
+        try env.set(name: "none", value: NullValue())
         try env.set(
             name: "raise_exception",
             value: { (args: String) throws in