[ENHANCEMENT] Allow interfaces to be parsed and no longer throw errors when they exist in scripts.

polymod/hscript/_internal/Expr.hx

@@ -146,6 +146,7 @@ ECustom(msg:String);
   DClass(c:ClassDecl);
   DTypedef(c:TypeDecl);
   DEnum(e:EnumDecl);
+  DInterface(e:InterfaceDecl);
 }
 
 typedef ModuleType =
@@ -189,6 +190,14 @@ typedef TypeDecl =
   var t:CType;
 }
 
+typedef InterfaceDecl =
+{
+  > ModuleType,
+  var extend:Array<CType>;
+  var fields:Array<FieldDecl>;
+  var isExtern:Bool;
+}
+
 typedef FieldDecl =
 {
   var name:String;

polymod/hscript/_internal/Parser.hx

@@ -1457,6 +1457,39 @@ class Parser
             name: name,
             fields: fields
           });
+      case "interface":
+        var name = getIdent();
+        var params = parseParams();
+        var extend = [];
+
+        while (true)
+        {
+          var t = token();
+          switch (t)
+          {
+            case TId("extends"):
+              extend.push(parseType());
+            default:
+              push(t);
+              break;
+          }
+        }
+
+        var fields = [];
+        ensure(TBrOpen);
+        while (!maybe(TBrClose))
+          fields.push(parseInterfaceField());
+
+        return DInterface(
+          {
+            name: name,
+            meta: meta,
+            params: params,
+            isPrivate: isPrivate,
+            extend: extend,
+            fields: fields,
+            isExtern: isExtern,
+          });
       default:
         unexpected(TId(ident));
     }
@@ -1545,6 +1578,85 @@ class Parser
     return null;
   }
 
+  function parseInterfaceField():FieldDecl
+  {
+    var meta = parseMetadata();
+    var access = [];
+    while (true)
+    {
+      var id = getIdent();
+      switch (id)
+      {
+        case "public":
+          access.push(APublic);
+        case "private":
+          access.push(APrivate);
+        case "static":
+          access.push(AStatic);
+        case "function":
+          var name = getIdent();
+          ensure(TPOpen);
+          var args = parseFunctionArgs();
+          var ret = null;
+          if (allowTypes)
+          {
+            var tk = token();
+            if (tk != TDoubleDot) push(tk);
+            else
+              ret = parseType();
+          }
+          ensure(TSemicolon);
+          return {
+            name: name,
+            meta: meta,
+            access: access,
+            kind: KFunction(
+              {
+                args: args,
+                expr: null,
+                ret: ret,
+              }),
+          };
+        case "var", "final":
+          var name = getIdent();
+          var get = null, set = null;
+          if (maybe(TPOpen))
+          {
+            get = getIdent();
+            ensure(TComma);
+            set = getIdent();
+            ensure(TPClose);
+          }
+          var type = maybe(TDoubleDot) ? parseType() : null;
+
+          if (type != null && type.match(CTAnon(_)))
+          {
+            maybe(TSemicolon);
+          }
+          else
+            ensure(TSemicolon);
+
+          return {
+            name: name,
+            meta: meta,
+            access: access,
+            kind: KVar(
+              {
+                get: get,
+                set: set,
+                type: type,
+                expr: null,
+                isfinal: (id == "final")
+              }),
+          };
+        default:
+          unexpected(TId(id));
+          break;
+      }
+    }
+    return null;
+  }
+
   function parseEnumField():EnumFieldDecl
   {
     var name = getIdent();

polymod/hscript/_internal/PolymodInterpEx.hx

@@ -1964,6 +1964,7 @@ class PolymodInterpEx extends Interp
 
 					registerScriptEnum(enumDecl);
 				case DTypedef(_):
+				case DInterface(_):
 			}
 		}
 	}