From 17a928ff0d7c2fc21ec9788f1becd33126221a27 Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Mon, 10 Jul 2023 12:31:44 +0530 Subject: [PATCH 1/7] Reduce creating type defns for const annotations --- .../compiler/bir/writer/BIRWriterUtils.java | 19 +++++++++----- .../analyzer/ConstantValueResolver.java | 25 +++++++++++++++---- .../annotations/DisplayAnnotationTest.java | 2 +- .../test/bala/annotation/AnnotationTests.java | 7 +----- 4 files changed, 35 insertions(+), 18 deletions(-) diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java index d9727b0f949e..0e718d0d80db 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java @@ -220,17 +220,22 @@ public static BIRNode.BIRAnnotationAttachment createBIRAnnotationAttachment( } public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue) { - int tag = constValue.type.tag; + BType refferedType = Types.getReferredType(constValue.type); + int tag = refferedType.tag; + boolean isIntersection = false; if (tag == TypeTags.INTERSECTION) { - constValue.type = ((BIntersectionType) constValue.type).effectiveType; - tag = constValue.type.tag; + refferedType = ((BIntersectionType) refferedType).effectiveType; + tag = refferedType.tag; + isIntersection = true; } if (tag == TypeTags.RECORD) { Map mapConstVal = new HashMap<>(); ((Map) constValue.value) .forEach((key, value) -> mapConstVal.put(key, getBIRConstantVal(value))); - return new BIRNode.ConstValue(mapConstVal, ((BRecordType) constValue.type).getIntersectionType().get()); + return isIntersection ? + new BIRNode.ConstValue(mapConstVal, ((BRecordType) refferedType).getIntersectionType().get()) + : new BIRNode.ConstValue(mapConstVal, refferedType); } if (tag == TypeTags.TUPLE) { @@ -239,9 +244,11 @@ public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue for (int exprIndex = 0; exprIndex < constantValueList.size(); exprIndex++) { tupleConstVal[exprIndex] = getBIRConstantVal(constantValueList.get(exprIndex)); } - return new BIRNode.ConstValue(tupleConstVal, ((BTupleType) constValue.type).getIntersectionType().get()); + return isIntersection ? + new BIRNode.ConstValue(tupleConstVal, ((BTupleType) refferedType).getIntersectionType().get()) + : new BIRNode.ConstValue(tupleConstVal, refferedType); } - return new BIRNode.ConstValue(constValue.value, constValue.type); + return new BIRNode.ConstValue(constValue.value, refferedType); } } diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java index f0c68289294c..d92673835337 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java @@ -85,6 +85,7 @@ import java.util.Stack; import java.util.function.BiFunction; +import static org.ballerinalang.model.symbols.SymbolOrigin.SOURCE; import static org.ballerinalang.model.symbols.SymbolOrigin.VIRTUAL; /** @@ -666,8 +667,8 @@ private void updateConstantType(BConstantSymbol symbol, BLangExpression expr, Sy return; } - if (resolvedType.getKind() == TypeKind.INTERSECTION && isListOrMapping(type.tag)) { - expr.setBType(((BIntersectionType) resolvedType).effectiveType); + if (resolvedType.getKind() == TypeKind.RECORD && isListOrMapping(type.tag)) { + expr.setBType(resolvedType); symbol.type = resolvedType; symbol.literalType = resolvedType; symbol.value.type = resolvedType; @@ -845,9 +846,23 @@ private BType createRecordType(BLangExpression expr, BConstantSymbol constantSym } createTypeDefinition(recordType, pos, env); - BIntersectionType intersectionType = ImmutableTypeCloner.getImmutableIntersectionType(pos, types, - recordType, env, symTable, anonymousModelHelper, names, new HashSet<>()); - return intersectionType; + updateRecordFields(recordType, pos, env); + recordType.tsymbol.flags |= Flags.READONLY; + recordType.flags |= Flags.READONLY; + return recordType; + } + + private void updateRecordFields(BRecordType recordType, Location pos, SymbolEnv env) { + BTypeSymbol structureSymbol = recordType.tsymbol; + for (BField field : recordType.fields.values()) { + field.type = ImmutableTypeCloner.getImmutableType(pos, types, field.type, env, + pkgID, env.scope.owner, symTable, anonymousModelHelper, names, + new HashSet<>()); + Name fieldName = field.symbol.name; + field.symbol = new BVarSymbol(field.symbol.flags | Flags.READONLY, fieldName, + pkgID, field.type, structureSymbol, pos, SOURCE); + structureSymbol.scope.define(fieldName, field.symbol); + } } private boolean populateRecordFields(BLangExpression expr, BConstantSymbol constantSymbol, Location pos, diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/annotations/DisplayAnnotationTest.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/annotations/DisplayAnnotationTest.java index adb7d514e159..7b97ddcd707a 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/annotations/DisplayAnnotationTest.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/annotations/DisplayAnnotationTest.java @@ -90,7 +90,7 @@ public void testDisplayAnnotOnObjectAndMemberFunction() { @Test public void testDisplayAnnotOnRecord() { - TypeDefinition typeDefinition = result.getAST().getTypeDefinitions().get(23); + TypeDefinition typeDefinition = result.getAST().getTypeDefinitions().get(13); List annot = typeDefinition.getAnnotationAttachments(); Assert.assertEquals(annot.size(), 1); Assert.assertEquals(annot.get(0).getExpression().toString(), diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java index 68c04f5fc95c..38597644ff0f 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java @@ -278,10 +278,7 @@ public void testParamAnnotAttachmentsViaBir() { Assert.assertEquals(mapValue.size(), 1); Assert.assertEquals(mapValue.get("i").value, 1L); BType type = constAttachmentSymbol.attachmentValueSymbol.type; - Assert.assertEquals(type.tag, TypeTags.INTERSECTION); - BIntersectionType intersectionType = (BIntersectionType) type; - BType effectiveType = intersectionType.effectiveType; - Assert.assertEquals(effectiveType.tag, TypeTags.RECORD); + Assert.assertEquals(type.tag, TypeTags.RECORD); params = detachMethod.symbol.params; annotationAttachmentSymbols = params.get(0).getAnnotations(); @@ -303,8 +300,6 @@ public void testParamAnnotAttachmentsViaBir() { Assert.assertEquals(mapValue.size(), 1); Assert.assertTrue(members.remove(mapValue.get("i").value)); type = constAttachmentSymbol.attachmentValueSymbol.type; - Assert.assertEquals(type.tag, TypeTags.INTERSECTION); - type = ((BIntersectionType) type).effectiveType; Assert.assertEquals(type.tag, TypeTags.RECORD); } } From 9158364945cea1ddb32112fa58e7b89d909b0887 Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Tue, 11 Jul 2023 08:41:01 +0530 Subject: [PATCH 2/7] Update failing tests --- .../ConstAnnotationAttachmentSymbolTest.java | 16 +++++----------- .../api/test/symbols/ConstDeclSymbolTest.java | 16 +++++----------- 2 files changed, 10 insertions(+), 22 deletions(-) diff --git a/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstAnnotationAttachmentSymbolTest.java b/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstAnnotationAttachmentSymbolTest.java index 82cbdace2ddb..d32ac10fa8eb 100644 --- a/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstAnnotationAttachmentSymbolTest.java +++ b/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstAnnotationAttachmentSymbolTest.java @@ -21,7 +21,6 @@ import io.ballerina.compiler.api.SemanticModel; import io.ballerina.compiler.api.impl.values.BallerinaConstantValue; import io.ballerina.compiler.api.symbols.AnnotationAttachmentSymbol; -import io.ballerina.compiler.api.symbols.IntersectionTypeSymbol; import io.ballerina.compiler.api.symbols.MemberTypeSymbol; import io.ballerina.compiler.api.symbols.RecordTypeSymbol; import io.ballerina.compiler.api.symbols.Symbol; @@ -80,14 +79,11 @@ public void testValuesInConstantAnnotationAttachment() { ConstantValue constVal = annotAttachment.attachmentValue().get(); // Test type-descriptor - assertEquals(constVal.valueType().typeKind(), TypeDescKind.INTERSECTION); - assertEquals(((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(0).typeKind(), - TypeDescKind.RECORD); - assertEquals(((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(1).typeKind(), - TypeDescKind.READONLY); + assertEquals(constVal.valueType().typeKind(), TypeDescKind.RECORD); RecordTypeSymbol recTypeSymbol = - (RecordTypeSymbol) ((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(0); - assertEquals(recTypeSymbol.signature(), "record {|1 id; record {|1 a; 2 b;|} perm;|}"); + (RecordTypeSymbol) constVal.valueType(); + assertEquals(recTypeSymbol.signature(), "record {|readonly 1 id; readonly record " + + "{|readonly 1 a; readonly 2 b;|} perm;|}"); // Test const value assertTrue(constVal.value() instanceof HashMap); @@ -101,9 +97,7 @@ public void testValuesInConstantAnnotationAttachment() { assertTrue(valueMap.get("perm") instanceof BallerinaConstantValue); BallerinaConstantValue permValue = (BallerinaConstantValue) valueMap.get("perm"); - assertEquals(permValue.valueType().typeKind(), TypeDescKind.INTERSECTION); - assertEquals(((IntersectionTypeSymbol) permValue.valueType()).effectiveTypeDescriptor().typeKind(), - TypeDescKind.RECORD); + assertEquals(permValue.valueType().typeKind(), TypeDescKind.RECORD); assertTrue(permValue.value() instanceof HashMap); HashMap permMap = (HashMap) permValue.value(); assertEquals(((BallerinaConstantValue) permMap.get("a")).value(), 1L); diff --git a/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstDeclSymbolTest.java b/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstDeclSymbolTest.java index f4bb23475198..40d797784ea1 100644 --- a/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstDeclSymbolTest.java +++ b/tests/ballerina-compiler-api-test/src/test/java/io/ballerina/semantic/api/test/symbols/ConstDeclSymbolTest.java @@ -24,7 +24,6 @@ import io.ballerina.compiler.api.symbols.AnnotationSymbol; import io.ballerina.compiler.api.symbols.ConstantSymbol; import io.ballerina.compiler.api.symbols.Documentation; -import io.ballerina.compiler.api.symbols.IntersectionTypeSymbol; import io.ballerina.compiler.api.symbols.Qualifier; import io.ballerina.compiler.api.symbols.RecordTypeSymbol; import io.ballerina.compiler.api.symbols.Symbol; @@ -160,14 +159,11 @@ public void testValuesInConstantAnnotationAttachment() { ConstantValue constVal = annotAttachment.attachmentValue().get(); // Test type-descriptor - assertEquals(constVal.valueType().typeKind(), TypeDescKind.INTERSECTION); - assertEquals(((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(0).typeKind(), - TypeDescKind.RECORD); - assertEquals(((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(1).typeKind(), - TypeDescKind.READONLY); + assertEquals(constVal.valueType().typeKind(), TypeDescKind.RECORD); RecordTypeSymbol recTypeSymbol = - (RecordTypeSymbol) ((IntersectionTypeSymbol) constVal.valueType()).memberTypeDescriptors().get(0); - assertEquals(recTypeSymbol.signature(), "record {|1 id; record {|1 a; 2 b;|} perm;|}"); + (RecordTypeSymbol) constVal.valueType(); + assertEquals(recTypeSymbol.signature(), "record {|readonly 1 id; readonly record " + + "{|readonly 1 a; readonly 2 b;|} perm;|}"); // Test const value assertTrue(constVal.value() instanceof HashMap); @@ -182,9 +178,7 @@ public void testValuesInConstantAnnotationAttachment() { assertTrue(valueMap.get("perm") instanceof BallerinaConstantValue); BallerinaConstantValue permValue = (BallerinaConstantValue) valueMap.get("perm"); - assertEquals(permValue.valueType().typeKind(), TypeDescKind.INTERSECTION); - assertEquals(((IntersectionTypeSymbol) permValue.valueType()).effectiveTypeDescriptor().typeKind(), - TypeDescKind.RECORD); + assertEquals(permValue.valueType().typeKind(), TypeDescKind.RECORD); assertTrue(permValue.value() instanceof HashMap); HashMap permMap = (HashMap) permValue.value(); assertEquals(((BallerinaConstantValue) permMap.get("a")).value(), 1L); From ca9413d98c3a2fbb4ce9519f348e0e17c8148703 Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Tue, 11 Jul 2023 12:41:02 +0530 Subject: [PATCH 3/7] Fix SpotBugs failure --- .../compiler/bir/writer/BIRWriterUtils.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java index 0e718d0d80db..546fd9e02e3e 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java @@ -220,12 +220,12 @@ public static BIRNode.BIRAnnotationAttachment createBIRAnnotationAttachment( } public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue) { - BType refferedType = Types.getReferredType(constValue.type); - int tag = refferedType.tag; + BType constValType = constValue.type; + int tag = constValue.type.tag; boolean isIntersection = false; - if (tag == TypeTags.INTERSECTION) { - refferedType = ((BIntersectionType) refferedType).effectiveType; - tag = refferedType.tag; + if (constValType.tag == TypeTags.INTERSECTION) { + constValType = ((BIntersectionType) constValType).effectiveType; + tag = constValType.tag; isIntersection = true; } @@ -234,8 +234,8 @@ public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue ((Map) constValue.value) .forEach((key, value) -> mapConstVal.put(key, getBIRConstantVal(value))); return isIntersection ? - new BIRNode.ConstValue(mapConstVal, ((BRecordType) refferedType).getIntersectionType().get()) - : new BIRNode.ConstValue(mapConstVal, refferedType); + new BIRNode.ConstValue(mapConstVal, ((BRecordType) constValType).getIntersectionType().get()) + : new BIRNode.ConstValue(mapConstVal, constValType); } if (tag == TypeTags.TUPLE) { @@ -245,10 +245,10 @@ public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue tupleConstVal[exprIndex] = getBIRConstantVal(constantValueList.get(exprIndex)); } return isIntersection ? - new BIRNode.ConstValue(tupleConstVal, ((BTupleType) refferedType).getIntersectionType().get()) - : new BIRNode.ConstValue(tupleConstVal, refferedType); + new BIRNode.ConstValue(tupleConstVal, ((BTupleType) constValType).getIntersectionType().get()) + : new BIRNode.ConstValue(tupleConstVal, constValType); } - return new BIRNode.ConstValue(constValue.value, refferedType); + return new BIRNode.ConstValue(constValue.value, constValType); } } From 87301b8f7529038d99392160f32867a40fbe73bf Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Tue, 11 Jul 2023 12:51:14 +0530 Subject: [PATCH 4/7] Remove typeDefinition for source annotation in jar --- .../compiler/bir/codegen/JvmPackageGen.java | 5 +++++ .../semantics/analyzer/ConstantValueResolver.java | 9 +++++++-- .../semantics/analyzer/SymbolResolver.java | 14 ++++++++++++-- .../java/org/wso2/ballerinalang/util/Flags.java | 1 + 4 files changed, 25 insertions(+), 4 deletions(-) diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java index 319e80eb2d28..fe2ca9923003 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java @@ -785,6 +785,7 @@ CompiledJarFile generate(BIRPackage module, boolean isEntry) { // generate the shutdown listener class. new ShutDownListenerGen().generateShutdownSignalListener(moduleInitClass, jarEntries); + removeSourceAnnotationTypeDefs(module.typeDefs); // desugar the record init function rewriteRecordInits(module.typeDefs); @@ -811,6 +812,10 @@ CompiledJarFile generate(BIRPackage module, boolean isEntry) { return new CompiledJarFile(getModuleLevelClassName(module.packageID, MODULE_INIT_CLASS_NAME, "."), jarEntries); } + private void removeSourceAnnotationTypeDefs(List typeDefs) { + typeDefs.removeIf(def -> Symbols.isFlagOn(def.flags, Flags.SOURCE_ANNOTATION)); + } + private BIRFunction getMainFunction(BIRPackage module) { BIRFunction mainFunc = null; if (module.packageID.skipTests) { diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java index d92673835337..29bd869a23c0 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java @@ -565,12 +565,13 @@ private BLangConstantValue calculateBooleanComplement(BLangConstantValue value) BLangConstantValue constructBLangConstantValueWithExactType(BLangExpression expression, BConstantSymbol constantSymbol, SymbolEnv env) { - return constructBLangConstantValueWithExactType(expression, constantSymbol, env, new Stack<>()); + return constructBLangConstantValueWithExactType(expression, constantSymbol, env, new Stack<>(), false); } BLangConstantValue constructBLangConstantValueWithExactType(BLangExpression expression, BConstantSymbol constantSymbol, SymbolEnv env, - Stack anonTypeNameSuffixes) { + Stack anonTypeNameSuffixes, + boolean isSourceOnlyAnon) { BLangConstantValue value = constructBLangConstantValue(expression); constantSymbol.value = value; @@ -580,6 +581,10 @@ BLangConstantValue constructBLangConstantValueWithExactType(BLangExpression expr this.anonTypeNameSuffixes = anonTypeNameSuffixes; updateConstantType(constantSymbol, expression, env); + BLangTypeDefinition typeDefinition = createdTypeDefinitions.get(constantSymbol.type.tsymbol); + if (isSourceOnlyAnon && typeDefinition != null) { + typeDefinition.symbol.flags |= Flags.SOURCE_ANNOTATION; + } return value; } diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/SymbolResolver.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/SymbolResolver.java index 0cb70e0aad9a..85693a7b62c4 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/SymbolResolver.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/SymbolResolver.java @@ -20,6 +20,7 @@ import io.ballerina.tools.diagnostics.DiagnosticCode; import io.ballerina.tools.diagnostics.Location; import org.ballerinalang.model.TreeBuilder; +import org.ballerinalang.model.elements.AttachPoint; import org.ballerinalang.model.elements.Flag; import org.ballerinalang.model.elements.PackageID; import org.ballerinalang.model.symbols.SymbolKind; @@ -2552,7 +2553,7 @@ public void populateAnnotationAttachmentSymbol(BLangAnnotationAttachment annotat attachedType = Types.getReferredType(attachedType); attachedType = attachedType.tag == TypeTags.ARRAY ? ((BArrayType) attachedType).eType : attachedType; } - + boolean isSourceOnlyAnon = isSourceAnonOnly(annotationSymbol.points); BConstantSymbol constantSymbol = new BConstantSymbol(0, Names.EMPTY, Names.EMPTY, env.enclPkg.packageID, attachedType, attachedType, env.scope.owner, annotationAttachment.pos, VIRTUAL); @@ -2575,7 +2576,7 @@ public void populateAnnotationAttachmentSymbol(BLangAnnotationAttachment annotat } } else { constAnnotationValue = constantValueResolver.constructBLangConstantValueWithExactType(expr, constantSymbol, - env, anonTypeNameSuffixes); + env, anonTypeNameSuffixes, isSourceOnlyAnon); } constantSymbol.type = constAnnotationValue.type; @@ -2588,6 +2589,15 @@ public void populateAnnotationAttachmentSymbol(BLangAnnotationAttachment annotat constantSymbol); } + private boolean isSourceAnonOnly(Set attachPoints) { + for (AttachPoint attachPoint : attachPoints) { + if (!attachPoint.source) { + return false; + } + } + return true; + } + public Set getConfigVarSymbolsIncludingImportedModules(BPackageSymbol packageSymbol) { Set configVars = new HashSet<>(); populateConfigurableVars(packageSymbol, configVars); diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java index ccc9cf1dc1c9..a1dfdd6d0b99 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java @@ -82,6 +82,7 @@ public class Flags { public static final long ENUM_MEMBER = INFER << 1; // 41 public static final long QUERY_LAMBDA = ENUM_MEMBER << 1; // 42 public static final long EFFECTIVE_TYPE_DEF = QUERY_LAMBDA << 1; // 43 + public static final long SOURCE_ANNOTATION = EFFECTIVE_TYPE_DEF << 1; // 44 public static long asMask(Set flagSet) { long mask = 0; From ae1ad75ebabca1a7f2acc2e385d47bfed07ba101 Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Wed, 12 Jul 2023 11:05:21 +0530 Subject: [PATCH 5/7] Fix BIRSpecTest failures --- docs/bir-spec/src/main/resources/kaitai/bir.ksy | 1 + .../test/java/org/ballerinalang/birspec/BIRTestUtils.java | 7 ++++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/docs/bir-spec/src/main/resources/kaitai/bir.ksy b/docs/bir-spec/src/main/resources/kaitai/bir.ksy index 08b726b9034b..0fd03ee4748d 100644 --- a/docs/bir-spec/src/main/resources/kaitai/bir.ksy +++ b/docs/bir-spec/src/main/resources/kaitai/bir.ksy @@ -723,6 +723,7 @@ types: 'type_tag_enum::type_tag_decimal': decimal_constant_info 'type_tag_enum::type_tag_boolean': boolean_constant_info 'type_tag_enum::type_tag_nil': nil_constant_info + 'type_tag_enum::type_tag_record': map_constant_info 'type_tag_enum::type_tag_intersection': intersection_constant_info instances: type: diff --git a/docs/bir-spec/src/test/java/org/ballerinalang/birspec/BIRTestUtils.java b/docs/bir-spec/src/test/java/org/ballerinalang/birspec/BIRTestUtils.java index 34ccdcdf18c1..1c0b93339202 100644 --- a/docs/bir-spec/src/test/java/org/ballerinalang/birspec/BIRTestUtils.java +++ b/docs/bir-spec/src/test/java/org/ballerinalang/birspec/BIRTestUtils.java @@ -742,8 +742,13 @@ private static void assertConstantValue(Bir.ConstantValue actualConstantValue, O Assert.assertEquals(booleanConstantInfo.valueBooleanConstant() == 1, expectedValue); break; case TYPE_TAG_RECORD: - Bir.MapConstantInfo actualMapConst = + Bir.MapConstantInfo actualMapConst; + if (constantValueInfo instanceof Bir.MapConstantInfo) { + actualMapConst = (Bir.MapConstantInfo) constantValueInfo; + } else { + actualMapConst = (Bir.MapConstantInfo) ((Bir.IntersectionConstantInfo) constantValueInfo).constantValueInfo(); + } Map expectedMapConst = (Map) expectedValue; Assert.assertEquals(actualMapConst.mapConstantSize(), expectedMapConst.size()); break; From e6260300ee876d0e370ba9fae0b01c501a4483be Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Wed, 12 Jul 2023 14:49:46 +0530 Subject: [PATCH 6/7] Remove unwanted changes to fix list const tests --- .../ballerinalang/compiler/bir/writer/BIRWriterUtils.java | 4 +--- .../ballerinalang/test/bala/annotation/AnnotationTests.java | 1 - 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java index 546fd9e02e3e..94a39e5f0df5 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/writer/BIRWriterUtils.java @@ -244,9 +244,7 @@ public static BIRNode.ConstValue getBIRConstantVal(BLangConstantValue constValue for (int exprIndex = 0; exprIndex < constantValueList.size(); exprIndex++) { tupleConstVal[exprIndex] = getBIRConstantVal(constantValueList.get(exprIndex)); } - return isIntersection ? - new BIRNode.ConstValue(tupleConstVal, ((BTupleType) constValType).getIntersectionType().get()) - : new BIRNode.ConstValue(tupleConstVal, constValType); + return new BIRNode.ConstValue(tupleConstVal, ((BTupleType) constValType).getIntersectionType().get()); } return new BIRNode.ConstValue(constValue.value, constValType); diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java index 38597644ff0f..28eee157944c 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/bala/annotation/AnnotationTests.java @@ -37,7 +37,6 @@ import org.wso2.ballerinalang.compiler.semantics.model.symbols.BTypeDefinitionSymbol; import org.wso2.ballerinalang.compiler.semantics.model.symbols.BVarSymbol; import org.wso2.ballerinalang.compiler.semantics.model.types.BField; -import org.wso2.ballerinalang.compiler.semantics.model.types.BIntersectionType; import org.wso2.ballerinalang.compiler.semantics.model.types.BRecordType; import org.wso2.ballerinalang.compiler.semantics.model.types.BTupleMember; import org.wso2.ballerinalang.compiler.semantics.model.types.BTupleType; From c6e9721c1a9efe4eca66031669b2a432a72fcdff Mon Sep 17 00:00:00 2001 From: prakanth <50439067+prakanth97@users.noreply.github.com> Date: Thu, 13 Jul 2023 13:23:03 +0530 Subject: [PATCH 7/7] Address review suggestions --- .../analyzer/ConstantValueResolver.java | 7 +++--- .../org/wso2/ballerinalang/util/Flags.java | 2 +- .../test/typedefs/TypeDefinitionsTest.java | 5 ++++ .../test-src/typedefs/type-definitions.bal | 23 +++++++++++++++++++ 4 files changed, 32 insertions(+), 5 deletions(-) diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java index 29bd869a23c0..ee749c1dc32b 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/ConstantValueResolver.java @@ -82,6 +82,7 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Stack; import java.util.function.BiFunction; @@ -581,10 +582,8 @@ BLangConstantValue constructBLangConstantValueWithExactType(BLangExpression expr this.anonTypeNameSuffixes = anonTypeNameSuffixes; updateConstantType(constantSymbol, expression, env); - BLangTypeDefinition typeDefinition = createdTypeDefinitions.get(constantSymbol.type.tsymbol); - if (isSourceOnlyAnon && typeDefinition != null) { - typeDefinition.symbol.flags |= Flags.SOURCE_ANNOTATION; - } + Optional.ofNullable(isSourceOnlyAnon ? createdTypeDefinitions.get(constantSymbol.type.tsymbol) : null) + .ifPresent(typeDefinition -> typeDefinition.symbol.flags |= Flags.SOURCE_ANNOTATION); return value; } diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java index a1dfdd6d0b99..25fa804b1e70 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/util/Flags.java @@ -82,7 +82,7 @@ public class Flags { public static final long ENUM_MEMBER = INFER << 1; // 41 public static final long QUERY_LAMBDA = ENUM_MEMBER << 1; // 42 public static final long EFFECTIVE_TYPE_DEF = QUERY_LAMBDA << 1; // 43 - public static final long SOURCE_ANNOTATION = EFFECTIVE_TYPE_DEF << 1; // 44 + public static final long SOURCE_ANNOTATION = EFFECTIVE_TYPE_DEF << 1; // 44 public static long asMask(Set flagSet) { long mask = 0; diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/typedefs/TypeDefinitionsTest.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/typedefs/TypeDefinitionsTest.java index 96004c500cc4..8197c30d0c56 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/typedefs/TypeDefinitionsTest.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/typedefs/TypeDefinitionsTest.java @@ -184,6 +184,11 @@ public void testRecordTypeResolvingWithTypeInclusion() { BRunUtil.invoke(recordFieldRes, "testRecordTypeResolvingWithTypeInclusion"); } + @Test + public void testAnnotWithRecordTypeDefinition() { + BRunUtil.invoke(compileResult, "testAnnotWithRecordTypeDefinition"); + } + @AfterClass public void tearDown() { compileResult = null; diff --git a/tests/jballerina-unit-test/src/test/resources/test-src/typedefs/type-definitions.bal b/tests/jballerina-unit-test/src/test/resources/test-src/typedefs/type-definitions.bal index c0b3d373e828..009e273f612d 100644 --- a/tests/jballerina-unit-test/src/test/resources/test-src/typedefs/type-definitions.bal +++ b/tests/jballerina-unit-test/src/test/resources/test-src/typedefs/type-definitions.bal @@ -338,6 +338,29 @@ public function returnTupleWithSingletonType2() returns X2 { return ["x", 2, ()]; } +type Data record {| + string value; +|}; + +const annotation Data dataAnon on type; + +@dataAnon { + value: "T1" +} +type Person2 record {| + string name; +|}; + +function testAnnotWithRecordTypeDefinition() { + Person2 foo = {name: "James"}; + typedesc t = typeof foo; + Data? annon = t.@dataAnon; + assertEquality("{\"value\":\"T1\"}", annon.toString()); + + Data data = {value: "T2"}; + assertEquality("{\"value\":\"T2\"}" , data.toString()); +} + function assertTrue(any|error actual) { assertEquality(true, actual); }