Support constant byte array literal

.github/workflows/pull_request_full_build.yml

@@ -4,6 +4,7 @@ on:
   pull_request:
     branches:
       - master
+      - symbolEnter-revamp
 
 jobs:
   build-lang:

.github/workflows/pull_request_windows_build.yml

@@ -14,6 +14,7 @@ on:
       - 2201.[0-9]+.[0-9]+-stage
       - native-build
       - revert-client-decl-master
+      - symbolEnter-revamp
 
 jobs:
   windows_build:

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/BIRPackageSymbolEnter.java

@@ -816,6 +816,7 @@ private BLangConstantValue readConstLiteralValue(BType valueType, DataInputStrea
                 }
                 return new BLangConstantValue(keyValuePairs, valueType);
             case TypeTags.TUPLE:
+            case TypeTags.BYTE_ARRAY:
                 int tupleSize = dataInStream.readInt();
                 List<BLangConstantValue> members = new ArrayList<>(tupleSize);
                 for (int i = 0; i < tupleSize; i++) {

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmCodeGenUtil.java

@@ -245,6 +245,7 @@ public static String getFieldTypeSignature(BType bType) {
                 case TypeTags.TABLE:
                     return GET_TABLE_VALUE_IMPL;
                 case TypeTags.ARRAY:
+                case TypeTags.BYTE_ARRAY:
                 case TypeTags.TUPLE:
                     return GET_ARRAY_VALUE;
                 case TypeTags.ERROR:
@@ -744,7 +745,6 @@ public static BType getReferredType(BType type) {
 
     public static void loadConstantValue(BType bType, Object constVal, MethodVisitor mv,
                                          JvmConstantsGen jvmConstantsGen) {
-
         int typeTag = getReferredType(bType).tag;
         if (TypeTags.isIntegerTypeTag(typeTag)) {
             long intValue = constVal instanceof Long ? (long) constVal : Long.parseLong(String.valueOf(constVal));
@@ -780,6 +780,10 @@ public static void loadConstantValue(BType bType, Object constVal, MethodVisitor
                 mv.visitLdcInsn(removeDecimalDiscriminator(String.valueOf(constVal)));
                 mv.visitMethodInsn(INVOKESPECIAL, DECIMAL_VALUE, JVM_INIT_METHOD, INIT_WITH_STRING, false);
                 break;
+            case TypeTags.BYTE_ARRAY:
+                String byteArrayLiteral = String.valueOf(constVal);
+                mv.visitLdcInsn(byteArrayLiteral);
+                break;
             case TypeTags.NIL:
             case TypeTags.NEVER:
                 mv.visitInsn(ACONST_NULL);

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRTypeWriter.java

@@ -619,6 +619,7 @@ private void writeValue(Object value, BType typeOfValue) {
                 byteBuf.writeBoolean((Boolean) value);
                 break;
             case TypeTags.NIL:
+            case TypeTags.BYTE_ARRAY:
                 break;
             default:
                 throw new UnsupportedOperationException("finite type value is not supported for type: " + typeOfValue);

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java

@@ -32,6 +32,9 @@
 import org.wso2.ballerinalang.compiler.semantics.model.types.BTupleType;
 import org.wso2.ballerinalang.compiler.semantics.model.types.BType;
 import org.wso2.ballerinalang.compiler.tree.BLangConstantValue;
+import org.wso2.ballerinalang.compiler.tree.expressions.BLangExpression;
+import org.wso2.ballerinalang.compiler.tree.expressions.BLangListConstructorExpr;
+import org.wso2.ballerinalang.compiler.tree.expressions.BLangLiteral;
 import org.wso2.ballerinalang.compiler.util.Name;
 import org.wso2.ballerinalang.compiler.util.TypeTags;
 
@@ -126,6 +129,7 @@ public static void writeConstValue(ConstantPool cp, ByteBuf buf, Object value, B
                 });
                 break;
             case TypeTags.TUPLE:
+            case TypeTags.BYTE_ARRAY:
                 BIRNode.ConstValue[] tupleConstVal = (BIRNode.ConstValue[]) value;
                 buf.writeInt(tupleConstVal.length);
                 for (BIRNode.ConstValue memValue : tupleConstVal) {
@@ -242,6 +246,18 @@ public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue
             return new BIRNode.ConstValue(tupleConstVal, ((BTupleType) constValue.type).getIntersectionType().get());
         }
 
+        if (tag == TypeTags.BYTE_ARRAY) {
+            BLangListConstructorExpr.BLangArrayLiteral arrayLiteral =
+                    (BLangListConstructorExpr.BLangArrayLiteral) constValue.value;
+            List<BLangExpression> exprList = arrayLiteral.exprs;
+            BIRNode.ConstValue[] byteArrConstVal = new BIRNode.ConstValue[exprList.size()];
+            for (int exprIndex = 0; exprIndex < exprList.size(); exprIndex++) {
+                BLangLiteral expr = (BLangLiteral) exprList.get(exprIndex);
+                byteArrConstVal[exprIndex] = new BIRNode.ConstValue(expr.value, expr.getBType());
+            }
+            return new BIRNode.ConstValue(byteArrConstVal, constValue.type);
+        }
+
         return new BIRNode.ConstValue(constValue.value, constValue.type);
     }
 }

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/desugar/ConstantPropagation.java

@@ -1082,6 +1082,13 @@ public void visit(BLangSimpleVarRef varRefExpr) {
             // If the var ref is a const-ref of value type, then replace the ref
             // from a simple literal
             BType literalType = Types.getReferredType(constSymbol.literalType);
+            BType varRefType = Types.getReferredType(varRefExpr.getBType());
+
+            // Handle the assignment of int to subtypes of int (byte, int:Signed16, ...).
+            if (literalType.tag == TypeTags.INT && types.isContainSubtypeOfInt(varRefType)) {
+                literalType = varRefType;
+            }
+
             if (literalType.tag <= TypeTags.BOOLEAN || literalType.tag == TypeTags.NIL) {
                 BLangConstRef constRef = ASTBuilderUtil.createBLangConstRef(varRefExpr.pos, literalType,
                                                                             constSymbol.value.value);
@@ -1097,7 +1104,7 @@ public void visit(BLangSimpleVarRef varRefExpr) {
                     implConversionExpr.targetType = varRefExpr.impConversionExpr.targetType;
                     constRef.impConversionExpr = implConversionExpr;
                 } else {
-                    types.setImplicitCastExpr(constRef, constRef.getBType(), varRefExpr.getBType());
+                    types.setImplicitCastExpr(constRef, constRef.getBType(), varRefType);
                 }
                 result = constRef;
                 return;

compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantAnalyzer.java

@@ -17,10 +17,14 @@
  */
 package org.wso2.ballerinalang.compiler.semantics.analyzer;
 
+import io.ballerina.tools.diagnostics.Location;
 import org.ballerinalang.model.tree.NodeKind;
 import org.ballerinalang.model.tree.expressions.RecordLiteralNode;
 import org.ballerinalang.util.diagnostic.DiagnosticErrorCode;
 import org.wso2.ballerinalang.compiler.diagnostic.BLangDiagnosticLog;
+import org.wso2.ballerinalang.compiler.parser.BLangMissingNodesHelper;
+import org.wso2.ballerinalang.compiler.semantics.model.SymbolEnv;
+import org.wso2.ballerinalang.compiler.semantics.model.SymbolTable;
 import org.wso2.ballerinalang.compiler.semantics.model.symbols.BSymbol;
 import org.wso2.ballerinalang.compiler.semantics.model.symbols.SymTag;
 import org.wso2.ballerinalang.compiler.tree.BLangNodeVisitor;
@@ -35,6 +39,7 @@
 import org.wso2.ballerinalang.compiler.tree.expressions.BLangSimpleVarRef;
 import org.wso2.ballerinalang.compiler.tree.expressions.BLangUnaryExpr;
 import org.wso2.ballerinalang.compiler.util.CompilerContext;
+import org.wso2.ballerinalang.compiler.util.Names;
 
 import java.util.Stack;
 
@@ -47,12 +52,21 @@ public class ConstantAnalyzer extends BLangNodeVisitor {
 
     private static final CompilerContext.Key<ConstantAnalyzer> CONSTANT_ANALYZER_KEY =
             new CompilerContext.Key<>();
+
+    private final BLangMissingNodesHelper missingNodesHelper;
+    private final Names names;
+    private final SymbolTable symTable;
+    private final SymbolResolver symResolver;
     private BLangDiagnosticLog dlog;
     private Stack<BLangExpression> expressions = new Stack<>();
 
     private ConstantAnalyzer(CompilerContext context) {
 
         context.put(CONSTANT_ANALYZER_KEY, this);
+        this.missingNodesHelper = BLangMissingNodesHelper.getInstance(context);
+        this.names = Names.getInstance(context);
+        this.symTable = SymbolTable.getInstance(context);
+        this.symResolver = SymbolResolver.getInstance(context);
         this.dlog = BLangDiagnosticLog.getInstance(context);
     }
 
@@ -87,6 +101,16 @@ public void visit(BLangNumericLiteral literal) {
     @Override
     public void visit(BLangSimpleVarRef varRef) {
         BSymbol symbol = varRef.symbol;
+        if (varRef.pkgSymbol != symTable.notFoundSymbol && symbol == symTable.notFoundSymbol) {
+            SymbolEnv pkgEnv = symTable.pkgEnvMap.get(varRef.pkgSymbol);
+            symbol = pkgEnv == null ? symbol : symResolver.lookupMainSpaceSymbolInPackage(varRef.pos, pkgEnv,
+                    names.fromIdNode(varRef.pkgAlias), names.fromIdNode(varRef.variableName));
+        }
+
+        if (symbol == symTable.notFoundSymbol) {
+            logUndefinedSymbolError(varRef.pos, varRef.variableName.value);
+        }
+
         // Symbol can be null in some invalid scenarios. Eg - const string m = { name: "Ballerina" };
         if (symbol != null && (symbol.tag & SymTag.CONSTANT) != SymTag.CONSTANT) {
             dlog.error(varRef.pos, DiagnosticErrorCode.EXPRESSION_IS_NOT_A_CONSTANT_EXPRESSION);
@@ -111,15 +135,6 @@ public void visit(BLangRecordLiteral recordLiteral) {
 
     @Override
     public void visit(BLangBinaryExpr binaryExpr) {
-        for (int i = expressions.size() - 1; i >= 0; i--) {
-            NodeKind kind = expressions.get(i).getKind();
-            if (kind == NodeKind.GROUP_EXPR || kind == NodeKind.UNARY_EXPR) {
-                continue;
-            }
-            if (kind != NodeKind.BINARY_EXPR) {
-                dlog.error(binaryExpr.pos, DiagnosticErrorCode.CONSTANT_EXPRESSION_NOT_SUPPORTED);
-            }
-        }
         analyzeExpr(binaryExpr.lhsExpr);
         analyzeExpr(binaryExpr.rhsExpr);
     }
@@ -156,4 +171,10 @@ void analyzeExpr(BLangExpression expr) {
         }
         dlog.error(expr.pos, DiagnosticErrorCode.EXPRESSION_IS_NOT_A_CONSTANT_EXPRESSION);
     }
+
+    private void logUndefinedSymbolError(Location pos, String name) {
+        if (!missingNodesHelper.isMissingNode(name)) {
+            dlog.error(pos, DiagnosticErrorCode.UNDEFINED_SYMBOL, name);
+        }
+    }
 }