feat: support element access of enum (#2950)

Author: HerrCai0907

src/common.ts

@@ -194,6 +194,8 @@ export namespace CommonNames{
 exportconstASC_VERSION_MAJOR="ASC_VERSION_MAJOR";
 exportconstASC_VERSION_MINOR="ASC_VERSION_MINOR";
 exportconstASC_VERSION_PATCH="ASC_VERSION_PATCH";
+// enums
+exportconstEnumToString="__enum_to_string";
 // classes
 exportconstI8="I8";
 exportconstI16="I16";

src/compiler.ts

@@ -1522,6 +1522,49 @@ export class Compiler extends DiagnosticEmitter{
 returntrue;
 }
 
+privateensureEnumToString(enumElement: Enum,reportNode: Node): string|null{
+if(enumElement.toStringFunctionName)returnenumElement.toStringFunctionName;
+
+if(!this.compileEnum(enumElement))returnnull;
+if(enumElement.is(CommonFlags.Const)){
+this.errorRelated(
+DiagnosticCode.A_const_enum_member_can_only_be_accessed_using_a_string_literal,
+reportNode.range,enumElement.identifierNode.range
+);
+returnnull;
+}
+
+letmembers=enumElement.members;
+if(!members)returnnull;
+
+letmodule=this.module;
+constisInline=enumElement.hasDecorator(DecoratorFlags.Inline);
+
+constfunctionName=`${enumElement.internalName}#${CommonNames.EnumToString}`;
+enumElement.toStringFunctionName=functionName;
+
+letexprs=newArray<ExpressionRef>();
+// when the values are the same, TS returns the last enum value name that appears
+for(let_keys=Map_keys(members),_values=Map_values(members),i=1,k=_keys.length;i<=k;++i){
+letenumValueName=unchecked(_keys[k-i]);
+letmember=unchecked(_values[k-i]);
+if(member.kind!=ElementKind.EnumValue)continue;
+letenumValue=<EnumValue>member;
+constenumValueExpr=isInline
+ ? module.i32(i64_low(enumValue.constantIntegerValue))
+ : module.global_get(enumValue.internalName,TypeRef.I32);
+letexpr=module.if(
+module.binary(BinaryOp.EqI32,enumValueExpr,module.local_get(0,TypeRef.I32)),
+module.return(this.ensureStaticString(enumValueName))
+);
+exprs.push(expr);
+}
+exprs.push(module.unreachable());
+module.addFunction(functionName,TypeRef.I32,TypeRef.I32,null,module.block(null,exprs,TypeRef.I32));
+
+returnfunctionName;
+}
+
 // === Functions ================================================================================
 
 /** Compiles a priorly resolved function. */
@@ -7092,7 +7135,17 @@ export class Compiler extends DiagnosticEmitter{
 ): ExpressionRef{
 letmodule=this.module;
 lettargetExpression=expression.expression;
-lettargetType=this.resolver.resolveExpression(targetExpression,this.currentFlow);// reports
+letresolver=this.resolver;
+lettargetElement=resolver.lookupExpression(targetExpression,this.currentFlow,Type.auto,ReportMode.Swallow);
+if(targetElement&&targetElement.kind==ElementKind.Enum){
+constelementExpr=this.compileExpression(expression.elementExpression,Type.i32,Constraints.ConvImplicit);
+consttoStringFunctionName=this.ensureEnumToString(<Enum>targetElement,expression);
+this.currentType=this.program.stringInstance.type;
+if(toStringFunctionName==null)returnmodule.unreachable();
+returnmodule.call(toStringFunctionName,[elementExpr],TypeRef.I32);
+}
+
+lettargetType=resolver.resolveExpression(targetExpression,this.currentFlow);
 if(targetType){
 letclassReference=targetType.getClassOrWrapper(this.program);
 if(classReference){

src/diagnosticMessages.json

@@ -174,6 +174,7 @@
 "Type '{0}' has no property '{1}'.": 2460,
 "The '{0}' operator cannot be applied to type '{1}'.": 2469,
 "In 'const' enum declarations member initializer must be constant expression.": 2474,
+"A const enum member can only be accessed using a string literal.": 2476,
 "Export declaration conflicts with exported declaration of '{0}'.": 2484,
 "'{0}' is referenced directly or indirectly in its own base expression.": 2506,
 "Cannot create an instance of an abstract class.": 2511,

src/program.ts

@@ -3449,7 +3449,7 @@ export class Namespace extends DeclaredElement{
 
 /** An enum. */
 exportclassEnumextendsTypedElement{
-
+toStringFunctionName: string|null=null;
 /** Constructs a new enum. */
 constructor(
 /** Simple name. */

tests/compiler/enum-to-string-error.json

@@ -0,0 +1,7 @@
+{
+"asc_flags": [],
+"stderr": [
+"TS2476: A const enum member can only be accessed using a string literal.",
+"EOF"
+ ]
+}

tests/compiler/enum-to-string-error.ts

@@ -0,0 +1,9 @@
+constenumCE{
+CE0,
+CE1,
+CE2,
+}
+
+assert(CE[CE.CE0]==="CE0");
+
+ERROR("EOF");