[K/JS] Add support of compilation with ES-classes

js/js.serializer/src/js-ast.proto

@@ -72,12 +72,17 @@ message Expression {
         PropertyReference property_reference = 40;
         Invocation invocation = 41;
         Instantiation instantiation = 42;
+        SuperLiteral super_literal = 43;
+        Class class = 44;
     }
 }
 
 message ThisLiteral {
 }
 
+message SuperLiteral {
+}
+
 message NullLiteral {
 }
 
@@ -111,6 +116,20 @@ message Function {
     optional int32 name_id = 2;
     required Statement body = 3;
     optional bool local = 4 [default = false];
+    repeated Modifier modifier = 5;
+
+    enum Modifier {
+        STATIC = 1;
+        GET = 2;
+        SET = 3;
+    }
+}
+
+message Class {
+    optional int32 name_id = 1;
+    optional Expression super_expression = 2;
+    optional Function constructor = 3;
+    repeated Function member = 4;
 }
 
 message Parameter {

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ast/JsAstDeserializerBase.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.serialization.js.ast
 
 import org.jetbrains.kotlin.js.backend.ast.*
 import org.jetbrains.kotlin.js.backend.ast.metadata.*
+import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import java.util.*
 
 abstract class JsAstDeserializerBase {
@@ -218,6 +219,7 @@ abstract class JsAstDeserializerBase {
 
     protected fun deserializeNoMetadataHelper(proto: JsAstProtoBuf.Expression): JsExpression = when (proto.expressionCase) {
         JsAstProtoBuf.Expression.ExpressionCase.THIS_LITERAL -> JsThisRef()
+        JsAstProtoBuf.Expression.ExpressionCase.SUPER_LITERAL -> JsSuperRef()
         JsAstProtoBuf.Expression.ExpressionCase.NULL_LITERAL -> JsNullLiteral()
         JsAstProtoBuf.Expression.ExpressionCase.TRUE_LITERAL -> JsBooleanLiteral(true)
         JsAstProtoBuf.Expression.ExpressionCase.FALSE_LITERAL -> JsBooleanLiteral(false)
@@ -251,15 +253,18 @@ abstract class JsAstDeserializerBase {
             )
         }
 
+        JsAstProtoBuf.Expression.ExpressionCase.CLASS -> {
+            val classProto = proto.class_
+            JsClass(
+                runIf(classProto.hasNameId()) { deserializeName(classProto.nameId) },
+                runIf(classProto.hasSuperExpression()) { deserialize(classProto.superExpression) as JsNameRef },
+                runIf(classProto.hasConstructor()) { deserializeFunction(classProto.constructor) },
+                classProto.memberList.map(::deserializeFunction).toMutableList()
+            )
+        }
+
         JsAstProtoBuf.Expression.ExpressionCase.FUNCTION -> {
-            val functionProto = proto.function
-            JsFunction(scope, deserialize(functionProto.body) as JsBlock, "").apply {
-                parameters += functionProto.parameterList.map { deserializeParameter(it) }
-                if (functionProto.hasNameId()) {
-                    name = deserializeName(functionProto.nameId)
-                }
-                isLocal = functionProto.local
-            }
+            deserializeFunction(proto.function)
         }
 
         JsAstProtoBuf.Expression.ExpressionCase.DOC_COMMENT -> {
@@ -345,6 +350,17 @@ abstract class JsAstDeserializerBase {
         JsAstProtoBuf.Expression.ExpressionCase.EXPRESSION_NOT_SET -> error("Unknown expression")
     }
 
+    protected fun deserializeFunction(functionProto: JsAstProtoBuf.Function): JsFunction {
+        return JsFunction(scope, deserialize(functionProto.body) as JsBlock, "").apply {
+            modifiers += functionProto.modifierList.map(::map)
+            parameters += functionProto.parameterList.map { deserializeParameter(it) }
+            if (functionProto.hasNameId()) {
+                name = deserializeName(functionProto.nameId)
+            }
+            isLocal = functionProto.local
+        }
+    }
+
     protected fun deserializeVars(proto: JsAstProtoBuf.Vars): JsVars {
         val vars = JsVars(proto.multiline)
         for (declProto in proto.declarationList) {
@@ -406,6 +422,12 @@ abstract class JsAstDeserializerBase {
 
     protected fun deserializeString(id: Int): String = stringTable[id]
 
+    protected fun map(modifier: JsAstProtoBuf.Function.Modifier) = when (modifier) {
+        JsAstProtoBuf.Function.Modifier.STATIC -> JsFunction.Modifier.STATIC
+        JsAstProtoBuf.Function.Modifier.SET -> JsFunction.Modifier.SET
+        JsAstProtoBuf.Function.Modifier.GET -> JsFunction.Modifier.GET
+    }
+
     protected fun map(op: JsAstProtoBuf.BinaryOperation.Type) = when (op) {
         JsAstProtoBuf.BinaryOperation.Type.MUL -> JsBinaryOperator.MUL
         JsAstProtoBuf.BinaryOperation.Type.DIV -> JsBinaryOperator.DIV

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/ast/JsAstSerializerBase.kt

@@ -199,6 +199,10 @@ abstract class JsAstSerializerBase {
                 builder.thisLiteral = JsAstProtoBuf.ThisLiteral.newBuilder().build()
             }
 
+            override fun visitSuper(x: JsSuperRef) {
+                builder.superLiteral = JsAstProtoBuf.SuperLiteral.newBuilder().build()
+            }
+
             override fun visitNull(x: JsNullLiteral) {
                 builder.nullLiteral = JsAstProtoBuf.NullLiteral.newBuilder().build()
             }
@@ -249,14 +253,16 @@ abstract class JsAstSerializerBase {
             }
 
             override fun visitFunction(x: JsFunction) {
-                val functionBuilder = JsAstProtoBuf.Function.newBuilder()
-                x.parameters.forEach { functionBuilder.addParameter(serializeParameter(it)) }
-                x.name?.let { functionBuilder.nameId = serialize(it) }
-                functionBuilder.body = serialize(x.body)
-                if (x.isLocal) {
-                    functionBuilder.local = true
-                }
-                builder.function = functionBuilder.build()
+                builder.function = serializeFunction(x)
+            }
+
+            override fun visitClass(x: JsClass) {
+                val classBuilder = JsAstProtoBuf.Class.newBuilder()
+                x.name?.let { classBuilder.nameId = serialize(it) }
+                x.baseClass?.let { classBuilder.superExpression = serialize(it) }
+                x.constructor?.let { classBuilder.constructor = serializeFunction(it) }
+                x.members.forEach { classBuilder.addMember(serializeFunction(it)) }
+                builder.class_ = classBuilder.build()
             }
 
             override fun visitDocComment(comment: JsDocComment) {
@@ -392,6 +398,19 @@ abstract class JsAstSerializerBase {
         return blockBuilder.build()
     }
 
+    protected fun serializeFunction(function: JsFunction): JsAstProtoBuf.Function {
+        val functionBuilder = JsAstProtoBuf.Function.newBuilder()
+        function.parameters.forEach { functionBuilder.addParameter(serializeParameter(it)) }
+        function.modifiers.forEach { functionBuilder.addModifier(map(it)) }
+        function.name?.let { functionBuilder.nameId = serialize(it) }
+        functionBuilder.body = serialize(function.body)
+        if (function.isLocal) {
+            functionBuilder.local = true
+        }
+        return functionBuilder.build()
+    }
+
+
     protected fun serializeVars(vars: JsVars): JsAstProtoBuf.Vars {
         val varsBuilder = JsAstProtoBuf.Vars.newBuilder()
         for (varDecl in vars.vars) {
@@ -419,6 +438,12 @@ abstract class JsAstSerializerBase {
         return unaryBuilder.build()
     }
 
+    protected fun map(modifier: JsFunction.Modifier) = when (modifier) {
+        JsFunction.Modifier.STATIC -> JsAstProtoBuf.Function.Modifier.STATIC
+        JsFunction.Modifier.SET -> JsAstProtoBuf.Function.Modifier.SET
+        JsFunction.Modifier.GET -> JsAstProtoBuf.Function.Modifier.GET
+    }
+
     protected fun map(op: JsBinaryOperator) = when (op) {
         JsBinaryOperator.MUL -> JsAstProtoBuf.BinaryOperation.Type.MUL
         JsBinaryOperator.DIV -> JsAstProtoBuf.BinaryOperation.Type.DIV