From 83792334428f9c837b5ea0b0119c057daa3a1407 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Wed, 10 Jan 2024 14:38:15 +0530 Subject: [PATCH 01/16] WIP: cache typechecks --- .../runtime/internal/TypeChecker.java | 117 ++++++++++++++++++ .../typecast/TypeCastExprTest.java | 5 + .../foreachstatement/ForeachDebugTest.java | 45 +++++++ .../whilestatement/WhileStmtTest.java | 8 ++ .../foreachstatement/foreach-debug.bal | 18 +++ 5 files changed, 193 insertions(+) create mode 100644 tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/foreachstatement/ForeachDebugTest.java create mode 100644 tests/jballerina-unit-test/src/test/resources/test-src/statements/foreachstatement/foreach-debug.bal diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 6717bf6a8d1b..c63e590dfe86 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -84,10 +84,12 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Objects; @@ -142,12 +144,20 @@ public class TypeChecker { private static final byte MAX_TYPECAST_ERROR_COUNT = 20; private static final String REG_EXP_TYPENAME = "RegExp"; + private static final TypeCheckMemoTable typeCheckMemo = new TypeCheckMemoTable<>(); public static Object checkCast(Object sourceVal, Type targetType) { List errors = new ArrayList<>(); Type sourceType = getImpliedType(getType(sourceVal)); + TypeCheckMemoKey memoKey = new TypeCheckMemoKey(sourceType, targetType); + // FIXME: think about thread safety (maybe double synchronize) here + // We don't need to synchronize this as long as we don't care about the actual value being stored in the map + if (typeCheckMemo.containsKey(memoKey)) { + return sourceVal; + } if (checkIsType(errors, sourceVal, sourceType, targetType)) { + typeCheckMemo.put(memoKey, true); return sourceVal; } @@ -3636,4 +3646,111 @@ private static BError createTypeCastError(Object value, Type targetType, List implements Map { + + private static final int CACHE_SIZE = 100; + private final Map cache; + + private TypeCheckMemoTable() { + // NOTE: accessOrdered mean get is also a structural modification + this.cache = new LinkedHashMap<>(CACHE_SIZE, 0.75f, true) { + @Override + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > CACHE_SIZE; + } + }; + } + + @Override + public int size() { + return cache.size(); + } + + @Override + public boolean isEmpty() { + return cache.isEmpty(); + } + + @Override + public boolean containsKey(Object key) { + return cache.containsKey(key); + } + + @Override + public boolean containsValue(Object value) { + return cache.containsValue(value); + } + + @Override + public V get(Object key) { + return cache.get(key); + } + + @Override + public V put(TypeCheckMemoKey key, V value) { + // FIXME: + if (key.sourceType().isReadOnly() || key.destinationType().isReadOnly()) { + return value; + } + return cache.put(key, value); + } + + @Override + public V remove(Object key) { + return cache.remove(key); + } + + @Override + public void putAll(Map m) { + cache.putAll(m); + } + + @Override + public void clear() { + cache.clear(); + } + + @Override + public Set keySet() { + return cache.keySet(); + } + + @Override + public Collection values() { + return cache.values(); + } + + @Override + public Set> entrySet() { + return cache.entrySet(); + } + } + + /** + * @param sourceType TODO: better field names + */ + private record TypeCheckMemoKey(Type sourceType, Type destinationType) { + + // TODO: do something better + @Override + public int hashCode() { + return sourceType.hashCode() | destinationType.hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof TypeCheckMemoKey other)) { + return false; + } + // We are not trying to do type checking here just checking if the same object + return this.sourceType == other.sourceType && this.destinationType == other.destinationType; + } + + @Override + public String toString() { + return sourceType.toString() + ":" + destinationType.toString(); + } + } } diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/expressions/typecast/TypeCastExprTest.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/expressions/typecast/TypeCastExprTest.java index d82a4b53fe26..ab94933e7a53 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/expressions/typecast/TypeCastExprTest.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/expressions/typecast/TypeCastExprTest.java @@ -709,6 +709,11 @@ public void testInvalidTypeCastJsonToMapOfAnydata() { BRunUtil.invoke(result, "testInvalidTypeCastJsonToMapOfAnydata"); } + @Test + public void simpleTest() { + BRunUtil.invoke(result, "testCastOfReadonlyIntArrayToByteArrayNegative"); + } + @AfterClass public void tearDown() { result = null; diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/foreachstatement/ForeachDebugTest.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/foreachstatement/ForeachDebugTest.java new file mode 100644 index 000000000000..d3228fff4808 --- /dev/null +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/foreachstatement/ForeachDebugTest.java @@ -0,0 +1,45 @@ +/* + * + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * / + * + */ + +package org.ballerinalang.test.statements.foreachstatement; + +import org.ballerinalang.test.BCompileUtil; +import org.ballerinalang.test.BRunUtil; +import org.ballerinalang.test.CompileResult; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +public class ForeachDebugTest { + + private CompileResult result; + + @BeforeClass + public void setup() { + result = BCompileUtil.compile("test-src/statements/foreachstatement/foreach-debug.bal"); + } + + @Test + public void testSimple() { + Object returns = BRunUtil.invoke(result, "simpleIntArray"); + Assert.assertEquals(returns, 10); + } +} diff --git a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/whilestatement/WhileStmtTest.java b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/whilestatement/WhileStmtTest.java index bf5ab407028c..67c0505aca91 100644 --- a/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/whilestatement/WhileStmtTest.java +++ b/tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/statements/whilestatement/WhileStmtTest.java @@ -358,6 +358,14 @@ public void testWhileStmtTypeNarrowPositive() { Assert.assertTrue((Boolean) returns); } + @Test + public void testForeachSimple() { + CompileResult result = BCompileUtil.compile("test-src/statements/foreachstatement/foreach-debug.bal"); + Object returns = BRunUtil.invoke(result, "simpleIntArray"); +// Object returns = BRunUtil.invoke(result, "simpleIntIter"); + Assert.assertEquals(returns, 45L); + } + @AfterClass public void tearDown() { positiveCompileResult = null; diff --git a/tests/jballerina-unit-test/src/test/resources/test-src/statements/foreachstatement/foreach-debug.bal b/tests/jballerina-unit-test/src/test/resources/test-src/statements/foreachstatement/foreach-debug.bal new file mode 100644 index 000000000000..9d3fe6a7fc1e --- /dev/null +++ b/tests/jballerina-unit-test/src/test/resources/test-src/statements/foreachstatement/foreach-debug.bal @@ -0,0 +1,18 @@ +function simpleIntArray() returns int { + int[] values = from int i in 0 ..< 10 select i; + int sum = 0; + foreach int each in values { + sum += each; + } + return sum; +} + +function simpleIntIter() returns int { + int[] values = from int i in 0 ..< 10 select i; + int sum = 0; + int len = values.length(); + foreach int i in 0.. Date: Thu, 18 Jan 2024 13:12:07 +0530 Subject: [PATCH 02/16] Cache implied type results --- .../java/io/ballerina/runtime/api/types/Type.java | 5 +++++ .../io/ballerina/runtime/api/utils/TypeUtils.java | 14 +++++++++----- .../io/ballerina/runtime/internal/types/BType.java | 10 ++++++++++ 3 files changed, 24 insertions(+), 5 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java index 54f15bf537a3..633bd2db0101 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java @@ -91,4 +91,9 @@ public interface Type { void setImmutableType(IntersectionType immutableType); Module getPkg(); + + // TODO: add documentation + void setImpliedType(Type impliedType); + + Type getImpliedType(); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java index 9485472eafcf..81dbe74c9047 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java @@ -167,12 +167,16 @@ public static Type getReferredType(Type type) { * else returns the original type */ public static Type getImpliedType(Type type) { - type = getReferredType(type); - - if (type.getTag() == TypeTags.INTERSECTION_TAG) { - return getImpliedType(((IntersectionType) type).getEffectiveType()); + Type memo = type.getImpliedType(); + if (memo != null) { + return memo; } + Type result = getReferredType(type); - return type; + if (result.getTag() == TypeTags.INTERSECTION_TAG) { + result = getImpliedType(((IntersectionType) result).getEffectiveType()); + } + type.setImpliedType(result); + return result; } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java index d83b84517f7f..8a8c63e768e5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java @@ -42,6 +42,7 @@ public abstract class BType implements Type { protected Module pkg; protected Class valueClass; private int hashCode; + private Type impliedType = null; protected BType(String typeName, Module pkg, Class valueClass) { this.typeName = typeName; @@ -195,4 +196,13 @@ public long getFlags() { return 0; } + @Override + public synchronized void setImpliedType(Type impliedType) { + this.impliedType = impliedType; + } + + @Override + public synchronized Type getImpliedType() { + return this.impliedType; + } } From f62ecb22f5047e5ffd3074ae465d397ce786c9b5 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Sun, 14 Jan 2024 15:53:25 +0530 Subject: [PATCH 03/16] Add SimpleType --- .../io/ballerina/runtime/api/SimpleType.java | 85 +++++++++++++++++++ .../runtime/api/SimpleTypeBuilder.java | 79 +++++++++++++++++ .../ballerina/runtime/api/SimpleTypeTag.java | 48 +++++++++++ .../io/ballerina/runtime/api/types/Type.java | 3 + .../ballerina/runtime/api/values/BValue.java | 2 + .../runtime/internal/TypeChecker.java | 26 ++++++ .../internal/types/BAnnotatableType.java | 5 +- .../runtime/internal/types/BAnyType.java | 6 +- .../runtime/internal/types/BArrayType.java | 7 +- .../runtime/internal/types/BBooleanType.java | 6 +- .../runtime/internal/types/BByteType.java | 6 +- .../runtime/internal/types/BDecimalType.java | 14 ++- .../runtime/internal/types/BErrorType.java | 10 ++- .../runtime/internal/types/BFiniteType.java | 5 +- .../runtime/internal/types/BFloatType.java | 6 +- .../runtime/internal/types/BFunctionType.java | 19 ++++- .../runtime/internal/types/BFutureType.java | 10 ++- .../runtime/internal/types/BHandleType.java | 6 +- .../runtime/internal/types/BIntegerType.java | 11 ++- .../internal/types/BIntersectionType.java | 3 +- .../runtime/internal/types/BIteratorType.java | 6 +- .../runtime/internal/types/BMapType.java | 5 +- .../runtime/internal/types/BNeverType.java | 3 + .../runtime/internal/types/BNullType.java | 6 +- .../runtime/internal/types/BObjectType.java | 11 +++ .../internal/types/BParameterizedType.java | 3 +- .../runtime/internal/types/BReadonlyType.java | 4 +- .../runtime/internal/types/BStreamType.java | 7 +- .../runtime/internal/types/BStringType.java | 13 ++- .../internal/types/BStructureType.java | 9 +- .../runtime/internal/types/BTableType.java | 8 +- .../runtime/internal/types/BTupleType.java | 12 ++- .../runtime/internal/types/BType.java | 10 ++- .../internal/types/BTypeReferenceType.java | 5 +- .../runtime/internal/types/BTypedescType.java | 9 +- .../runtime/internal/types/BUnionType.java | 30 +++++-- .../internal/types/BXmlAttributesType.java | 5 +- .../runtime/internal/types/BXmlType.java | 16 +++- .../internal/values/AbstractArrayValue.java | 11 +++ .../internal/values/AbstractObjectValue.java | 12 +++ .../runtime/internal/values/DecimalValue.java | 11 +++ .../runtime/internal/values/ErrorValue.java | 10 +++ .../runtime/internal/values/FPValue.java | 10 +++ .../runtime/internal/values/FutureValue.java | 10 +++ .../runtime/internal/values/HandleValue.java | 10 +++ .../internal/values/IteratorValue.java | 10 +++ .../runtime/internal/values/MapValueImpl.java | 10 +++ .../internal/values/RegExpCommonValue.java | 22 +++++ .../runtime/internal/values/RegExpValue.java | 21 +++++ .../runtime/internal/values/StreamValue.java | 10 +++ .../runtime/internal/values/StringValue.java | 10 +++ .../internal/values/TableValueImpl.java | 10 +++ .../internal/values/TypedescValue.java | 1 + .../internal/values/TypedescValueImpl.java | 10 +++ .../runtime/internal/values/XmlQName.java | 11 +++ .../runtime/internal/values/XmlValue.java | 11 +++ .../semantics/model/types/BRecordType.java | 1 + .../langlib/error/StackTrace.java | 8 ++ .../natives/mock/GenericMockObjectValue.java | 10 +++ 59 files changed, 686 insertions(+), 52 deletions(-) create mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java create mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java create mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java new file mode 100644 index 000000000000..e7d79327fea3 --- /dev/null +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -0,0 +1,85 @@ +/* + * + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * / + * + */ + +package io.ballerina.runtime.api; + +import java.util.stream.Stream; + +public class SimpleType { + + public long all; + public long some; + + public SimpleType(long all, long some) { + this.all = all; + this.some = some; + } + + public SimpleType intersection(SimpleType other) { + long all = this.all & other.all; + long some = (this.some | this.all) & (other.some | other.all); + some &= ~all; + return new SimpleType(all, some); + } + + public SimpleType union(SimpleType other) { + long all = this.all | other.all; + long some = this.some | other.some; + some &= ~all; + return new SimpleType(all, some); + } + + public SimpleType diff(SimpleType other) { + long all = this.all & ~(other.all | other.some); + long some = (this.all | this.some) & ~(other.all); + some &= ~all; + return new SimpleType(all, some); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof SimpleType other)) { + return false; + } + return this.all == other.all && this.some == other.some; + } + + @Override + public String toString() { + SimpleTypeTag[] allTags = + Stream.of(SimpleTypeTag.values()).filter(tag -> (all & (1L << tag.ordinal())) != 0) + .toArray(SimpleTypeTag[]::new); + SimpleTypeTag[] someTags = + Stream.of(SimpleTypeTag.values()).filter(tag -> (some & (1L << tag.ordinal())) != 0) + .toArray(SimpleTypeTag[]::new); + StringBuilder sb = new StringBuilder(); + sb.append("SimpleType all: {"); + for (SimpleTypeTag tag : allTags) { + sb.append(tag).append(", "); + } + sb.append("} some: {"); + for (SimpleTypeTag tag : someTags) { + sb.append(tag).append(", "); + } + sb.append("}"); + return sb.toString(); + } +} diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java new file mode 100644 index 000000000000..5c9084419e97 --- /dev/null +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java @@ -0,0 +1,79 @@ +/* + * + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * / + * + */ + +package io.ballerina.runtime.api; + +import io.ballerina.runtime.api.types.Type; + +import java.util.List; + +public class SimpleTypeBuilder { + + public static final long NONE = 0; + public static final long ALL = (1L << (SimpleTypeTag.values().length + 1)) - 1; + + public static long basicTypeUnionBitset(SimpleTypeTag... basicTypes) { + long bits = 0; + for (SimpleTypeTag basicType : basicTypes) { + bits |= (1L << basicType.ordinal()); + } + return bits; + } + + public static long basicTypeBitset(SimpleTypeTag basicType) { + return 1L << basicType.ordinal(); + } + + public static SimpleType createContainerSimpleType(Type constraint, SimpleTypeTag tag) { + SimpleType constraintSimpleType = constraint.getSimpleType(); + if (constraintSimpleType.all == ALL) { + // no constraint mean it is the top type + return new SimpleType(SimpleTypeBuilder.basicTypeBitset(tag), SimpleTypeBuilder.NONE); + } + return new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(tag)); + } + + public static long except(SimpleTypeTag... basicTypes) { + long bits = ALL; + for (SimpleTypeTag basicType : basicTypes) { + bits &= ~(1L << basicType.ordinal()); + } + return bits; + } + + public static SimpleType intersection(List types) { + if (types.isEmpty()) { + // I assume this (and union) is because we are modifying types after the fact + return new SimpleType(NONE, NONE); + } + return types.stream().skip(1).map(Type::getSimpleType) + .reduce(types.get(0).getSimpleType(), SimpleType::intersection); + } + + public static SimpleType union(List types) { + if (types.isEmpty()) { + return new SimpleType(NONE, NONE); + } + return types.stream().skip(1).map(Type::getSimpleType) + .reduce(types.get(0).getSimpleType(), SimpleType::union); + } +} + diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java new file mode 100644 index 000000000000..68ed9f56adb7 --- /dev/null +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java @@ -0,0 +1,48 @@ +/* + * + * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). + * + * WSO2 LLC. licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * / + * + */ + +package io.ballerina.runtime.api; + +public enum SimpleTypeTag { + + NIL, + BOOLEAN, + INT, + FLOAT, + DECIMAL, + STRING, + ERROR, + TYPEDESC, + HANDLE, + FUNCTION, + + // Inherently mutable + FUTURE, + STREAM, + + // Selectively immutable + LIST, + MAPPING, + TABLE, + XML, + OBJECT, + CELL +} diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java index 633bd2db0101..9a6d35aef38d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java @@ -18,6 +18,7 @@ package io.ballerina.runtime.api.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; /** * {@code Type} represents a type in Ballerina. @@ -31,6 +32,8 @@ */ public interface Type { + SimpleType getSimpleType(); + /** * Get the default value of the type. This is the value of an uninitialized variable of this type. * For value types, this is same as the value get from {@code BType#getInitValue()}. diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java index 82a8bdac0a59..64a99b56079f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java @@ -17,6 +17,7 @@ */ package io.ballerina.runtime.api.values; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import java.util.Map; @@ -30,6 +31,7 @@ */ public interface BValue { + SimpleType getSimpleType(); /** * Method to perform a deep copy, recursively copying all structural values and their members. * diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index c63e590dfe86..ba429546670c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -19,6 +19,7 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.types.ArrayType.ArrayState; @@ -675,11 +676,36 @@ public static boolean checkIsType(Type sourceType, Type targetType, List unresolvedTypes) { sourceType = getImpliedType(sourceType); targetType = getImpliedType(targetType); + return switch (checkIsTypeSimple(sourceType.getSimpleType(), targetType.getSimpleType())) { + case TRUE -> true; + case FALSE -> false; + case UNKNOWN -> checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); + }; + } + private static boolean checkIsTypeInner(Object sourceVal, Type sourceType, Type targetType, + List unresolvedTypes) { + sourceType = getImpliedType(sourceType); + targetType = getImpliedType(targetType); int sourceTypeTag = sourceType.getTag(); int targetTypeTag = targetType.getTag(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnnotatableType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnnotatableType.java index 81c5d0dffe6e..4582fd4512c7 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnnotatableType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnnotatableType.java @@ -18,6 +18,7 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.creators.ValueCreator; import io.ballerina.runtime.api.types.AnnotatableType; import io.ballerina.runtime.api.utils.StringUtils; @@ -35,8 +36,8 @@ public abstract class BAnnotatableType extends BType implements AnnotatableType protected BMap annotations = ValueCreator.createMapValue(); - BAnnotatableType(String typeName, Module pkg, Class valueClass) { - super(typeName, pkg, valueClass); + BAnnotatableType(String typeName, Module pkg, Class valueClass, SimpleType simpleType) { + super(typeName, pkg, valueClass, simpleType); } public void setAnnotations(BMap annotations) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java index 5d3f5d12ec45..baf349f4fa62 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java @@ -19,6 +19,9 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.flags.TypeFlags; @@ -46,7 +49,8 @@ public class BAnyType extends BType implements AnyType { * @param typeName string name of the type */ public BAnyType(String typeName, Module pkg, boolean readonly) { - super(typeName, pkg, RefValue.class); + super(typeName, pkg, RefValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.except(SimpleTypeTag.ERROR))); this.readonly = readonly; if (!readonly) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java index 5b5344a730c1..0ff94439abf3 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.types; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.ArrayType; @@ -74,7 +77,9 @@ public BArrayType(Type elemType, int size, boolean readonly, int typeFlags) { } public BArrayType(int typeFlags, int size, boolean readonly, boolean hasFillerValue) { - super(null, null, ArrayValue.class); + // FIXME: properly differentiate list top type + super(null, null, ArrayValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); this.typeFlags = typeFlags; if (size != -1) { state = ArrayState.CLOSED; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java index 7eef2d162920..a4c47cbb6b25 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.BooleanType; @@ -34,7 +37,8 @@ public class BBooleanType extends BType implements BooleanType { * @param typeName string name of the type */ public BBooleanType(String typeName, Module pkg) { - super(typeName, pkg, Boolean.class); + super(typeName, pkg, Boolean.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.BOOLEAN), SimpleTypeBuilder.NONE)); } @SuppressWarnings("unchecked") diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java index 8e5cda22dfbc..a6c0640da9e9 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java @@ -19,6 +19,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ByteType; @@ -35,7 +38,8 @@ public class BByteType extends BType implements ByteType { * @param typeName string name of the type */ public BByteType(String typeName, Module pkg) { - super(typeName, pkg, Integer.class); + super(typeName, pkg, Integer.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java index a5af3b4d220a..e688a3a4ee58 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java @@ -19,6 +19,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.DecimalType; import io.ballerina.runtime.internal.values.DecimalValue; @@ -38,8 +41,12 @@ public class BDecimalType extends BType implements DecimalType { * * @param typeName string name of the type */ + + private final SimpleType simpleType = + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.DECIMAL), SimpleTypeBuilder.NONE); public BDecimalType(String typeName, Module pkg) { - super(typeName, pkg, DecimalValue.class); + super(typeName, pkg, DecimalValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); } @Override @@ -63,4 +70,9 @@ public int getTag() { public boolean isReadOnly() { return true; } + + @Override + public SimpleType getSimpleType() { + return simpleType; + } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java index 2201afb4bb5d..a8b3663c8f2f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java @@ -19,6 +19,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ErrorType; import io.ballerina.runtime.api.types.IntersectionType; @@ -39,12 +42,15 @@ public class BErrorType extends BAnnotatableType implements ErrorType { private IntersectionType intersectionType = null; public BErrorType(String typeName, Module pkg, Type detailType) { - super(typeName, pkg, ErrorValue.class); + // FIXME: + super(typeName, pkg, ErrorValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.ERROR))); this.detailType = detailType; } public BErrorType(String typeName, Module pkg) { - super(typeName, pkg, ErrorValue.class); + super(typeName, pkg, ErrorValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.ERROR))); } public void setTypeIdSet(BTypeIdSet typeIdSet) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java index 936f904164d8..59421b8cce5f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java @@ -18,6 +18,8 @@ package io.ballerina.runtime.internal.types; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.FiniteType; @@ -51,7 +53,8 @@ public BFiniteType(String typeName, Set values, int typeFlags) { } public BFiniteType(String typeName, String originalName, Set values, int typeFlags) { - super(typeName, null, RefValue.class); + // FIXME: + super(typeName, null, RefValue.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); this.valueSpace = values; this.typeFlags = typeFlags; this.originalName = originalName; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java index 2ef0d084d3e9..71ed892f2378 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.FloatType; @@ -36,7 +39,8 @@ public class BFloatType extends BType implements FloatType { * @param typeName string name of the type */ public BFloatType(String typeName, Module pkg) { - super(typeName, pkg, Double.class); + super(typeName, pkg, Double.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FLOAT), SimpleTypeBuilder.NONE)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java index 87dd2924dacd..05b3441fb66c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java @@ -20,6 +20,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.types.FunctionType; @@ -41,14 +44,20 @@ public class BFunctionType extends BAnnotatableType implements FunctionType { public Parameter[] parameters; public BFunctionType(Module pkg) { - super("function ()", pkg, Object.class); + super("function ()", pkg, Object.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION), SimpleTypeBuilder.NONE)); this.parameters = new Parameter[0]; this.retType = PredefinedTypes.TYPE_NULL; this.flags = 0; } public BFunctionType(Module pkg, long flags) { - super("function", pkg, Object.class); + // FIXME: formattitng + super("function", pkg, Object.class, + flags == 0 ? new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION), + SimpleTypeBuilder.NONE) : + new SimpleType(SimpleTypeBuilder.NONE, + SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); this.parameters = null; this.retType = null; this.flags = flags; @@ -56,7 +65,8 @@ public BFunctionType(Module pkg, long flags) { @Deprecated public BFunctionType(Module pkg, Type[] paramTypes, Type restType, Type retType, long flags) { - super("function ()", pkg, Object.class); + super("function ()", pkg, Object.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); this.restType = restType; this.retType = retType; this.flags = flags; @@ -64,7 +74,8 @@ public BFunctionType(Module pkg, Type[] paramTypes, Type restType, Type retType, public BFunctionType(Module pkg, Parameter[] parameters, Type restType, Type retType, long flags, String name) { - super(name, pkg, Object.class); + super(name, pkg, Object.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); this.parameters = parameters; this.restType = restType; this.retType = retType; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java index 38e6bc656b04..14e6b5706f67 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.FutureType; @@ -40,11 +43,14 @@ public class BFutureType extends BType implements FutureType { * @param pkg of the type */ public BFutureType(String typeName, Module pkg) { - super(typeName, pkg, Object.class); + super(typeName, pkg, Object.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUTURE), SimpleTypeBuilder.NONE)); } public BFutureType(Type constraint) { - super(TypeConstants.FUTURE_TNAME, null, Object.class); + // FIXME: what is the correct top type? + super(TypeConstants.FUTURE_TNAME, null, Object.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUTURE))); this.constraint = constraint; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java index 89b5482936bf..4c195241c04a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.HandleType; import io.ballerina.runtime.internal.values.RefValue; @@ -36,7 +39,8 @@ public class BHandleType extends BType implements HandleType { * @param typeName string name of the type */ public BHandleType(String typeName, Module pkg) { - super(typeName, pkg, RefValue.class); + super(typeName, pkg, RefValue.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.HANDLE), SimpleTypeBuilder.NONE)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java index d8e290013da6..051f1a244e02 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.IntegerType; @@ -37,12 +40,16 @@ public class BIntegerType extends BType implements IntegerType { * @param typeName string name of the type */ public BIntegerType(String typeName, Module pkg) { - super(typeName, pkg, Long.class); + super(typeName, pkg, Long.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT), SimpleTypeBuilder.NONE)); tag = TypeTags.INT_TAG; } public BIntegerType(String typeName, Module pkg, int tag) { - super(typeName, pkg, Long.class); + super(typeName, pkg, Long.class, + tag == TypeTags.INT_TAG ? + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT), SimpleTypeBuilder.NONE) : + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); this.tag = tag; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java index 58c22226890a..a7469e6dde29 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java @@ -18,6 +18,7 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.flags.TypeFlags; @@ -81,7 +82,7 @@ public BIntersectionType(String typeName, Module pkg, Type[] constituentTypes, } private BIntersectionType(String typeName, Module pkg, Type[] constituentTypes, int typeFlags, boolean readonly) { - super(typeName, pkg, Object.class); + super(typeName, pkg, Object.class, SimpleTypeBuilder.intersection(List.of(constituentTypes))); this.constituentTypes = Arrays.asList(constituentTypes); this.typeFlags = typeFlags; this.readonly = readonly; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java index 46be5354f1a4..8ffe662d3645 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.IteratorType; import io.ballerina.runtime.internal.values.IteratorValue; @@ -30,7 +33,8 @@ public class BIteratorType extends BType implements IteratorType { public BIteratorType(String typeName, Module pkg) { - super(typeName, pkg, IteratorValue.class); + super(typeName, pkg, IteratorValue.class, new SimpleType(SimpleTypeBuilder.NONE, + SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT))); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java index 2ad5a6b78db0..52b0bff55b81 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java @@ -19,6 +19,8 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -68,7 +70,8 @@ public BMapType(String typeName, Type constraint, Module pkg) { } public BMapType(String typeName, Type constraint, Module pkg, boolean readonly) { - super(typeName, pkg, MapValueImpl.class); + super(typeName, pkg, MapValueImpl.class, + SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.MAPPING)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java index 9f0d4da9901b..cb66cde54d8d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java @@ -18,6 +18,8 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.NeverType; @@ -35,6 +37,7 @@ public class BNeverType extends BNullType implements NeverType { */ public BNeverType(Module pkg) { super(TypeConstants.NEVER_TNAME, pkg); + simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.NONE); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java index 45e19ebea9c8..97c682e2886b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.NullType; @@ -35,7 +38,8 @@ public class BNullType extends BType implements NullType { * @param pkg package path */ public BNullType(String typeName, Module pkg) { - super(typeName, pkg, null); + super(typeName, pkg, null, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.NIL), SimpleTypeBuilder.NONE)); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java index c3ee14297571..2e3a96cdcebe 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java @@ -19,6 +19,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.flags.SymbolFlags; @@ -62,6 +65,9 @@ public class BObjectType extends BStructureType implements ObjectType { private String cachedToString; private boolean resolving; + // FIXME: + private final SimpleType simpleType = + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); /** * Create a {@code BObjectType} which represents the user defined struct type. @@ -75,6 +81,11 @@ public BObjectType(String typeName, Module pkg, long flags) { this.readonly = SymbolFlags.isFlagOn(flags, SymbolFlags.READONLY); } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public V getZeroValue() { return (V) createObjectValueWithDefaultValues(this.pkg, this); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java index f39bc96f1f70..3afd1de2230b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java @@ -33,7 +33,8 @@ public class BParameterizedType extends BType implements ParameterizedType { private int paramIndex; public BParameterizedType(Type paramValueType, int paramIndex) { - super(null, null, null); + super(null, null, null, + paramValueType.getSimpleType()); this.paramValueType = paramValueType; this.paramIndex = paramIndex; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java index 856da35eaa16..c04a55dbef2e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java @@ -18,6 +18,8 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ReadonlyType; import io.ballerina.runtime.internal.values.RefValue; @@ -30,7 +32,7 @@ public class BReadonlyType extends BType implements ReadonlyType { public BReadonlyType(String typeName, Module pkg) { - super(typeName, pkg, RefValue.class); + super(typeName, pkg, RefValue.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java index f75dc8b6145e..b3b3ec8f3fa2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java @@ -20,6 +20,9 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.StreamType; @@ -47,7 +50,9 @@ public class BStreamType extends BType implements StreamType { * @param pkgPath package path */ public BStreamType(String typeName, Type constraint, Type completionType, Module pkgPath) { - super(typeName, pkgPath, StreamValue.class); + // FIXME: what is the correct top type + super(typeName, pkgPath, StreamValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STREAM))); this.constraint = constraint; this.completionType = completionType; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java index 359beacd3d21..cdcc3d250979 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.types.StringType; @@ -38,12 +41,18 @@ public class BStringType extends BType implements StringType { * @param typeName string name of the type */ public BStringType(String typeName, Module pkg) { - super(typeName, pkg, String.class); + super(typeName, pkg, String.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING), SimpleTypeBuilder.NONE)); tag = TypeTags.STRING_TAG; } public BStringType(String typeName, Module pkg, int tag) { - super(typeName, pkg, String.class); + // FIXME: formatting + super(typeName, pkg, String.class, + tag == TypeTags.STRING_TAG ? new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING), + SimpleTypeBuilder.NONE) : + new SimpleType(SimpleTypeBuilder.NONE, + SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING))); this.tag = tag; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java index 58b453e9f082..07d0cc9d0784 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.types.Field; import io.ballerina.runtime.api.types.StructureType; @@ -43,7 +46,8 @@ public abstract class BStructureType extends BAnnotatableType implements Structu * @param valueClass of the structure type */ public BStructureType(String typeName, Module pkg, long flags, Class valueClass) { - super(typeName, pkg, valueClass); + super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.MAPPING))); this.flags = flags; fields = new HashMap<>(); } @@ -59,7 +63,8 @@ public BStructureType(String typeName, Module pkg, long flags, Class valueClass, Map fields) { - super(typeName, pkg, valueClass); + super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.MAPPING))); this.flags = flags; this.fields = fields; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java index 6393166c5f63..610dbbf53ff7 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java @@ -17,6 +17,8 @@ */ package io.ballerina.runtime.internal.types; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -54,7 +56,11 @@ public BTableType(Type constraint, Type keyType, boolean readonly) { } public BTableType(Type constraint, boolean readonly) { - super(TypeConstants.TABLE_TNAME, null, TableValue.class); + // FIXME: properly define the top level type + super(TypeConstants.TABLE_TNAME, + null, + TableValue.class, + SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.TABLE)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java index 4e69b2e41dab..89dde0724320 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java @@ -19,6 +19,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.IntersectionType; @@ -57,7 +60,8 @@ public class BTupleType extends BAnnotatableType implements TupleType { * @param typeList of the tuple type */ public BTupleType(List typeList) { - super(null, null, Object.class); + super(null, null, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.LIST))); this.tupleTypes = typeList; this.restType = null; checkAllMembers(); @@ -81,7 +85,8 @@ public BTupleType(List typeList, Type restType, int typeFlags, boolean rea * @param readonly whether immutable */ public BTupleType(List typeList, Type restType, int typeFlags, boolean isCyclic, boolean readonly) { - super(null, null, Object.class); + super(null, null, Object.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); if (readonly) { this.resolvingReadonly = true; this.tupleTypes = getReadOnlyTypes(typeList); @@ -97,7 +102,8 @@ public BTupleType(List typeList, Type restType, int typeFlags, boolean isC } public BTupleType(String name, Module pkg, int typeFlags, boolean isCyclic, boolean readonly) { - super(name, pkg, Object.class); + super(name, pkg, Object.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); this.typeFlags = typeFlags; this.tupleTypes = new ArrayList<>(0); this.restType = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java index 8a8c63e768e5..9edcbda8c935 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java @@ -18,6 +18,7 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.IntersectionType; @@ -43,14 +44,21 @@ public abstract class BType implements Type { protected Class valueClass; private int hashCode; private Type impliedType = null; + public SimpleType simpleType; - protected BType(String typeName, Module pkg, Class valueClass) { + protected BType(String typeName, Module pkg, Class valueClass, SimpleType simpleType) { this.typeName = typeName; this.pkg = pkg; this.valueClass = valueClass; if (pkg != null && typeName != null) { this.hashCode = Objects.hash(pkg, typeName); } + this.simpleType = simpleType; + } + + @Override + public SimpleType getSimpleType() { + return this.simpleType; } @SuppressWarnings("unchecked") diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java index f43cd540dc0e..1f6bd654d33c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java @@ -20,6 +20,8 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.IntersectableReferenceType; @@ -42,7 +44,8 @@ public class BTypeReferenceType extends BAnnotatableType implements Intersectabl private IntersectionType intersectionType; public BTypeReferenceType(String typeName, Module pkg, int typeFlags, boolean readOnly) { - super(typeName, pkg, Object.class); + // FIXME: + super(typeName, pkg, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); this.typeFlags = typeFlags; this.readOnly = readOnly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java index a03a30737ad7..0f2126fe6ecf 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java @@ -20,6 +20,9 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.Type; @@ -36,11 +39,13 @@ public class BTypedescType extends BType implements TypedescType { private Type constraint; public BTypedescType(String typeName, Module pkg) { - super(typeName, pkg, Object.class); + super(typeName, pkg, Object.class, + new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.TYPEDESC), SimpleTypeBuilder.NONE)); } public BTypedescType(Type constraint) { - super(TypeConstants.TYPEDESC_TNAME, null, TypedescValue.class); + super(TypeConstants.TYPEDESC_TNAME, null, TypedescValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.TYPEDESC))); this.constraint = constraint; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java index 527ce7d0f651..89af46703865 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java @@ -18,6 +18,8 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.flags.TypeFlags; @@ -38,6 +40,8 @@ import java.util.Set; import java.util.StringJoiner; import java.util.regex.Pattern; +import java.util.stream.Collectors; +import java.util.stream.Stream; /** * {@code BUnionType} represents a union type in Ballerina. @@ -70,7 +74,8 @@ public BUnionType(List memberTypes, int typeFlags, boolean readonly, bool private BUnionType(List memberTypes, List originalMemberTypes, int typeFlags, boolean isCyclic, long flags) { - super(null, null, Object.class); + super(null, null, Object.class, SimpleTypeBuilder.union(Stream.concat(memberTypes.stream(), + originalMemberTypes.stream()).collect(Collectors.toList()))); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.flags = flags; @@ -79,7 +84,7 @@ private BUnionType(List memberTypes, List originalMemberTypes, int t } public BUnionType(int typeFlags, boolean isCyclic, long flags) { - super(null, null, Object.class); + super(null, null, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.memberTypes = new ArrayList<>(0); @@ -92,7 +97,7 @@ public BUnionType(List memberTypes) { } public BUnionType(String typeName, Module pkg, List memberTypes, boolean readonly) { - super(typeName, pkg, Object.class); + super(typeName, pkg, Object.class, SimpleTypeBuilder.union(memberTypes)); this.readonly = readonly; setMemberTypes(memberTypes); } @@ -102,7 +107,7 @@ public BUnionType(List memberTypes, boolean readonly) { } public BUnionType(List memberTypes, boolean readonly, boolean isCyclic) { - super(null, null, Object.class); + super(null, null, Object.class, SimpleTypeBuilder.union(memberTypes)); this.typeFlags = 0; this.readonly = readonly; setMemberTypes(memberTypes); @@ -118,7 +123,7 @@ public BUnionType(Type[] memberTypes, Type[] originalMemberTypes, int typeFlags, } public BUnionType(List memberTypes, String name, Module pkg, int typeFlags, boolean isCyclic, long flags) { - super(name, pkg, Object.class); + super(name, pkg, Object.class, SimpleTypeBuilder.union(memberTypes)); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.memberTypes = memberTypes; @@ -131,7 +136,7 @@ public BUnionType(String name, Module pkg, int typeFlags, boolean isCyclic, long } protected BUnionType(String typeName, Module pkg, boolean readonly, Class valueClass) { - super(typeName, pkg, valueClass); + super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.NONE)); this.readonly = readonly; } @@ -142,7 +147,7 @@ protected BUnionType(String typeName, Module pkg, boolean readonly, Class(unionType.memberTypes.size()); this.originalMemberTypes = new ArrayList<>(unionType.memberTypes.size()); @@ -152,7 +157,9 @@ protected BUnionType(BUnionType unionType, String typeName, boolean readonly) { public BUnionType(Type[] memberTypes, Type[] originalMemberTypes, String name, Module pkg, int typeFlags, boolean isCyclic, long flags) { - super(name, pkg, Object.class); + super(name, pkg, Object.class, + SimpleTypeBuilder.union(List.of(memberTypes)) + .union(SimpleTypeBuilder.union(List.of(originalMemberTypes)))); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.isCyclic = isCyclic; @@ -165,6 +172,9 @@ public void setMemberTypes(Type[] members) { if (members == null) { return; } + for (Type member : members) { + this.simpleType = this.simpleType.union(member.getSimpleType()); + } this.memberTypes = readonly ? getReadOnlyTypes(members) : Arrays.asList(members); setFlagsBasedOnMembers(); } @@ -182,6 +192,7 @@ private void setMemberTypes(List members) { } private void setMemberTypes(List members, List originalMembers) { + // FIXME: avoid duplication here if (members == null) { return; } @@ -237,6 +248,9 @@ private void addMember(Type type) { public void addMembers(Type... types) { this.memberTypes.addAll(Arrays.asList(types)); + for (Type member : types) { + this.simpleType = this.simpleType.union(member.getSimpleType()); + } setFlagsBasedOnMembers(); this.originalMemberTypes.addAll(Arrays.asList(types)); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java index 0d08050ef73f..2a324c404ead 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java @@ -18,6 +18,8 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.XmlAttributesType; @@ -35,7 +37,8 @@ public class BXmlAttributesType extends BType implements XmlAttributesType { * @param pkg package path */ public BXmlAttributesType(String typeName, Module pkg) { - super(typeName, pkg, null); + // FIXME: string, error , () + super(typeName, pkg, null, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java index 187c15dfb6c2..ab9fd9ef9b14 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -50,28 +53,33 @@ public class BXmlType extends BType implements XmlType { * @param constraint constraint of the xml sequence */ public BXmlType(String typeName, Type constraint, Module pkg) { - super(typeName, pkg, XmlValue.class); + super(typeName, pkg, XmlValue.class, + SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.XML)); this.constraint = constraint; this.tag = TypeTags.XML_TAG; this.readonly = false; } + // FIXME: public BXmlType(String typeName, Module pkg, int tag, boolean readonly) { - super(typeName, pkg, XmlValue.class); + super(typeName, pkg, XmlValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); this.tag = tag; this.readonly = readonly; this.constraint = null; } public BXmlType(String typeName, Type constraint, Module pkg, boolean readonly) { - super(typeName, pkg, XmlValue.class); + super(typeName, pkg, XmlValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); this.tag = TypeTags.XML_TAG; this.readonly = readonly; this.constraint = constraint; } public BXmlType(Type constraint, boolean readonly) { - super(TypeConstants.XML_TNAME, null, XmlValue.class); + super(TypeConstants.XML_TNAME, null, XmlValue.class, + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); this.tag = TypeTags.XML_TAG; this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java index 80c1ac6512f0..95f804d21402 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Type; @@ -63,6 +66,14 @@ public abstract class AbstractArrayValue implements ArrayValue { protected int size = 0; protected Type iteratorNextReturnType; + private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.LIST)); + + @Override + public SimpleType getSimpleType() { + return simpleType; + } + /** * Append value to the existing array. * diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java index 068b97bb03a4..1b44f45b39be 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.types.Field; @@ -58,11 +61,14 @@ * @since 0.995.0 */ public abstract class AbstractObjectValue implements ObjectValue { + private BTypedesc typedesc; private final BObjectType objectType; private final Type type; private final HashMap nativeData = new HashMap<>(); + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.OBJECT)); public AbstractObjectValue(Type type) { this.type = type; @@ -232,4 +238,10 @@ private void checkFieldUpdateType(String fieldName, Object value) { ErrorHelper.getErrorDetails(ErrorCodes.INVALID_OBJECT_FIELD_VALUE_ERROR, fieldName, fieldType, TypeChecker.getType(value))); } + + @Override + public SimpleType getSimpleType() { + return simpleType; + } + } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java index aafa40069354..c3bcd173ebe4 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java @@ -19,6 +19,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Type; @@ -56,6 +59,9 @@ public class DecimalValue implements SimpleValue, BDecimal { private static final BigDecimal MIN_DECIMAL_MAGNITUDE = new BigDecimal("1.000000000000000000000000000000000e-6143", MathContext.DECIMAL128); + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.DECIMAL)); + // Variable used to track the kind of a decimal value. @Deprecated public DecimalValueKind valueKind = DecimalValueKind.OTHER; @@ -174,6 +180,11 @@ public boolean booleanValue() { return value.compareTo(BigDecimal.ZERO) != 0; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java index f3a8683ce7a0..e875d04afeb2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java @@ -20,6 +20,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.Type; @@ -81,6 +84,8 @@ public class ErrorValue extends BError implements RefValue { private static final String INIT_FUNCTION_SUFFIX = ".."; private static final String START_FUNCTION_SUFFIX = "."; private static final String STOP_FUNCTION_SUFFIX = "."; + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.ERROR)); public ErrorValue(BString message) { this(new BErrorType(TypeConstants.ERROR, PredefinedTypes.TYPE_ERROR.getPackage(), TYPE_MAP), @@ -212,6 +217,11 @@ public Type getType() { return type; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { // Error values are immutable and frozen, copy give same value. diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java index 44f8b914744a..588007275111 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.async.StrandMetadata; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.types.Type; @@ -48,6 +51,8 @@ public class FPValue implements BFunctionPointer, RefValue { final Type type; private BTypedesc typedesc; + private SimpleType simpleType = + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION)); Function function; public boolean isConcurrent; public String strandName; @@ -98,6 +103,11 @@ public Type getType() { return type; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java index 76709936a568..d3d942a72780 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.values; + import io.ballerina.runtime.api.SimpleTypeBuilder; + import io.ballerina.runtime.api.SimpleTypeTag; + import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.async.Callback; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BFuture; @@ -56,6 +59,8 @@ public class FutureValue implements BFuture, RefValue { private boolean waited; Type type; + private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.FUTURE)); @Deprecated public FutureValue(Strand strand, Callback callback, Type constraint) { @@ -87,6 +92,11 @@ public Type getType() { return this.type; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { throw new UnsupportedOperationException(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java index f41b50630709..d88733d27133 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BHandle; import io.ballerina.runtime.api.values.BLink; @@ -39,6 +42,8 @@ public class HandleValue implements BHandle, RefValue { private Object value; private BTypedesc typedesc; + private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.HANDLE)); public HandleValue(Object value) { this.value = value; @@ -72,6 +77,11 @@ public Type getType() { return PredefinedTypes.TYPE_HANDLE; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java index 924748e14728..0e81f7ff5d61 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BIterator; import io.ballerina.runtime.api.values.BLink; @@ -38,6 +41,8 @@ public interface IteratorValue extends RefValue, BIterator { BTypedesc TYPEDESC = new TypedescValueImpl(PredefinedTypes.TYPE_ITERATOR); + SimpleType TAGGED_TYPE = + new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); /* Default implementation */ @@ -56,6 +61,11 @@ default String expressionStringValue(BLink parent) { return stringValue(parent); } + @Override + default SimpleType getSimpleType() { + return TAGGED_TYPE; + } + @Override default Object copy(Map refs) { throw new UnsupportedOperationException(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java index c1a58b87996e..611adc5286dd 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Field; @@ -100,6 +103,8 @@ public class MapValueImpl extends LinkedHashMap implements RefValue, private Type referredType; private final Map nativeData = new HashMap<>(); private Type iteratorNextReturnType; + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.MAPPING)); public MapValueImpl(TypedescValue typedesc) { this(typedesc.getDescribingType()); @@ -452,6 +457,11 @@ public String toString() { return stringValue(null); } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @SuppressWarnings("unchecked") @Override public Object copy(Map refs) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java index 1b460f8e276d..2529688be439 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BTypedesc; @@ -36,6 +39,20 @@ */ public abstract class RegExpCommonValue implements RefValue { + // FIXME: currently our anydata representation don't have regex + private final SimpleType simpleType = new SimpleType( + SimpleTypeBuilder.basicTypeUnionBitset( + SimpleTypeTag.NIL, + SimpleTypeTag.BOOLEAN, + SimpleTypeTag.INT, + SimpleTypeTag.FLOAT, + SimpleTypeTag.DECIMAL, + SimpleTypeTag.STRING, + SimpleTypeTag.LIST, + SimpleTypeTag.MAPPING, + SimpleTypeTag.TABLE, + SimpleTypeTag.XML), + SimpleTypeBuilder.NONE); @Override public String expressionStringValue(BLink parent) { return stringValue(parent); @@ -65,4 +82,9 @@ public Object frozenCopy(Map refs) { public BTypedesc getTypedesc() { throw new UnsupportedOperationException(); } + + @Override + public SimpleType getSimpleType() { + return simpleType; + } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java index 151a98822ca0..4a580afa525f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java @@ -16,6 +16,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BRegexpValue; @@ -40,6 +43,19 @@ public class RegExpValue implements BRegexpValue, RefValue { private final RegExpDisjunction regExpDisjunction; private BTypedesc typedesc; private static final Type type = PredefinedTypes.TYPE_READONLY_ANYDATA; + private final SimpleType simpleType = new SimpleType( + SimpleTypeBuilder.basicTypeUnionBitset( + SimpleTypeTag.NIL, + SimpleTypeTag.BOOLEAN, + SimpleTypeTag.INT, + SimpleTypeTag.FLOAT, + SimpleTypeTag.DECIMAL, + SimpleTypeTag.STRING, + SimpleTypeTag.LIST, + SimpleTypeTag.MAPPING, + SimpleTypeTag.TABLE, + SimpleTypeTag.XML), + SimpleTypeBuilder.NONE); public RegExpValue(RegExpDisjunction regExpDisjunction) { this.regExpDisjunction = regExpDisjunction; @@ -87,6 +103,11 @@ public BTypedesc getTypedesc() { return this.typedesc; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java index a0cb54eb1ff6..d39bb4cf7daf 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BObject; @@ -47,6 +50,8 @@ public class StreamValue implements RefValue, BStream { private Type completionType; private Type iteratorNextReturnType; private BObject iteratorObj; + private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.STREAM)); /** @@ -108,6 +113,11 @@ public Type getType() { return this.type; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { throw new UnsupportedOperationException(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java index a00c1c0e0575..8ecf34da1921 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java @@ -18,12 +18,16 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BString; import java.util.Map; +import static io.ballerina.runtime.api.SimpleTypeTag.STRING; + /** * Class representing ballerina strings. * @@ -33,6 +37,7 @@ public abstract class StringValue implements BString, SimpleValue { final String value; final boolean isNonBmp; + final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(STRING)); protected StringValue(String value, boolean isNonBmp) { this.value = value; @@ -44,6 +49,11 @@ public Type getType() { return PredefinedTypes.TYPE_STRING; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java index badb37a26cf7..b7bdd9b8ab77 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java @@ -17,6 +17,9 @@ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.creators.ValueCreator; @@ -103,6 +106,8 @@ public class TableValueImpl implements TableValue { private final Map nativeData = new HashMap<>(); private BTypedesc typedesc; + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.TABLE)); public TableValueImpl(TableType tableType) { this.type = this.tableType = tableType; @@ -159,6 +164,11 @@ public IteratorValue getIterator() { return new TableIterator(); } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { if (isFrozen()) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValue.java index 8fb9c222dce9..f468a886b7d6 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValue.java @@ -32,4 +32,5 @@ public interface TypedescValue extends RefValue, BTypedesc { Object instantiate(Strand strand); Object instantiate(Strand strand, BInitialValueEntry[] initialValues); + } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java index 6d014bcf16ed..6cdd52425190 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java @@ -17,6 +17,9 @@ */ package io.ballerina.runtime.internal.values; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Type; @@ -56,6 +59,8 @@ public class TypedescValueImpl implements TypedescValue { public MapValue[] closures; public MapValue annotations; private BTypedesc typedesc; + private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.TYPEDESC)); @Deprecated public TypedescValueImpl(Type describingType) { @@ -127,6 +132,11 @@ public Type getType() { return type; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return this; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java index 6ef15a47244b..d5f5665e0563 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java @@ -18,6 +18,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BString; @@ -45,6 +48,9 @@ public final class XmlQName implements RefValue, BXmlQName { private String uri; private String prefix; private BTypedesc typedesc = null; + // FIXME: + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.STRING)); /** * Create attribute map with an XML. @@ -133,6 +139,11 @@ public int hashCode() { return Objects.hash(localName, uri); } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { if (isFrozen()) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java index c2999bd4330f..0247b77726e2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java @@ -17,6 +17,9 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.types.XmlNodeType; @@ -56,6 +59,10 @@ public abstract class XmlValue implements RefValue, BXml, CollectionValue { Type type = PredefinedTypes.TYPE_XML; + + // FIXME: + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.XML)); protected BTypedesc typedesc; protected Type iteratorNextReturnType; @@ -263,4 +270,8 @@ public Type getIteratorNextReturnType() { return iteratorNextReturnType; } + @Override + public SimpleType getSimpleType() { + return simpleType; + } } diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BRecordType.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BRecordType.java index a6933f7e6856..e911a618a76d 100644 --- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BRecordType.java +++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/types/BRecordType.java @@ -47,6 +47,7 @@ public class BRecordType extends BStructureType implements RecordType { public BRecordType mutableType; public BRecordType(BTypeSymbol tSymbol) { + // FIXME: set the simple type correctly super(TypeTags.RECORD, tSymbol); } diff --git a/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java b/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java index 398f210a2517..aec1460c7579 100644 --- a/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java +++ b/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java @@ -20,6 +20,9 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleType; +import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.creators.TypeCreator; import io.ballerina.runtime.api.creators.ValueCreator; @@ -213,6 +216,11 @@ public void set(BString fieldName, Object value) { throw ErrorCreator.createError(StringUtils.fromString("No such field or method: callStack")); } + @Override + public SimpleType getSimpleType() { + return new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); + } + @Override public Object copy(Map refs) { return null; diff --git a/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java b/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java index 802bfd9b7c50..39b9d248b52e 100644 --- a/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java +++ b/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java @@ -17,6 +17,9 @@ */ package org.ballerinalang.testerina.natives.mock; +import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.ObjectType; @@ -51,6 +54,8 @@ public class GenericMockObjectValue implements ObjectValue { private ObjectType type; private BTypedesc typedesc; + private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( + SimpleTypeTag.OBJECT)); public GenericMockObjectValue(ObjectType type, ObjectValue mockObj) { this.type = type; this.mockObj = mockObj; @@ -249,6 +254,11 @@ private Object[] removeUnnecessaryArgs(Object[] args) { return newArgs.toArray(); } + @Override + public SimpleType getSimpleType() { + return simpleType; + } + @Override public Object copy(Map refs) { return null; From 923396425201ae1812dbdedced05f37b45c42a04 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Thu, 18 Jan 2024 12:02:42 +0530 Subject: [PATCH 04/16] Make simple type a record type --- .../main/java/io/ballerina/runtime/api/SimpleType.java | 10 +--------- .../io/ballerina/runtime/api/SimpleTypeBuilder.java | 2 +- .../io/ballerina/runtime/internal/TypeChecker.java | 7 +++---- 3 files changed, 5 insertions(+), 14 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java index e7d79327fea3..829cec1d3362 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -23,15 +23,7 @@ import java.util.stream.Stream; -public class SimpleType { - - public long all; - public long some; - - public SimpleType(long all, long some) { - this.all = all; - this.some = some; - } +public record SimpleType(long all, long some) { public SimpleType intersection(SimpleType other) { long all = this.all & other.all; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java index 5c9084419e97..e1508954783a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java @@ -44,7 +44,7 @@ public static long basicTypeBitset(SimpleTypeTag basicType) { public static SimpleType createContainerSimpleType(Type constraint, SimpleTypeTag tag) { SimpleType constraintSimpleType = constraint.getSimpleType(); - if (constraintSimpleType.all == ALL) { + if (constraintSimpleType.all() == ALL) { // no constraint mean it is the top type return new SimpleType(SimpleTypeBuilder.basicTypeBitset(tag), SimpleTypeBuilder.NONE); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index ba429546670c..e297cdb77057 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -683,12 +683,11 @@ private enum SimpleSubtypeResult { } private static SimpleSubtypeResult checkIsTypeSimple(SimpleType source, SimpleType target) { - S - impleType remainder = source.diff(target); - if (remainder.all == 0 && remainder.some == 0) { + SimpleType remainder = source.diff(target); + if (remainder.all() == 0 && remainder.some() == 0) { return SimpleSubtypeResult.TRUE; } - return remainder.some == 0 ? SimpleSubtypeResult.FALSE : SimpleSubtypeResult.UNKNOWN; + return remainder.some() == 0 ? SimpleSubtypeResult.FALSE : SimpleSubtypeResult.UNKNOWN; } private static boolean checkIsType(Object sourceVal, Type sourceType, Type targetType, From b561d78d0bb10bd3197eb1df0b6894aaec50b4f5 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Thu, 18 Jan 2024 12:47:19 +0530 Subject: [PATCH 05/16] Factor out cases where value type is not needed --- .../ballerina/runtime/internal/TypeChecker.java | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index e297cdb77057..6316053cf738 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -291,7 +291,10 @@ public static boolean anyToJBoolean(Object sourceVal) { * @return true if the value belongs to the given type, false otherwise */ public static boolean checkIsType(Object sourceVal, Type targetType) { - return checkIsType(null, sourceVal, getType(sourceVal), targetType); + if (checkIsType(sourceVal, targetType, null)) { + return true; + } + return checkIsTypeFinalize(null, sourceVal, getType(sourceVal), targetType); } /** @@ -308,6 +311,11 @@ public static boolean checkIsType(List errors, Object sourceVal, Type so return true; } + return checkIsTypeFinalize(errors, sourceVal, sourceType, targetType); + } + + private static boolean checkIsTypeFinalize(List errors, Object sourceVal, Type sourceType, + Type targetType) { if (getImpliedType(sourceType).getTag() == TypeTags.XML_TAG && !targetType.isReadOnly()) { XmlValue val = (XmlValue) sourceVal; if (val.getNodeType() == XmlNodeType.SEQUENCE) { @@ -322,6 +330,7 @@ public static boolean checkIsType(List errors, Object sourceVal, Type so return checkIsLikeOnValue(errors, sourceVal, sourceType, targetType, new ArrayList<>(), false, null); } + /** * Check whether a given value has the same shape as the given type. * @@ -690,6 +699,11 @@ private static SimpleSubtypeResult checkIsTypeSimple(SimpleType source, SimpleTy return remainder.some() == 0 ? SimpleSubtypeResult.FALSE : SimpleSubtypeResult.UNKNOWN; } + private static boolean checkIsType(Object sourceVal, Type targetType, List unresolvedTypes) { + // check if sourceVal is BValue if so type check using that else check is Type + return checkIsType(sourceVal, getType(sourceVal), targetType, unresolvedTypes); + } + private static boolean checkIsType(Object sourceVal, Type sourceType, Type targetType, List unresolvedTypes) { sourceType = getImpliedType(sourceType); @@ -703,6 +717,7 @@ private static boolean checkIsType(Object sourceVal, Type sourceType, Type targe private static boolean checkIsTypeInner(Object sourceVal, Type sourceType, Type targetType, List unresolvedTypes) { + // FIXME: avoid getting the implied type twice sourceType = getImpliedType(sourceType); targetType = getImpliedType(targetType); int sourceTypeTag = sourceType.getTag(); From 1dff0e3690a4756a7c94256916866ad36f6d8f6b Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Fri, 19 Jan 2024 07:11:43 +0530 Subject: [PATCH 06/16] WIP caching --- .../runtime/internal/TypeChecker.java | 112 ++++++------------ 1 file changed, 36 insertions(+), 76 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 6316053cf738..acbbadb10357 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -85,7 +85,6 @@ import java.util.ArrayList; import java.util.Arrays; -import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; @@ -151,14 +150,7 @@ public static Object checkCast(Object sourceVal, Type targetType) { List errors = new ArrayList<>(); Type sourceType = getImpliedType(getType(sourceVal)); - TypeCheckMemoKey memoKey = new TypeCheckMemoKey(sourceType, targetType); - // FIXME: think about thread safety (maybe double synchronize) here - // We don't need to synchronize this as long as we don't care about the actual value being stored in the map - if (typeCheckMemo.containsKey(memoKey)) { - return sourceVal; - } if (checkIsType(errors, sourceVal, sourceType, targetType)) { - typeCheckMemo.put(memoKey, true); return sourceVal; } @@ -307,11 +299,20 @@ public static boolean checkIsType(Object sourceVal, Type targetType) { * @return true if the value belongs to the given type, false otherwise */ public static boolean checkIsType(List errors, Object sourceVal, Type sourceType, Type targetType) { - if (checkIsType(sourceVal, sourceType, targetType, null)) { - return true; - } - - return checkIsTypeFinalize(errors, sourceVal, sourceType, targetType); + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); + Boolean result = typeCheckMemo.get(key); + if (result != null) { + return result; + } + result = checkIsType(sourceVal, sourceType, targetType, null) || + checkIsTypeFinalize(errors, sourceVal, sourceType, targetType); +// if (result != null && result != actual) { +// throw new RuntimeException("unexpected"); +// } else { +// + typeCheckMemo.put(key, result); +// } + return result; } private static boolean checkIsTypeFinalize(List errors, Object sourceVal, Type sourceType, @@ -575,7 +576,19 @@ public static Object getAnnotValue(TypedescValue typedescValue, BString annotTag * @return flag indicating the the equivalence of the two types */ public static boolean checkIsType(Type sourceType, Type targetType) { - return checkIsType(sourceType, targetType, (List) null); + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); + Boolean result = typeCheckMemo.get(key); + if (result != null) { + return result; + } + result = checkIsType(sourceType, targetType, (List) null); +// if (result != null && result != actual) { +// throw new RuntimeException("unexpected"); +// } else { + + typeCheckMemo.put(key, result); +// } + return result; } @Deprecated @@ -3688,7 +3701,7 @@ private TypeChecker() { } // FIXME: - private static class TypeCheckMemoTable implements Map { + private static class TypeCheckMemoTable { private static final int CACHE_SIZE = 100; private final Map cache; @@ -3703,32 +3716,10 @@ protected boolean removeEldestEntry(Map.Entry eldest) { }; } - @Override - public int size() { - return cache.size(); - } - - @Override - public boolean isEmpty() { - return cache.isEmpty(); - } - - @Override - public boolean containsKey(Object key) { - return cache.containsKey(key); - } - - @Override - public boolean containsValue(Object value) { - return cache.containsValue(value); - } - - @Override - public V get(Object key) { + public V get(TypeCheckMemoKey key) { return cache.get(key); } - @Override public V put(TypeCheckMemoKey key, V value) { // FIXME: if (key.sourceType().isReadOnly() || key.destinationType().isReadOnly()) { @@ -3737,60 +3728,29 @@ public V put(TypeCheckMemoKey key, V value) { return cache.put(key, value); } - @Override - public V remove(Object key) { - return cache.remove(key); - } - - @Override - public void putAll(Map m) { - cache.putAll(m); - } - - @Override - public void clear() { - cache.clear(); - } - - @Override - public Set keySet() { - return cache.keySet(); - } - - @Override - public Collection values() { - return cache.values(); - } - - @Override - public Set> entrySet() { - return cache.entrySet(); - } } /** * @param sourceType TODO: better field names */ private record TypeCheckMemoKey(Type sourceType, Type destinationType) { - - // TODO: do something better @Override - public int hashCode() { - return sourceType.hashCode() | destinationType.hashCode(); + public String toString() { + return sourceType.toString() + ":" + destinationType.toString(); } @Override public boolean equals(Object obj) { - if (!(obj instanceof TypeCheckMemoKey other)) { + if (!(obj instanceof TypeCheckMemoKey)) { return false; } - // We are not trying to do type checking here just checking if the same object - return this.sourceType == other.sourceType && this.destinationType == other.destinationType; + TypeCheckMemoKey other = (TypeCheckMemoKey) obj; + return sourceType == other.sourceType && destinationType == other.destinationType; } @Override - public String toString() { - return sourceType.toString() + ":" + destinationType.toString(); + public int hashCode() { + return sourceType.hashCode() | destinationType.hashCode(); } } } From a64e16bf92faf79ef558a467515a06145458e16f Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Mon, 22 Jan 2024 10:02:05 +0530 Subject: [PATCH 07/16] Add read write locks --- .../io/ballerina/runtime/api/types/Type.java | 6 +++--- .../runtime/api/utils/TypeUtils.java | 10 +++++----- .../runtime/internal/TypeChecker.java | 19 ++++++++++++++----- .../runtime/internal/types/BType.java | 18 +++++++++--------- gradle.properties | 2 +- 5 files changed, 32 insertions(+), 23 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java index 9a6d35aef38d..ba3ed982b3e2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/Type.java @@ -96,7 +96,7 @@ public interface Type { Module getPkg(); // TODO: add documentation - void setImpliedType(Type impliedType); - - Type getImpliedType(); +// void setImpliedType(Type impliedType); +// +// Type getImpliedType(); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java index 81dbe74c9047..7f16dfc1e316 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/utils/TypeUtils.java @@ -167,16 +167,16 @@ public static Type getReferredType(Type type) { * else returns the original type */ public static Type getImpliedType(Type type) { - Type memo = type.getImpliedType(); - if (memo != null) { - return memo; - } +// Type memo = type.getImpliedType(); +// if (memo != null) { +// return memo; +// } Type result = getReferredType(type); if (result.getTag() == TypeTags.INTERSECTION_TAG) { result = getImpliedType(((IntersectionType) result).getEffectiveType()); } - type.setImpliedType(result); +// type.setImpliedType(result); return result; } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index acbbadb10357..9844646fa809 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -95,6 +95,8 @@ import java.util.Objects; import java.util.Optional; import java.util.Set; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.stream.Collectors; import static io.ballerina.runtime.api.PredefinedTypes.TYPE_ANY; @@ -3706,9 +3708,11 @@ private static class TypeCheckMemoTable { private static final int CACHE_SIZE = 100; private final Map cache; + private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); + private TypeCheckMemoTable() { // NOTE: accessOrdered mean get is also a structural modification - this.cache = new LinkedHashMap<>(CACHE_SIZE, 0.75f, true) { + this.cache = new LinkedHashMap<>(CACHE_SIZE, 0.75f, false) { @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > CACHE_SIZE; @@ -3717,15 +3721,20 @@ protected boolean removeEldestEntry(Map.Entry eldest) { } public V get(TypeCheckMemoKey key) { - return cache.get(key); +// rwLock.readLock().lock(); + V val = cache.get(key); +// rwLock.readLock().unlock(); + return val; } - public V put(TypeCheckMemoKey key, V value) { + public void put(TypeCheckMemoKey key, V value) { // FIXME: if (key.sourceType().isReadOnly() || key.destinationType().isReadOnly()) { - return value; + return; } - return cache.put(key, value); +// rwLock.writeLock().lock(); + cache.put(key, value); +// rwLock.writeLock().unlock(); } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java index 9edcbda8c935..81b8bb088182 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BType.java @@ -204,13 +204,13 @@ public long getFlags() { return 0; } - @Override - public synchronized void setImpliedType(Type impliedType) { - this.impliedType = impliedType; - } - - @Override - public synchronized Type getImpliedType() { - return this.impliedType; - } +// @Override +// public synchronized void setImpliedType(Type impliedType) { +// this.impliedType = impliedType; +// } +// +// @Override +// public synchronized Type getImpliedType() { +// return this.impliedType; +// } } diff --git a/gradle.properties b/gradle.properties index 07a9f86371d6..d2847ec66ad8 100644 --- a/gradle.properties +++ b/gradle.properties @@ -6,7 +6,7 @@ org.gradle.vfs.watch=false systemProp.scan.capture-build-logging=false systemProp.scan.capture-test-logging=false -version=2201.9.0-SNAPSHOT +version=2201.8.4 group=org.ballerinalang bootstrappedOn=1.1.0-alpha specVersion=2023R1 From 33135f535043f1d2c4cb1d3c3464b48061f96b8d Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Tue, 23 Jan 2024 09:05:14 +0530 Subject: [PATCH 08/16] Use the caching stage only to complex cases --- .../runtime/internal/TypeChecker.java | 104 +++++++++--------- 1 file changed, 55 insertions(+), 49 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 9844646fa809..1a98273cfc33 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -285,10 +285,8 @@ public static boolean anyToJBoolean(Object sourceVal) { * @return true if the value belongs to the given type, false otherwise */ public static boolean checkIsType(Object sourceVal, Type targetType) { - if (checkIsType(sourceVal, targetType, null)) { - return true; - } - return checkIsTypeFinalize(null, sourceVal, getType(sourceVal), targetType); + return checkIsType(sourceVal, targetType, null) || + checkIsTypeFinalize(null, sourceVal, getType(sourceVal), targetType); } /** @@ -301,20 +299,8 @@ public static boolean checkIsType(Object sourceVal, Type targetType) { * @return true if the value belongs to the given type, false otherwise */ public static boolean checkIsType(List errors, Object sourceVal, Type sourceType, Type targetType) { - TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); - Boolean result = typeCheckMemo.get(key); - if (result != null) { - return result; - } - result = checkIsType(sourceVal, sourceType, targetType, null) || + return checkIsType(sourceVal, sourceType, targetType, null) || checkIsTypeFinalize(errors, sourceVal, sourceType, targetType); -// if (result != null && result != actual) { -// throw new RuntimeException("unexpected"); -// } else { -// - typeCheckMemo.put(key, result); -// } - return result; } private static boolean checkIsTypeFinalize(List errors, Object sourceVal, Type sourceType, @@ -578,19 +564,7 @@ public static Object getAnnotValue(TypedescValue typedescValue, BString annotTag * @return flag indicating the the equivalence of the two types */ public static boolean checkIsType(Type sourceType, Type targetType) { - TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); - Boolean result = typeCheckMemo.get(key); - if (result != null) { - return result; - } - result = checkIsType(sourceType, targetType, (List) null); -// if (result != null && result != actual) { -// throw new RuntimeException("unexpected"); -// } else { - - typeCheckMemo.put(key, result); -// } - return result; + return checkIsType(sourceType, targetType, null); } @Deprecated @@ -726,7 +700,21 @@ private static boolean checkIsType(Object sourceVal, Type sourceType, Type targe return switch (checkIsTypeSimple(sourceType.getSimpleType(), targetType.getSimpleType())) { case TRUE -> true; case FALSE -> false; - case UNKNOWN -> checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); + case UNKNOWN -> { + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceVal, sourceType, targetType); + Boolean cachedResult = typeCheckMemo.get(key); + if (cachedResult != null) { + yield cachedResult; + } + boolean result = checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); + typeCheckMemo.put(key, result); +// if (cachedResult == null) { +// typeCheckMemo.put(key, result); +// } else if (cachedResult != result) { +// throw new AssertionError("Unexpected"); +// } + yield result; + } }; } @@ -3703,10 +3691,10 @@ private TypeChecker() { } // FIXME: - private static class TypeCheckMemoTable { + private static final class TypeCheckMemoTable { private static final int CACHE_SIZE = 100; - private final Map cache; + private final Map> cache; private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); @@ -3714,35 +3702,53 @@ private TypeCheckMemoTable() { // NOTE: accessOrdered mean get is also a structural modification this.cache = new LinkedHashMap<>(CACHE_SIZE, 0.75f, false) { @Override - protected boolean removeEldestEntry(Map.Entry eldest) { + protected boolean removeEldestEntry(Map.Entry> eldest) { return size() > CACHE_SIZE; } }; } public V get(TypeCheckMemoKey key) { -// rwLock.readLock().lock(); - V val = cache.get(key); -// rwLock.readLock().unlock(); - return val; + rwLock.readLock().lock(); + TypeCheckMemoData data = cache.get(key); + rwLock.readLock().unlock(); + if (data == null) { + return null; + } + if (data.shouldInvalidate(key)) { + // not sure if invalidation is the right move here maybe we should just return null + // -- this prevents us from potentially reusing the results but should reduce the lookup costs? + rwLock.writeLock().lock(); + // We are not using clear sine multiple threads could do this sequentially + cache.put(key, null); + rwLock.writeLock().unlock(); + return null; + } + return data.data(); } public void put(TypeCheckMemoKey key, V value) { - // FIXME: - if (key.sourceType().isReadOnly() || key.destinationType().isReadOnly()) { - return; - } -// rwLock.writeLock().lock(); - cache.put(key, value); -// rwLock.writeLock().unlock(); + rwLock.writeLock().lock(); + TypeCheckMemoData valueData = new TypeCheckMemoData<>(value, key.sourceValue); + cache.put(key, valueData); + rwLock.writeLock().unlock(); } + } + private record TypeCheckMemoData(V data, Object sourceValue) { + + // TODO: add comment + public boolean shouldInvalidate(TypeCheckMemoKey key) { + int sourceTypeTag = key.sourceType.getTag(); + if (sourceTypeTag != TypeTags.RECORD_TYPE_TAG && sourceTypeTag != TypeTags.OBJECT_TYPE_TAG) { + return false; + } + return key.sourceValue != sourceValue; + } } - /** - * @param sourceType TODO: better field names - */ - private record TypeCheckMemoKey(Type sourceType, Type destinationType) { + // NOTE: we are using sourceValue to invalidate cache for record types + private record TypeCheckMemoKey(Object sourceValue, Type sourceType, Type destinationType) { @Override public String toString() { return sourceType.toString() + ":" + destinationType.toString(); From d06fe011eec9a63bc09fe2f7bd05fe04c1e40e0b Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Tue, 23 Jan 2024 11:38:43 +0530 Subject: [PATCH 09/16] Use a concurrent hashmap instead of manual locking --- .../runtime/internal/TypeChecker.java | 30 +++++-------------- 1 file changed, 7 insertions(+), 23 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 1a98273cfc33..751e6db24b75 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -89,14 +89,12 @@ import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.Set; -import java.util.concurrent.locks.ReadWriteLock; -import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; import static io.ballerina.runtime.api.PredefinedTypes.TYPE_ANY; @@ -3696,42 +3694,28 @@ private static final class TypeCheckMemoTable { private static final int CACHE_SIZE = 100; private final Map> cache; - private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); - private TypeCheckMemoTable() { - // NOTE: accessOrdered mean get is also a structural modification - this.cache = new LinkedHashMap<>(CACHE_SIZE, 0.75f, false) { - @Override - protected boolean removeEldestEntry(Map.Entry> eldest) { - return size() > CACHE_SIZE; - } - }; + this.cache = new ConcurrentHashMap<>(CACHE_SIZE); } public V get(TypeCheckMemoKey key) { - rwLock.readLock().lock(); TypeCheckMemoData data = cache.get(key); - rwLock.readLock().unlock(); if (data == null) { return null; } if (data.shouldInvalidate(key)) { - // not sure if invalidation is the right move here maybe we should just return null - // -- this prevents us from potentially reusing the results but should reduce the lookup costs? - rwLock.writeLock().lock(); - // We are not using clear sine multiple threads could do this sequentially - cache.put(key, null); - rwLock.writeLock().unlock(); + cache.remove(key); return null; } - return data.data(); + return data.data; } public void put(TypeCheckMemoKey key, V value) { - rwLock.writeLock().lock(); + if (cache.size() > CACHE_SIZE) { + cache.clear(); + } TypeCheckMemoData valueData = new TypeCheckMemoData<>(value, key.sourceValue); cache.put(key, valueData); - rwLock.writeLock().unlock(); } } From 8616197ddb52880738e795d1df1aa49db3abc024 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Tue, 23 Jan 2024 13:44:12 +0530 Subject: [PATCH 10/16] Refactor Type tag and builder --- .../io/ballerina/runtime/api/SimpleType.java | 104 +++++++++++++++--- .../runtime/api/SimpleTypeBuilder.java | 79 ------------- .../ballerina/runtime/api/SimpleTypeTag.java | 48 -------- .../runtime/internal/types/BAnyType.java | 5 +- .../runtime/internal/types/BArrayType.java | 5 +- .../runtime/internal/types/BBooleanType.java | 5 +- .../runtime/internal/types/BByteType.java | 5 +- .../runtime/internal/types/BDecimalType.java | 9 +- .../runtime/internal/types/BErrorType.java | 8 +- .../runtime/internal/types/BFiniteType.java | 4 +- .../runtime/internal/types/BFloatType.java | 5 +- .../runtime/internal/types/BFunctionType.java | 19 ++-- .../runtime/internal/types/BFutureType.java | 8 +- .../runtime/internal/types/BHandleType.java | 5 +- .../runtime/internal/types/BIntegerType.java | 11 +- .../internal/types/BIntersectionType.java | 4 +- .../runtime/internal/types/BIteratorType.java | 6 +- .../runtime/internal/types/BMapType.java | 5 +- .../runtime/internal/types/BNeverType.java | 3 +- .../runtime/internal/types/BNullType.java | 5 +- .../runtime/internal/types/BObjectType.java | 5 +- .../runtime/internal/types/BReadonlyType.java | 4 +- .../runtime/internal/types/BStreamType.java | 5 +- .../runtime/internal/types/BStringType.java | 14 +-- .../internal/types/BStructureType.java | 12 +- .../runtime/internal/types/BTableType.java | 5 +- .../runtime/internal/types/BTupleType.java | 13 ++- .../internal/types/BTypeReferenceType.java | 4 +- .../runtime/internal/types/BTypedescType.java | 8 +- .../runtime/internal/types/BUnionType.java | 19 ++-- .../internal/types/BXmlAttributesType.java | 3 +- .../runtime/internal/types/BXmlType.java | 13 ++- .../internal/values/AbstractArrayValue.java | 7 +- .../internal/values/AbstractObjectValue.java | 7 +- .../runtime/internal/values/DecimalValue.java | 7 +- .../runtime/internal/values/ErrorValue.java | 7 +- .../runtime/internal/values/FPValue.java | 5 +- .../runtime/internal/values/FutureValue.java | 7 +- .../runtime/internal/values/HandleValue.java | 7 +- .../internal/values/IteratorValue.java | 5 +- .../runtime/internal/values/MapValueImpl.java | 7 +- .../internal/values/RegExpCommonValue.java | 26 ++--- .../runtime/internal/values/RegExpValue.java | 26 ++--- .../runtime/internal/values/StreamValue.java | 7 +- .../runtime/internal/values/StringValue.java | 6 +- .../internal/values/TableValueImpl.java | 7 +- .../internal/values/TypedescValueImpl.java | 7 +- .../runtime/internal/values/XmlQName.java | 7 +- .../runtime/internal/values/XmlValue.java | 7 +- .../langlib/error/StackTrace.java | 5 +- .../natives/mock/GenericMockObjectValue.java | 7 +- 51 files changed, 264 insertions(+), 348 deletions(-) delete mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java delete mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java index 829cec1d3362..8962a845ece6 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -21,6 +21,9 @@ package io.ballerina.runtime.api; +import io.ballerina.runtime.api.types.Type; + +import java.util.List; import java.util.stream.Stream; public record SimpleType(long all, long some) { @@ -46,32 +49,101 @@ public SimpleType diff(SimpleType other) { return new SimpleType(all, some); } - @Override - public boolean equals(Object obj) { - if (!(obj instanceof SimpleType other)) { - return false; - } - return this.all == other.all && this.some == other.some; - } - @Override public String toString() { - SimpleTypeTag[] allTags = - Stream.of(SimpleTypeTag.values()).filter(tag -> (all & (1L << tag.ordinal())) != 0) - .toArray(SimpleTypeTag[]::new); - SimpleTypeTag[] someTags = - Stream.of(SimpleTypeTag.values()).filter(tag -> (some & (1L << tag.ordinal())) != 0) - .toArray(SimpleTypeTag[]::new); + Tag[] allTags = + Stream.of(Tag.values()).filter(tag -> (all & (1L << tag.ordinal())) != 0) + .toArray(Tag[]::new); + Tag[] someTags = + Stream.of(Tag.values()).filter(tag -> (some & (1L << tag.ordinal())) != 0) + .toArray(Tag[]::new); StringBuilder sb = new StringBuilder(); sb.append("SimpleType all: {"); - for (SimpleTypeTag tag : allTags) { + for (Tag tag : allTags) { sb.append(tag).append(", "); } sb.append("} some: {"); - for (SimpleTypeTag tag : someTags) { + for (Tag tag : someTags) { sb.append(tag).append(", "); } sb.append("}"); return sb.toString(); } + + public enum Tag { + NIL, + BOOLEAN, + INT, + FLOAT, + DECIMAL, + STRING, + ERROR, + TYPEDESC, + HANDLE, + FUNCTION, + + // Inherently mutable + FUTURE, + STREAM, + + // Selectively immutable + LIST, + MAPPING, + TABLE, + XML, + OBJECT, + CELL + } + + public static class Builder { + + public static final long NONE = 0; + public static final long ALL = (1L << (Tag.values().length + 1)) - 1; + + public static long basicTypeUnionBitset(Tag... basicTypes) { + long bits = 0; + for (Tag basicType : basicTypes) { + bits |= (1L << basicType.ordinal()); + } + return bits; + } + + public static long basicTypeBitset(Tag basicType) { + return 1L << basicType.ordinal(); + } + + public static SimpleType createContainerSimpleType(Type constraint, Tag tag) { + SimpleType constraintSimpleType = constraint.getSimpleType(); + if (constraintSimpleType.all == ALL) { + // no constraint mean it is the top type + return new SimpleType(Builder.basicTypeBitset(tag), Builder.NONE); + } + return new SimpleType(Builder.NONE, Builder.basicTypeBitset(tag)); + } + + public static long except(Tag... basicTypes) { + long bits = ALL; + for (Tag basicType : basicTypes) { + bits &= ~(1L << basicType.ordinal()); + } + return bits; + } + + public static SimpleType intersection(List types) { + if (types.isEmpty()) { + // I assume this (and union) is because we are modifying types after the fact + return new SimpleType(NONE, NONE); + } + return types.stream().skip(1).map(Type::getSimpleType) + .reduce(types.get(0).getSimpleType(), SimpleType::intersection); + } + + public static SimpleType union(List types) { + if (types.isEmpty()) { + return new SimpleType(NONE, NONE); + } + return types.stream().skip(1).map(Type::getSimpleType) + .reduce(types.get(0).getSimpleType(), SimpleType::union); + } + } } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java deleted file mode 100644 index e1508954783a..000000000000 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeBuilder.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * - * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). - * - * WSO2 LLC. licenses this file to you under the Apache License, - * Version 2.0 (the "License"); you may not use this file except - * in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * / - * - */ - -package io.ballerina.runtime.api; - -import io.ballerina.runtime.api.types.Type; - -import java.util.List; - -public class SimpleTypeBuilder { - - public static final long NONE = 0; - public static final long ALL = (1L << (SimpleTypeTag.values().length + 1)) - 1; - - public static long basicTypeUnionBitset(SimpleTypeTag... basicTypes) { - long bits = 0; - for (SimpleTypeTag basicType : basicTypes) { - bits |= (1L << basicType.ordinal()); - } - return bits; - } - - public static long basicTypeBitset(SimpleTypeTag basicType) { - return 1L << basicType.ordinal(); - } - - public static SimpleType createContainerSimpleType(Type constraint, SimpleTypeTag tag) { - SimpleType constraintSimpleType = constraint.getSimpleType(); - if (constraintSimpleType.all() == ALL) { - // no constraint mean it is the top type - return new SimpleType(SimpleTypeBuilder.basicTypeBitset(tag), SimpleTypeBuilder.NONE); - } - return new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(tag)); - } - - public static long except(SimpleTypeTag... basicTypes) { - long bits = ALL; - for (SimpleTypeTag basicType : basicTypes) { - bits &= ~(1L << basicType.ordinal()); - } - return bits; - } - - public static SimpleType intersection(List types) { - if (types.isEmpty()) { - // I assume this (and union) is because we are modifying types after the fact - return new SimpleType(NONE, NONE); - } - return types.stream().skip(1).map(Type::getSimpleType) - .reduce(types.get(0).getSimpleType(), SimpleType::intersection); - } - - public static SimpleType union(List types) { - if (types.isEmpty()) { - return new SimpleType(NONE, NONE); - } - return types.stream().skip(1).map(Type::getSimpleType) - .reduce(types.get(0).getSimpleType(), SimpleType::union); - } -} - diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java deleted file mode 100644 index 68ed9f56adb7..000000000000 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleTypeTag.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * - * Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org). - * - * WSO2 LLC. licenses this file to you under the Apache License, - * Version 2.0 (the "License"); you may not use this file except - * in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * / - * - */ - -package io.ballerina.runtime.api; - -public enum SimpleTypeTag { - - NIL, - BOOLEAN, - INT, - FLOAT, - DECIMAL, - STRING, - ERROR, - TYPEDESC, - HANDLE, - FUNCTION, - - // Inherently mutable - FUTURE, - STREAM, - - // Selectively immutable - LIST, - MAPPING, - TABLE, - XML, - OBJECT, - CELL -} diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java index baf349f4fa62..2399188fd5d4 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java @@ -20,8 +20,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.flags.TypeFlags; @@ -50,7 +48,8 @@ public class BAnyType extends BType implements AnyType { */ public BAnyType(String typeName, Module pkg, boolean readonly) { super(typeName, pkg, RefValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.except(SimpleTypeTag.ERROR))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.except(SimpleType.Tag.ERROR))); this.readonly = readonly; if (!readonly) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java index 0ff94439abf3..44140e8c0d49 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.ArrayType; @@ -79,7 +77,8 @@ public BArrayType(Type elemType, int size, boolean readonly, int typeFlags) { public BArrayType(int typeFlags, int size, boolean readonly, boolean hasFillerValue) { // FIXME: properly differentiate list top type super(null, null, ArrayValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.LIST))); this.typeFlags = typeFlags; if (size != -1) { state = ArrayState.CLOSED; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java index a4c47cbb6b25..4242b76d83ae 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BBooleanType.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.BooleanType; @@ -38,7 +36,8 @@ public class BBooleanType extends BType implements BooleanType { */ public BBooleanType(String typeName, Module pkg) { super(typeName, pkg, Boolean.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.BOOLEAN), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.BOOLEAN), + SimpleType.Builder.NONE)); } @SuppressWarnings("unchecked") diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java index a6c0640da9e9..4b15bf236996 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BByteType.java @@ -20,8 +20,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ByteType; @@ -39,7 +37,8 @@ public class BByteType extends BType implements ByteType { */ public BByteType(String typeName, Module pkg) { super(typeName, pkg, Integer.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.INT))); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java index e688a3a4ee58..e04f5b1d0b95 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BDecimalType.java @@ -20,8 +20,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.DecimalType; import io.ballerina.runtime.internal.values.DecimalValue; @@ -43,10 +41,13 @@ public class BDecimalType extends BType implements DecimalType { */ private final SimpleType simpleType = - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.DECIMAL), SimpleTypeBuilder.NONE); + new SimpleType( + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.DECIMAL), + SimpleType.Builder.NONE); public BDecimalType(String typeName, Module pkg) { super(typeName, pkg, DecimalValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.INT))); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java index a8b3663c8f2f..c8fd003268ec 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java @@ -20,8 +20,6 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ErrorType; import io.ballerina.runtime.api.types.IntersectionType; @@ -44,13 +42,15 @@ public class BErrorType extends BAnnotatableType implements ErrorType { public BErrorType(String typeName, Module pkg, Type detailType) { // FIXME: super(typeName, pkg, ErrorValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.ERROR))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR))); this.detailType = detailType; } public BErrorType(String typeName, Module pkg) { super(typeName, pkg, ErrorValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.ERROR))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR))); } public void setTypeIdSet(BTypeIdSet typeIdSet) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java index 59421b8cce5f..4353f97d6d87 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java @@ -19,7 +19,6 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.FiniteType; @@ -54,7 +53,8 @@ public BFiniteType(String typeName, Set values, int typeFlags) { public BFiniteType(String typeName, String originalName, Set values, int typeFlags) { // FIXME: - super(typeName, null, RefValue.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); + super(typeName, null, RefValue.class, new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.ALL)); this.valueSpace = values; this.typeFlags = typeFlags; this.originalName = originalName; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java index 71ed892f2378..fc1c32a4730a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFloatType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.FloatType; @@ -40,7 +38,8 @@ public class BFloatType extends BType implements FloatType { */ public BFloatType(String typeName, Module pkg) { super(typeName, pkg, Double.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FLOAT), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FLOAT), + SimpleType.Builder.NONE)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java index 05b3441fb66c..4caba1a529fd 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFunctionType.java @@ -21,8 +21,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.types.FunctionType; @@ -45,7 +43,8 @@ public class BFunctionType extends BAnnotatableType implements FunctionType { public BFunctionType(Module pkg) { super("function ()", pkg, Object.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION), + SimpleType.Builder.NONE)); this.parameters = new Parameter[0]; this.retType = PredefinedTypes.TYPE_NULL; this.flags = 0; @@ -54,10 +53,10 @@ public BFunctionType(Module pkg) { public BFunctionType(Module pkg, long flags) { // FIXME: formattitng super("function", pkg, Object.class, - flags == 0 ? new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION), - SimpleTypeBuilder.NONE) : - new SimpleType(SimpleTypeBuilder.NONE, - SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); + flags == 0 ? new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION), + SimpleType.Builder.NONE) : + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION))); this.parameters = null; this.retType = null; this.flags = flags; @@ -66,7 +65,8 @@ public BFunctionType(Module pkg, long flags) { @Deprecated public BFunctionType(Module pkg, Type[] paramTypes, Type restType, Type retType, long flags) { super("function ()", pkg, Object.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION))); this.restType = restType; this.retType = retType; this.flags = flags; @@ -75,7 +75,8 @@ public BFunctionType(Module pkg, Type[] paramTypes, Type restType, Type retType, public BFunctionType(Module pkg, Parameter[] parameters, Type restType, Type retType, long flags, String name) { super(name, pkg, Object.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION))); this.parameters = parameters; this.restType = restType; this.retType = retType; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java index 14e6b5706f67..ad5428ff2a65 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFutureType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.FutureType; @@ -44,13 +42,15 @@ public class BFutureType extends BType implements FutureType { */ public BFutureType(String typeName, Module pkg) { super(typeName, pkg, Object.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUTURE), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUTURE), + SimpleType.Builder.NONE)); } public BFutureType(Type constraint) { // FIXME: what is the correct top type? super(TypeConstants.FUTURE_TNAME, null, Object.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUTURE))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUTURE))); this.constraint = constraint; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java index 4c195241c04a..b37231981705 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BHandleType.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.HandleType; @@ -40,7 +38,8 @@ public class BHandleType extends BType implements HandleType { */ public BHandleType(String typeName, Module pkg) { super(typeName, pkg, RefValue.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.HANDLE), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.HANDLE), + SimpleType.Builder.NONE)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java index 051f1a244e02..b1481acb6b0f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntegerType.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.IntegerType; @@ -41,15 +39,18 @@ public class BIntegerType extends BType implements IntegerType { */ public BIntegerType(String typeName, Module pkg) { super(typeName, pkg, Long.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.INT), + SimpleType.Builder.NONE)); tag = TypeTags.INT_TAG; } public BIntegerType(String typeName, Module pkg, int tag) { super(typeName, pkg, Long.class, tag == TypeTags.INT_TAG ? - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT), SimpleTypeBuilder.NONE) : - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.INT))); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.INT), + SimpleType.Builder.NONE) : + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.INT))); this.tag = tag; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java index a7469e6dde29..32d55c5bb3df 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIntersectionType.java @@ -18,7 +18,7 @@ package io.ballerina.runtime.internal.types; import io.ballerina.runtime.api.Module; -import io.ballerina.runtime.api.SimpleTypeBuilder; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.flags.TypeFlags; @@ -82,7 +82,7 @@ public BIntersectionType(String typeName, Module pkg, Type[] constituentTypes, } private BIntersectionType(String typeName, Module pkg, Type[] constituentTypes, int typeFlags, boolean readonly) { - super(typeName, pkg, Object.class, SimpleTypeBuilder.intersection(List.of(constituentTypes))); + super(typeName, pkg, Object.class, SimpleType.Builder.intersection(List.of(constituentTypes))); this.constituentTypes = Arrays.asList(constituentTypes); this.typeFlags = typeFlags; this.readonly = readonly; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java index 8ffe662d3645..8e79c4a36393 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BIteratorType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.IteratorType; import io.ballerina.runtime.internal.values.IteratorValue; @@ -33,8 +31,8 @@ public class BIteratorType extends BType implements IteratorType { public BIteratorType(String typeName, Module pkg) { - super(typeName, pkg, IteratorValue.class, new SimpleType(SimpleTypeBuilder.NONE, - SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT))); + super(typeName, pkg, IteratorValue.class, new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT))); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java index 52b0bff55b81..a4369a544529 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java @@ -19,8 +19,7 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -71,7 +70,7 @@ public BMapType(String typeName, Type constraint, Module pkg) { public BMapType(String typeName, Type constraint, Module pkg, boolean readonly) { super(typeName, pkg, MapValueImpl.class, - SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.MAPPING)); + SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.MAPPING)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java index cb66cde54d8d..41ea8896dda2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNeverType.java @@ -19,7 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.NeverType; @@ -37,7 +36,7 @@ public class BNeverType extends BNullType implements NeverType { */ public BNeverType(Module pkg) { super(TypeConstants.NEVER_TNAME, pkg); - simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.NONE); + simpleType = new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.NONE); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java index 97c682e2886b..bc2255408766 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BNullType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.NullType; @@ -39,7 +37,8 @@ public class BNullType extends BType implements NullType { */ public BNullType(String typeName, Module pkg) { super(typeName, pkg, null, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.NIL), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.NIL), + SimpleType.Builder.NONE)); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java index 2e3a96cdcebe..e90c67a16aff 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java @@ -20,8 +20,6 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.flags.SymbolFlags; @@ -67,7 +65,8 @@ public class BObjectType extends BStructureType implements ObjectType { private boolean resolving; // FIXME: private final SimpleType simpleType = - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT)); /** * Create a {@code BObjectType} which represents the user defined struct type. diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java index c04a55dbef2e..c950fee06f03 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BReadonlyType.java @@ -19,7 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.ReadonlyType; import io.ballerina.runtime.internal.values.RefValue; @@ -32,7 +31,8 @@ public class BReadonlyType extends BType implements ReadonlyType { public BReadonlyType(String typeName, Module pkg) { - super(typeName, pkg, RefValue.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); + super(typeName, pkg, RefValue.class, new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.ALL)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java index b3b3ec8f3fa2..0dc986711acb 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStreamType.java @@ -21,8 +21,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.StreamType; @@ -52,7 +50,8 @@ public class BStreamType extends BType implements StreamType { public BStreamType(String typeName, Type constraint, Type completionType, Module pkgPath) { // FIXME: what is the correct top type super(typeName, pkgPath, StreamValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STREAM))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.STREAM))); this.constraint = constraint; this.completionType = completionType; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java index cdcc3d250979..67342f11fdd2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStringType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.types.StringType; @@ -42,17 +40,19 @@ public class BStringType extends BType implements StringType { */ public BStringType(String typeName, Module pkg) { super(typeName, pkg, String.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.STRING), + SimpleType.Builder.NONE)); tag = TypeTags.STRING_TAG; } public BStringType(String typeName, Module pkg, int tag) { // FIXME: formatting super(typeName, pkg, String.class, - tag == TypeTags.STRING_TAG ? new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING), - SimpleTypeBuilder.NONE) : - new SimpleType(SimpleTypeBuilder.NONE, - SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.STRING))); + tag == TypeTags.STRING_TAG ? + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.STRING), + SimpleType.Builder.NONE) : + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.STRING))); this.tag = tag; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java index 07d0cc9d0784..05048de18627 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BStructureType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.types.Field; import io.ballerina.runtime.api.types.StructureType; @@ -46,8 +44,9 @@ public abstract class BStructureType extends BAnnotatableType implements Structu * @param valueClass of the structure type */ public BStructureType(String typeName, Module pkg, long flags, Class valueClass) { - super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.MAPPING))); + super(typeName, pkg, valueClass, + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.MAPPING))); this.flags = flags; fields = new HashMap<>(); } @@ -63,8 +62,9 @@ public BStructureType(String typeName, Module pkg, long flags, Class valueClass, Map fields) { - super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.MAPPING))); + super(typeName, pkg, valueClass, + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.MAPPING))); this.flags = flags; this.fields = fields; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java index 610dbbf53ff7..0c1160e572ef 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java @@ -17,8 +17,7 @@ */ package io.ballerina.runtime.internal.types; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -60,7 +59,7 @@ public BTableType(Type constraint, boolean readonly) { super(TypeConstants.TABLE_TNAME, null, TableValue.class, - SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.TABLE)); + SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.TABLE)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java index 89dde0724320..f7bba5d69cbf 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTupleType.java @@ -20,8 +20,6 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.IntersectionType; @@ -60,8 +58,9 @@ public class BTupleType extends BAnnotatableType implements TupleType { * @param typeList of the tuple type */ public BTupleType(List typeList) { - super(null, null, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.LIST))); + super(null, null, Object.class, + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.LIST))); this.tupleTypes = typeList; this.restType = null; checkAllMembers(); @@ -86,7 +85,8 @@ public BTupleType(List typeList, Type restType, int typeFlags, boolean rea */ public BTupleType(List typeList, Type restType, int typeFlags, boolean isCyclic, boolean readonly) { super(null, null, Object.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.LIST))); if (readonly) { this.resolvingReadonly = true; this.tupleTypes = getReadOnlyTypes(typeList); @@ -103,7 +103,8 @@ public BTupleType(List typeList, Type restType, int typeFlags, boolean isC public BTupleType(String name, Module pkg, int typeFlags, boolean isCyclic, boolean readonly) { super(name, pkg, Object.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.LIST))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.LIST))); this.typeFlags = typeFlags; this.tupleTypes = new ArrayList<>(0); this.restType = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java index 1f6bd654d33c..365fabf90f3e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeReferenceType.java @@ -21,7 +21,6 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.IntersectableReferenceType; @@ -45,7 +44,8 @@ public class BTypeReferenceType extends BAnnotatableType implements Intersectabl public BTypeReferenceType(String typeName, Module pkg, int typeFlags, boolean readOnly) { // FIXME: - super(typeName, pkg, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); + super(typeName, pkg, Object.class, new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.ALL)); this.typeFlags = typeFlags; this.readOnly = readOnly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java index 0f2126fe6ecf..a5fcf3e41862 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypedescType.java @@ -21,8 +21,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.Type; @@ -40,12 +38,14 @@ public class BTypedescType extends BType implements TypedescType { public BTypedescType(String typeName, Module pkg) { super(typeName, pkg, Object.class, - new SimpleType(SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.TYPEDESC), SimpleTypeBuilder.NONE)); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.TYPEDESC), + SimpleType.Builder.NONE)); } public BTypedescType(Type constraint) { super(TypeConstants.TYPEDESC_TNAME, null, TypedescValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.TYPEDESC))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.TYPEDESC))); this.constraint = constraint; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java index 89af46703865..ae4189587f5c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java @@ -19,7 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.flags.TypeFlags; @@ -74,7 +73,7 @@ public BUnionType(List memberTypes, int typeFlags, boolean readonly, bool private BUnionType(List memberTypes, List originalMemberTypes, int typeFlags, boolean isCyclic, long flags) { - super(null, null, Object.class, SimpleTypeBuilder.union(Stream.concat(memberTypes.stream(), + super(null, null, Object.class, SimpleType.Builder.union(Stream.concat(memberTypes.stream(), originalMemberTypes.stream()).collect(Collectors.toList()))); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); @@ -84,7 +83,8 @@ private BUnionType(List memberTypes, List originalMemberTypes, int t } public BUnionType(int typeFlags, boolean isCyclic, long flags) { - super(null, null, Object.class, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); + super(null, null, Object.class, + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.ALL)); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.memberTypes = new ArrayList<>(0); @@ -97,7 +97,7 @@ public BUnionType(List memberTypes) { } public BUnionType(String typeName, Module pkg, List memberTypes, boolean readonly) { - super(typeName, pkg, Object.class, SimpleTypeBuilder.union(memberTypes)); + super(typeName, pkg, Object.class, SimpleType.Builder.union(memberTypes)); this.readonly = readonly; setMemberTypes(memberTypes); } @@ -107,7 +107,7 @@ public BUnionType(List memberTypes, boolean readonly) { } public BUnionType(List memberTypes, boolean readonly, boolean isCyclic) { - super(null, null, Object.class, SimpleTypeBuilder.union(memberTypes)); + super(null, null, Object.class, SimpleType.Builder.union(memberTypes)); this.typeFlags = 0; this.readonly = readonly; setMemberTypes(memberTypes); @@ -123,7 +123,7 @@ public BUnionType(Type[] memberTypes, Type[] originalMemberTypes, int typeFlags, } public BUnionType(List memberTypes, String name, Module pkg, int typeFlags, boolean isCyclic, long flags) { - super(name, pkg, Object.class, SimpleTypeBuilder.union(memberTypes)); + super(name, pkg, Object.class, SimpleType.Builder.union(memberTypes)); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.memberTypes = memberTypes; @@ -136,7 +136,8 @@ public BUnionType(String name, Module pkg, int typeFlags, boolean isCyclic, long } protected BUnionType(String typeName, Module pkg, boolean readonly, Class valueClass) { - super(typeName, pkg, valueClass, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.NONE)); + super(typeName, pkg, valueClass, + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.NONE)); this.readonly = readonly; } @@ -158,8 +159,8 @@ protected BUnionType(BUnionType unionType, String typeName, boolean readonly) { public BUnionType(Type[] memberTypes, Type[] originalMemberTypes, String name, Module pkg, int typeFlags, boolean isCyclic, long flags) { super(name, pkg, Object.class, - SimpleTypeBuilder.union(List.of(memberTypes)) - .union(SimpleTypeBuilder.union(List.of(originalMemberTypes)))); + SimpleType.Builder.union(List.of(memberTypes)) + .union(SimpleType.Builder.union(List.of(originalMemberTypes)))); this.typeFlags = typeFlags; this.readonly = isReadOnlyFlagOn(flags); this.isCyclic = isCyclic; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java index 2a324c404ead..434c31806f8b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlAttributesType.java @@ -19,7 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.types.XmlAttributesType; @@ -38,7 +37,7 @@ public class BXmlAttributesType extends BType implements XmlAttributesType { */ public BXmlAttributesType(String typeName, Module pkg) { // FIXME: string, error , () - super(typeName, pkg, null, new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.ALL)); + super(typeName, pkg, null, new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.ALL)); } public V getZeroValue() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java index ab9fd9ef9b14..ae53e9da5914 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.types.IntersectionType; @@ -54,7 +52,7 @@ public class BXmlType extends BType implements XmlType { */ public BXmlType(String typeName, Type constraint, Module pkg) { super(typeName, pkg, XmlValue.class, - SimpleTypeBuilder.createContainerSimpleType(constraint, SimpleTypeTag.XML)); + SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.XML)); this.constraint = constraint; this.tag = TypeTags.XML_TAG; this.readonly = false; @@ -63,7 +61,8 @@ public BXmlType(String typeName, Type constraint, Module pkg) { // FIXME: public BXmlType(String typeName, Module pkg, int tag, boolean readonly) { super(typeName, pkg, XmlValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.XML))); this.tag = tag; this.readonly = readonly; this.constraint = null; @@ -71,7 +70,8 @@ public BXmlType(String typeName, Module pkg, int tag, boolean readonly) { public BXmlType(String typeName, Type constraint, Module pkg, boolean readonly) { super(typeName, pkg, XmlValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.XML))); this.tag = TypeTags.XML_TAG; this.readonly = readonly; this.constraint = constraint; @@ -79,7 +79,8 @@ public BXmlType(String typeName, Type constraint, Module pkg, boolean readonly) public BXmlType(Type constraint, boolean readonly) { super(TypeConstants.XML_TNAME, null, XmlValue.class, - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.XML))); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.XML))); this.tag = TypeTags.XML_TAG; this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java index 95f804d21402..fed2a740ee04 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractArrayValue.java @@ -17,8 +17,6 @@ */ package io.ballerina.runtime.internal.values; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -66,8 +64,9 @@ public abstract class AbstractArrayValue implements ArrayValue { protected int size = 0; protected Type iteratorNextReturnType; - private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.LIST)); + private SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.LIST)); @Override public SimpleType getSimpleType() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java index 1b44f45b39be..4cca803b57bc 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/AbstractObjectValue.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.flags.SymbolFlags; import io.ballerina.runtime.api.types.Field; @@ -67,8 +65,9 @@ public abstract class AbstractObjectValue implements ObjectValue { private final Type type; private final HashMap nativeData = new HashMap<>(); - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.OBJECT)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.OBJECT)); public AbstractObjectValue(Type type) { this.type = type; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java index c3bcd173ebe4..78c637bd2878 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/DecimalValue.java @@ -19,8 +19,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -59,8 +57,9 @@ public class DecimalValue implements SimpleValue, BDecimal { private static final BigDecimal MIN_DECIMAL_MAGNITUDE = new BigDecimal("1.000000000000000000000000000000000e-6143", MathContext.DECIMAL128); - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.DECIMAL)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.DECIMAL)); // Variable used to track the kind of a decimal value. @Deprecated diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java index e875d04afeb2..48629f714632 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ErrorValue.java @@ -20,8 +20,6 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; @@ -84,8 +82,9 @@ public class ErrorValue extends BError implements RefValue { private static final String INIT_FUNCTION_SUFFIX = ".."; private static final String START_FUNCTION_SUFFIX = "."; private static final String STOP_FUNCTION_SUFFIX = "."; - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.ERROR)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.ERROR)); public ErrorValue(BString message) { this(new BErrorType(TypeConstants.ERROR, PredefinedTypes.TYPE_ERROR.getPackage(), TYPE_MAP), diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java index 588007275111..fbb1f8b479ed 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FPValue.java @@ -17,8 +17,6 @@ */ package io.ballerina.runtime.internal.values; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.async.StrandMetadata; import io.ballerina.runtime.api.constants.RuntimeConstants; @@ -52,7 +50,8 @@ public class FPValue implements BFunctionPointer, RefValue { final Type type; private BTypedesc typedesc; private SimpleType simpleType = - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.FUNCTION)); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.FUNCTION)); Function function; public boolean isConcurrent; public String strandName; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java index d3d942a72780..c7995c1bc820 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/FutureValue.java @@ -17,8 +17,6 @@ */ package io.ballerina.runtime.internal.values; - import io.ballerina.runtime.api.SimpleTypeBuilder; - import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.async.Callback; import io.ballerina.runtime.api.types.Type; @@ -59,8 +57,9 @@ public class FutureValue implements BFuture, RefValue { private boolean waited; Type type; - private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.FUTURE)); + private SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.FUTURE)); @Deprecated public FutureValue(Strand strand, Callback callback, Type constraint) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java index d88733d27133..c3f578b92ece 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/HandleValue.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BHandle; @@ -42,8 +40,9 @@ public class HandleValue implements BHandle, RefValue { private Object value; private BTypedesc typedesc; - private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.HANDLE)); + private SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.HANDLE)); public HandleValue(Object value) { this.value = value; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java index 0e81f7ff5d61..b498ac0b2657 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/IteratorValue.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BIterator; @@ -42,7 +40,8 @@ public interface IteratorValue extends RefValue, BIterator { BTypedesc TYPEDESC = new TypedescValueImpl(PredefinedTypes.TYPE_ITERATOR); SimpleType TAGGED_TYPE = - new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); + new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT)); /* Default implementation */ diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java index 611adc5286dd..341793e02f17 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/MapValueImpl.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -103,8 +101,9 @@ public class MapValueImpl extends LinkedHashMap implements RefValue, private Type referredType; private final Map nativeData = new HashMap<>(); private Type iteratorNextReturnType; - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.MAPPING)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.MAPPING)); public MapValueImpl(TypedescValue typedesc) { this(typedesc.getDescribingType()); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java index 2529688be439..bb84bc7b0e9e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpCommonValue.java @@ -19,8 +19,6 @@ import io.ballerina.runtime.api.PredefinedTypes; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; import io.ballerina.runtime.api.values.BTypedesc; @@ -41,18 +39,18 @@ public abstract class RegExpCommonValue implements RefValue { // FIXME: currently our anydata representation don't have regex private final SimpleType simpleType = new SimpleType( - SimpleTypeBuilder.basicTypeUnionBitset( - SimpleTypeTag.NIL, - SimpleTypeTag.BOOLEAN, - SimpleTypeTag.INT, - SimpleTypeTag.FLOAT, - SimpleTypeTag.DECIMAL, - SimpleTypeTag.STRING, - SimpleTypeTag.LIST, - SimpleTypeTag.MAPPING, - SimpleTypeTag.TABLE, - SimpleTypeTag.XML), - SimpleTypeBuilder.NONE); + SimpleType.Builder.basicTypeUnionBitset( + SimpleType.Tag.NIL, + SimpleType.Tag.BOOLEAN, + SimpleType.Tag.INT, + SimpleType.Tag.FLOAT, + SimpleType.Tag.DECIMAL, + SimpleType.Tag.STRING, + SimpleType.Tag.LIST, + SimpleType.Tag.MAPPING, + SimpleType.Tag.TABLE, + SimpleType.Tag.XML), + SimpleType.Builder.NONE); @Override public String expressionStringValue(BLink parent) { return stringValue(parent); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java index 4a580afa525f..25ecb0206052 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RegExpValue.java @@ -16,8 +16,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; @@ -44,18 +42,18 @@ public class RegExpValue implements BRegexpValue, RefValue { private BTypedesc typedesc; private static final Type type = PredefinedTypes.TYPE_READONLY_ANYDATA; private final SimpleType simpleType = new SimpleType( - SimpleTypeBuilder.basicTypeUnionBitset( - SimpleTypeTag.NIL, - SimpleTypeTag.BOOLEAN, - SimpleTypeTag.INT, - SimpleTypeTag.FLOAT, - SimpleTypeTag.DECIMAL, - SimpleTypeTag.STRING, - SimpleTypeTag.LIST, - SimpleTypeTag.MAPPING, - SimpleTypeTag.TABLE, - SimpleTypeTag.XML), - SimpleTypeBuilder.NONE); + SimpleType.Builder.basicTypeUnionBitset( + SimpleType.Tag.NIL, + SimpleType.Tag.BOOLEAN, + SimpleType.Tag.INT, + SimpleType.Tag.FLOAT, + SimpleType.Tag.DECIMAL, + SimpleType.Tag.STRING, + SimpleType.Tag.LIST, + SimpleType.Tag.MAPPING, + SimpleType.Tag.TABLE, + SimpleType.Tag.XML), + SimpleType.Builder.NONE); public RegExpValue(RegExpDisjunction regExpDisjunction) { this.regExpDisjunction = regExpDisjunction; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java index d39bb4cf7daf..9bcf331edac2 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StreamValue.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; @@ -50,8 +48,9 @@ public class StreamValue implements RefValue, BStream { private Type completionType; private Type iteratorNextReturnType; private BObject iteratorObj; - private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.STREAM)); + private SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.STREAM)); /** diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java index 8ecf34da1921..595c7aaa42c6 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/StringValue.java @@ -18,7 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; @@ -26,7 +25,7 @@ import java.util.Map; -import static io.ballerina.runtime.api.SimpleTypeTag.STRING; +import static io.ballerina.runtime.api.SimpleType.Tag.STRING; /** * Class representing ballerina strings. @@ -37,7 +36,8 @@ public abstract class StringValue implements BString, SimpleValue { final String value; final boolean isNonBmp; - final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(STRING)); + final SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset(STRING)); protected StringValue(String value, boolean isNonBmp) { this.value = value; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java index b7bdd9b8ab77..b9fbae5e294d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TableValueImpl.java @@ -17,8 +17,6 @@ package io.ballerina.runtime.internal.values; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -106,8 +104,9 @@ public class TableValueImpl implements TableValue { private final Map nativeData = new HashMap<>(); private BTypedesc typedesc; - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.TABLE)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.TABLE)); public TableValueImpl(TableType tableType) { this.type = this.tableType = tableType; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java index 6cdd52425190..ba959f616826 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/TypedescValueImpl.java @@ -17,8 +17,6 @@ */ package io.ballerina.runtime.internal.values; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -59,8 +57,9 @@ public class TypedescValueImpl implements TypedescValue { public MapValue[] closures; public MapValue annotations; private BTypedesc typedesc; - private SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.TYPEDESC)); + private SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.TYPEDESC)); @Deprecated public TypedescValueImpl(Type describingType) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java index d5f5665e0563..5214f86071ae 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlQName.java @@ -18,8 +18,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.types.Type; import io.ballerina.runtime.api.values.BLink; @@ -49,8 +47,9 @@ public final class XmlQName implements RefValue, BXmlQName { private String prefix; private BTypedesc typedesc = null; // FIXME: - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.STRING)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.STRING)); /** * Create attribute map with an XML. diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java index 0247b77726e2..9a437054d263 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/XmlValue.java @@ -17,8 +17,6 @@ package io.ballerina.runtime.internal.values; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.types.Type; @@ -61,8 +59,9 @@ public abstract class XmlValue implements RefValue, BXml, CollectionValue { Type type = PredefinedTypes.TYPE_XML; // FIXME: - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.XML)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.XML)); protected BTypedesc typedesc; protected Type iteratorNextReturnType; diff --git a/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java b/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java index aec1460c7579..7d1b60cf566b 100644 --- a/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java +++ b/langlib/lang.error/src/main/java/org/ballerinalang/langlib/error/StackTrace.java @@ -20,9 +20,7 @@ import io.ballerina.identifier.Utils; import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; -import io.ballerina.runtime.api.SimpleTypeBuilder; import io.ballerina.runtime.api.SimpleType; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.creators.ErrorCreator; import io.ballerina.runtime.api.creators.TypeCreator; import io.ballerina.runtime.api.creators.ValueCreator; @@ -218,7 +216,8 @@ public void set(BString fieldName, Object value) { @Override public SimpleType getSimpleType() { - return new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset(SimpleTypeTag.OBJECT)); + return new SimpleType(SimpleType.Builder.NONE, + SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT)); } @Override diff --git a/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java b/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java index 39b9d248b52e..d02f6b8a9ade 100644 --- a/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java +++ b/misc/testerina/modules/testerina-core/src/main/java/org/ballerinalang/testerina/natives/mock/GenericMockObjectValue.java @@ -17,8 +17,6 @@ */ package org.ballerinalang.testerina.natives.mock; -import io.ballerina.runtime.api.SimpleTypeBuilder; -import io.ballerina.runtime.api.SimpleTypeTag; import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.creators.ErrorCreator; @@ -54,8 +52,9 @@ public class GenericMockObjectValue implements ObjectValue { private ObjectType type; private BTypedesc typedesc; - private final SimpleType simpleType = new SimpleType(SimpleTypeBuilder.NONE, SimpleTypeBuilder.basicTypeBitset( - SimpleTypeTag.OBJECT)); + private final SimpleType simpleType = new SimpleType( + SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset( + SimpleType.Tag.OBJECT)); public GenericMockObjectValue(ObjectType type, ObjectValue mockObj) { this.type = type; this.mockObj = mockObj; From cc5ea3aa5c06ee8836abe4811e578141f6abd877 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Tue, 23 Jan 2024 15:53:49 +0530 Subject: [PATCH 11/16] Use tighter simple types --- .../src/main/java/io/ballerina/runtime/api/SimpleType.java | 2 ++ .../java/io/ballerina/runtime/internal/types/BAnyType.java | 3 +-- .../io/ballerina/runtime/internal/types/BAnydataType.java | 6 ++++++ .../io/ballerina/runtime/internal/types/BArrayType.java | 5 ++--- .../io/ballerina/runtime/internal/types/BErrorType.java | 6 +++--- .../io/ballerina/runtime/internal/types/BObjectType.java | 5 ++--- .../runtime/internal/types/BParameterizedType.java | 3 +-- 7 files changed, 17 insertions(+), 13 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java index 8962a845ece6..a72a5af3961a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -97,6 +97,7 @@ public enum Tag { public static class Builder { + // TODO: Move these to SimpleType? public static final long NONE = 0; public static final long ALL = (1L << (Tag.values().length + 1)) - 1; @@ -112,6 +113,7 @@ public static long basicTypeBitset(Tag basicType) { return 1L << basicType.ordinal(); } + // TODO: container is not a good name? public static SimpleType createContainerSimpleType(Type constraint, Tag tag) { SimpleType constraintSimpleType = constraint.getSimpleType(); if (constraintSimpleType.all == ALL) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java index 2399188fd5d4..ebf8f892158b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnyType.java @@ -48,8 +48,7 @@ public class BAnyType extends BType implements AnyType { */ public BAnyType(String typeName, Module pkg, boolean readonly) { super(typeName, pkg, RefValue.class, - new SimpleType(SimpleType.Builder.NONE, - SimpleType.Builder.except(SimpleType.Tag.ERROR))); + new SimpleType(SimpleType.Builder.except(SimpleType.Tag.ERROR), SimpleType.Builder.NONE)); this.readonly = readonly; if (!readonly) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnydataType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnydataType.java index 2f7b28c53605..3bfa144295ee 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnydataType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BAnydataType.java @@ -19,6 +19,7 @@ import io.ballerina.runtime.api.Module; import io.ballerina.runtime.api.PredefinedTypes; +import io.ballerina.runtime.api.SimpleType; import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.constants.TypeConstants; import io.ballerina.runtime.api.flags.TypeFlags; @@ -40,6 +41,11 @@ public class BAnydataType extends BUnionType implements AnydataType { */ public BAnydataType(String typeName, Module pkg, boolean readonly) { super(typeName, pkg, readonly, RefValue.class); + simpleType = new SimpleType( + SimpleType.Builder.basicTypeUnionBitset(SimpleType.Tag.NIL, SimpleType.Tag.BOOLEAN, SimpleType.Tag.INT, + SimpleType.Tag.FLOAT, SimpleType.Tag.DECIMAL, SimpleType.Tag.STRING, SimpleType.Tag.XML), + SimpleType.Builder.basicTypeUnionBitset(SimpleType.Tag.LIST, SimpleType.Tag.MAPPING, + SimpleType.Tag.TABLE)); if (!readonly) { BAnydataType immutableAnydataType = new BAnydataType(TypeConstants.READONLY_ANYDATA_TNAME, pkg, true); this.immutableType = new BIntersectionType(pkg, new Type[]{ this, PredefinedTypes.TYPE_READONLY}, diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java index 44140e8c0d49..56aa2861f1a0 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java @@ -75,10 +75,8 @@ public BArrayType(Type elemType, int size, boolean readonly, int typeFlags) { } public BArrayType(int typeFlags, int size, boolean readonly, boolean hasFillerValue) { - // FIXME: properly differentiate list top type super(null, null, ArrayValue.class, - new SimpleType(SimpleType.Builder.NONE, - SimpleType.Builder.basicTypeBitset(SimpleType.Tag.LIST))); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.LIST), SimpleType.Builder.NONE)); this.typeFlags = typeFlags; if (size != -1) { state = ArrayState.CLOSED; @@ -90,6 +88,7 @@ public BArrayType(int typeFlags, int size, boolean readonly, boolean hasFillerVa public void setElementType(Type elementType, int dimensions, boolean elementRO) { this.elementType = readonly && !elementRO ? ReadOnlyUtils.getReadOnlyType(elementType) : elementType; + this.simpleType = SimpleType.Builder.createContainerSimpleType(elementType, SimpleType.Tag.LIST); this.dimensions = dimensions; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java index c8fd003268ec..5103f6d49128 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BErrorType.java @@ -40,7 +40,6 @@ public class BErrorType extends BAnnotatableType implements ErrorType { private IntersectionType intersectionType = null; public BErrorType(String typeName, Module pkg, Type detailType) { - // FIXME: super(typeName, pkg, ErrorValue.class, new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR))); @@ -49,8 +48,7 @@ public BErrorType(String typeName, Module pkg, Type detailType) { public BErrorType(String typeName, Module pkg) { super(typeName, pkg, ErrorValue.class, - new SimpleType(SimpleType.Builder.NONE, - SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR))); + new SimpleType(SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR), SimpleType.Builder.NONE)); } public void setTypeIdSet(BTypeIdSet typeIdSet) { @@ -74,6 +72,8 @@ public int getTag() { public void setDetailType(Type detailType) { this.detailType = detailType; + this.simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset(SimpleType.Tag.ERROR)); } @Override diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java index e90c67a16aff..e3f29918065b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BObjectType.java @@ -64,9 +64,8 @@ public class BObjectType extends BStructureType implements ObjectType { private String cachedToString; private boolean resolving; // FIXME: - private final SimpleType simpleType = - new SimpleType(SimpleType.Builder.NONE, - SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT)); + private static final SimpleType simpleType = + new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.basicTypeBitset(SimpleType.Tag.OBJECT)); /** * Create a {@code BObjectType} which represents the user defined struct type. diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java index 3afd1de2230b..a13f1c92fd10 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BParameterizedType.java @@ -33,8 +33,7 @@ public class BParameterizedType extends BType implements ParameterizedType { private int paramIndex; public BParameterizedType(Type paramValueType, int paramIndex) { - super(null, null, null, - paramValueType.getSimpleType()); + super(null, null, null, paramValueType.getSimpleType()); this.paramValueType = paramValueType; this.paramIndex = paramIndex; } From 82b5614a4972d432e476bd2d4e0c3bd0e3293e55 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Wed, 24 Jan 2024 08:43:16 +0530 Subject: [PATCH 12/16] Add separate cases where we can cache type check --- .../runtime/internal/TypeChecker.java | 50 +++++++------------ 1 file changed, 18 insertions(+), 32 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 751e6db24b75..108da001cc1e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -144,7 +144,7 @@ public class TypeChecker { private static final byte MAX_TYPECAST_ERROR_COUNT = 20; private static final String REG_EXP_TYPENAME = "RegExp"; - private static final TypeCheckMemoTable typeCheckMemo = new TypeCheckMemoTable<>(); + private static final TypeCheckCache typeCheckCache = new TypeCheckCache<>(); public static Object checkCast(Object sourceVal, Type targetType) { @@ -699,18 +699,13 @@ private static boolean checkIsType(Object sourceVal, Type sourceType, Type targe case TRUE -> true; case FALSE -> false; case UNKNOWN -> { - TypeCheckMemoKey key = new TypeCheckMemoKey(sourceVal, sourceType, targetType); - Boolean cachedResult = typeCheckMemo.get(key); + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); + Boolean cachedResult = typeCheckCache.get(key); if (cachedResult != null) { yield cachedResult; } boolean result = checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); - typeCheckMemo.put(key, result); -// if (cachedResult == null) { -// typeCheckMemo.put(key, result); -// } else if (cachedResult != result) { -// throw new AssertionError("Unexpected"); -// } + typeCheckCache.put(key, result); yield result; } }; @@ -3689,50 +3684,41 @@ private TypeChecker() { } // FIXME: - private static final class TypeCheckMemoTable { + private static final class TypeCheckCache { private static final int CACHE_SIZE = 100; - private final Map> cache; + private final Map cache; - private TypeCheckMemoTable() { + private TypeCheckCache() { this.cache = new ConcurrentHashMap<>(CACHE_SIZE); } public V get(TypeCheckMemoKey key) { - TypeCheckMemoData data = cache.get(key); - if (data == null) { - return null; - } - if (data.shouldInvalidate(key)) { - cache.remove(key); - return null; - } - return data.data; + return cache.get(key); } public void put(TypeCheckMemoKey key, V value) { + if (!isCacheable(key)) { + return; + } if (cache.size() > CACHE_SIZE) { cache.clear(); } - TypeCheckMemoData valueData = new TypeCheckMemoData<>(value, key.sourceValue); - cache.put(key, valueData); + cache.put(key, value); } - } - - private record TypeCheckMemoData(V data, Object sourceValue) { - // TODO: add comment - public boolean shouldInvalidate(TypeCheckMemoKey key) { + // For record/object types we may have readonly/final fields, so the type check result may depend on the value + private boolean isCacheable(TypeCheckMemoKey key) { int sourceTypeTag = key.sourceType.getTag(); if (sourceTypeTag != TypeTags.RECORD_TYPE_TAG && sourceTypeTag != TypeTags.OBJECT_TYPE_TAG) { - return false; + return true; } - return key.sourceValue != sourceValue; + int destinationTypeTag = key.destinationType.getTag(); + return destinationTypeTag == TypeTags.ANY_TAG || destinationTypeTag == TypeTags.READONLY_TAG; } } - // NOTE: we are using sourceValue to invalidate cache for record types - private record TypeCheckMemoKey(Object sourceValue, Type sourceType, Type destinationType) { + private record TypeCheckMemoKey(Type sourceType, Type destinationType) { @Override public String toString() { return sourceType.toString() + ":" + destinationType.toString(); From 458b2a5de6eeddbee485e8758db98dc196de9dff Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Wed, 24 Jan 2024 12:40:56 +0530 Subject: [PATCH 13/16] Using caching only for checkCast For cast operation we don't need to care about readonly/final nature of fields. So we can cache more type check results --- .../runtime/internal/TypeChecker.java | 35 ++++++++----------- 1 file changed, 15 insertions(+), 20 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 108da001cc1e..6e0b10077080 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -144,13 +144,21 @@ public class TypeChecker { private static final byte MAX_TYPECAST_ERROR_COUNT = 20; private static final String REG_EXP_TYPENAME = "RegExp"; - private static final TypeCheckCache typeCheckCache = new TypeCheckCache<>(); + private static final TypeCheckCache castCheckCache = new TypeCheckCache<>(); public static Object checkCast(Object sourceVal, Type targetType) { List errors = new ArrayList<>(); Type sourceType = getImpliedType(getType(sourceVal)); - if (checkIsType(errors, sourceVal, sourceType, targetType)) { + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); + Boolean cachedResult = castCheckCache.get(key); + if (cachedResult == null) { + boolean typeCheckResult = checkIsType(errors, sourceVal, sourceType, targetType); + castCheckCache.put(key, typeCheckResult); + if (typeCheckResult) { + return sourceVal; + } + } else if (cachedResult) { return sourceVal; } @@ -698,16 +706,7 @@ private static boolean checkIsType(Object sourceVal, Type sourceType, Type targe return switch (checkIsTypeSimple(sourceType.getSimpleType(), targetType.getSimpleType())) { case TRUE -> true; case FALSE -> false; - case UNKNOWN -> { - TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); - Boolean cachedResult = typeCheckCache.get(key); - if (cachedResult != null) { - yield cachedResult; - } - boolean result = checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); - typeCheckCache.put(key, result); - yield result; - } + case UNKNOWN -> checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); }; } @@ -3683,7 +3682,6 @@ private static BError createTypeCastError(Object value, Type targetType, List { private static final int CACHE_SIZE = 100; @@ -3702,19 +3700,16 @@ public void put(TypeCheckMemoKey key, V value) { return; } if (cache.size() > CACHE_SIZE) { + // A more sophisticated cache replacement policy like LRU should be better if we can do it efficiently + // while remaining threadsafe. cache.clear(); } cache.put(key, value); } - // For record/object types we may have readonly/final fields, so the type check result may depend on the value private boolean isCacheable(TypeCheckMemoKey key) { - int sourceTypeTag = key.sourceType.getTag(); - if (sourceTypeTag != TypeTags.RECORD_TYPE_TAG && sourceTypeTag != TypeTags.OBJECT_TYPE_TAG) { - return true; - } - int destinationTypeTag = key.destinationType.getTag(); - return destinationTypeTag == TypeTags.ANY_TAG || destinationTypeTag == TypeTags.READONLY_TAG; + // If either types are readonly then actual type check result may depend on runtime values. + return !key.sourceType.isReadOnly() && !key.destinationType.isReadOnly(); } } From 35d8ce5a99e85f5abc246cbaa671cf6dd7f19738 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Wed, 24 Jan 2024 13:02:02 +0530 Subject: [PATCH 14/16] Fix finite type --- .../io/ballerina/runtime/api/SimpleType.java | 11 ++++----- .../runtime/internal/TypeChecker.java | 7 +++--- .../runtime/internal/types/BArrayType.java | 2 +- .../runtime/internal/types/BFiniteType.java | 24 +++++++++++++++---- .../runtime/internal/types/BMapType.java | 2 +- .../runtime/internal/types/BTableType.java | 2 +- .../runtime/internal/types/BXmlType.java | 2 +- 7 files changed, 32 insertions(+), 18 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java index a72a5af3961a..8d8df4875a3a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -97,7 +97,7 @@ public enum Tag { public static class Builder { - // TODO: Move these to SimpleType? + // Helper values to construct types public static final long NONE = 0; public static final long ALL = (1L << (Tag.values().length + 1)) - 1; @@ -114,13 +114,13 @@ public static long basicTypeBitset(Tag basicType) { } // TODO: container is not a good name? - public static SimpleType createContainerSimpleType(Type constraint, Tag tag) { + public static SimpleType createConstrainedType(Type constraint, Tag baseType) { SimpleType constraintSimpleType = constraint.getSimpleType(); if (constraintSimpleType.all == ALL) { - // no constraint mean it is the top type - return new SimpleType(Builder.basicTypeBitset(tag), Builder.NONE); + // no constraint mean it is the base type + return new SimpleType(Builder.basicTypeBitset(baseType), Builder.NONE); } - return new SimpleType(Builder.NONE, Builder.basicTypeBitset(tag)); + return new SimpleType(Builder.NONE, Builder.basicTypeBitset(baseType)); } public static long except(Tag... basicTypes) { @@ -133,7 +133,6 @@ public static long except(Tag... basicTypes) { public static SimpleType intersection(List types) { if (types.isEmpty()) { - // I assume this (and union) is because we are modifying types after the fact return new SimpleType(NONE, NONE); } return types.stream().skip(1).map(Type::getSimpleType) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index 6e0b10077080..ad5815cdb13d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -701,9 +701,9 @@ private static boolean checkIsType(Object sourceVal, Type targetType, List unresolvedTypes) { - sourceType = getImpliedType(sourceType); - targetType = getImpliedType(targetType); - return switch (checkIsTypeSimple(sourceType.getSimpleType(), targetType.getSimpleType())) { + SimpleType sourceSimpleType = + sourceVal instanceof BValue ? ((BValue) sourceVal).getSimpleType() : sourceType.getSimpleType(); + return switch (checkIsTypeSimple(sourceSimpleType, targetType.getSimpleType())) { case TRUE -> true; case FALSE -> false; case UNKNOWN -> checkIsTypeInner(sourceVal, sourceType, targetType, unresolvedTypes); @@ -712,7 +712,6 @@ private static boolean checkIsType(Object sourceVal, Type sourceType, Type targe private static boolean checkIsTypeInner(Object sourceVal, Type sourceType, Type targetType, List unresolvedTypes) { - // FIXME: avoid getting the implied type twice sourceType = getImpliedType(sourceType); targetType = getImpliedType(targetType); int sourceTypeTag = sourceType.getTag(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java index 56aa2861f1a0..4b796589a45d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BArrayType.java @@ -88,7 +88,7 @@ public BArrayType(int typeFlags, int size, boolean readonly, boolean hasFillerVa public void setElementType(Type elementType, int dimensions, boolean elementRO) { this.elementType = readonly && !elementRO ? ReadOnlyUtils.getReadOnlyType(elementType) : elementType; - this.simpleType = SimpleType.Builder.createContainerSimpleType(elementType, SimpleType.Tag.LIST); + this.simpleType = SimpleType.Builder.createConstrainedType(elementType, SimpleType.Tag.LIST); this.dimensions = dimensions; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java index 4353f97d6d87..bdf088826db1 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java @@ -22,9 +22,11 @@ import io.ballerina.runtime.api.TypeTags; import io.ballerina.runtime.api.flags.TypeFlags; import io.ballerina.runtime.api.types.FiniteType; +import io.ballerina.runtime.api.values.BValue; import io.ballerina.runtime.internal.TypeChecker; import io.ballerina.runtime.internal.values.RefValue; +import java.util.Collections; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; @@ -52,14 +54,28 @@ public BFiniteType(String typeName, Set values, int typeFlags) { } public BFiniteType(String typeName, String originalName, Set values, int typeFlags) { - // FIXME: - super(typeName, null, RefValue.class, new SimpleType( - SimpleType.Builder.NONE, SimpleType.Builder.ALL)); - this.valueSpace = values; + super(typeName, null, RefValue.class, simpleType(values)); + this.valueSpace = Collections.unmodifiableSet(values); this.typeFlags = typeFlags; this.originalName = originalName; } + private static SimpleType simpleType(Set values) { + SimpleType ty = new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.NONE); + for (Object value : values) { + if (!(value instanceof BValue)) { + return new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.ALL); + } + SimpleType valueTy = ((BValue) value).getSimpleType(); + // FIXME: why fallowing don't work? (TypeCastExpressionTest) +// SimpleType valueTy = TypeChecker.getType(value).getSimpleType(); +// SimpleType valueTy = value instanceof BValue ? ((BValue) value).getSimpleType() : +// TypeChecker.getType(value).getSimpleType(); + ty = ty.union(valueTy); + } + return ty; + } + @Override public V getZeroValue() { if (valueSpace.stream().anyMatch(val -> val == null || TypeChecker.getType(val).isNilable())) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java index a4369a544529..6615efec8717 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BMapType.java @@ -70,7 +70,7 @@ public BMapType(String typeName, Type constraint, Module pkg) { public BMapType(String typeName, Type constraint, Module pkg, boolean readonly) { super(typeName, pkg, MapValueImpl.class, - SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.MAPPING)); + SimpleType.Builder.createConstrainedType(constraint, SimpleType.Tag.MAPPING)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java index 0c1160e572ef..f44df60f028d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTableType.java @@ -59,7 +59,7 @@ public BTableType(Type constraint, boolean readonly) { super(TypeConstants.TABLE_TNAME, null, TableValue.class, - SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.TABLE)); + SimpleType.Builder.createConstrainedType(constraint, SimpleType.Tag.TABLE)); this.constraint = readonly ? ReadOnlyUtils.getReadOnlyType(constraint) : constraint; this.readonly = readonly; } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java index ae53e9da5914..5d8d66197033 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BXmlType.java @@ -52,7 +52,7 @@ public class BXmlType extends BType implements XmlType { */ public BXmlType(String typeName, Type constraint, Module pkg) { super(typeName, pkg, XmlValue.class, - SimpleType.Builder.createContainerSimpleType(constraint, SimpleType.Tag.XML)); + SimpleType.Builder.createConstrainedType(constraint, SimpleType.Tag.XML)); this.constraint = constraint; this.tag = TypeTags.XML_TAG; this.readonly = false; From d27f68a901059e59276a9ba39f4b0ac9f2914cea Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Wed, 24 Jan 2024 15:16:28 +0530 Subject: [PATCH 15/16] Move type check into inner check --- .../runtime/internal/TypeChecker.java | 43 ++++++++----------- 1 file changed, 19 insertions(+), 24 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java index ad5815cdb13d..8223eb219dad 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/TypeChecker.java @@ -144,24 +144,15 @@ public class TypeChecker { private static final byte MAX_TYPECAST_ERROR_COUNT = 20; private static final String REG_EXP_TYPENAME = "RegExp"; - private static final TypeCheckCache castCheckCache = new TypeCheckCache<>(); + private static final TypeCheckCache typeCheckCache = new TypeCheckCache<>(); public static Object checkCast(Object sourceVal, Type targetType) { List errors = new ArrayList<>(); Type sourceType = getImpliedType(getType(sourceVal)); - TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); - Boolean cachedResult = castCheckCache.get(key); - if (cachedResult == null) { - boolean typeCheckResult = checkIsType(errors, sourceVal, sourceType, targetType); - castCheckCache.put(key, typeCheckResult); - if (typeCheckResult) { - return sourceVal; - } - } else if (cachedResult) { + if (checkIsType(errors, sourceVal, sourceType, targetType)) { return sourceVal; } - if (sourceType.getTag() <= TypeTags.BOOLEAN_TAG && targetType.getTag() <= TypeTags.BOOLEAN_TAG) { return TypeConverter.castValues(targetType, sourceVal); } @@ -714,6 +705,12 @@ private static boolean checkIsTypeInner(Object sourceVal, Type sourceType, Type List unresolvedTypes) { sourceType = getImpliedType(sourceType); targetType = getImpliedType(targetType); + + TypeCheckMemoKey key = new TypeCheckMemoKey(sourceType, targetType); + Boolean cachedResult = typeCheckCache.get(key); + if (cachedResult != null) { + return cachedResult; + } int sourceTypeTag = sourceType.getTag(); int targetTypeTag = targetType.getTag(); @@ -732,28 +729,33 @@ private static boolean checkIsTypeInner(Object sourceVal, Type sourceType, Type // // where `Bar b = {i: 100};`, `b is Foo` should evaluate to true. if (sourceTypeTag != TypeTags.RECORD_TYPE_TAG && sourceTypeTag != TypeTags.OBJECT_TYPE_TAG) { - return checkIsType(sourceType, targetType); + return cacheAndReturnResult(key, checkIsType(sourceType, targetType)); } if (sourceType == targetType || (sourceType.getTag() == targetType.getTag() && sourceType.equals(targetType))) { - return true; + return cacheAndReturnResult(key, true); } if (targetType.isReadOnly() && !sourceType.isReadOnly()) { - return false; + return cacheAndReturnResult(key, false); } switch (targetTypeTag) { case TypeTags.ANY_TAG: - return checkIsAnyType(sourceType); + return cacheAndReturnResult(key, checkIsAnyType(sourceType)); case TypeTags.READONLY_TAG: - return isInherentlyImmutableType(sourceType) || sourceType.isReadOnly(); + return cacheAndReturnResult(key, isInherentlyImmutableType(sourceType) || sourceType.isReadOnly()); default: return checkIsRecursiveTypeOnValue(sourceVal, sourceType, targetType, sourceTypeTag, targetTypeTag, unresolvedTypes == null ? new ArrayList<>() : unresolvedTypes); } } + private static boolean cacheAndReturnResult(TypeCheckMemoKey key, boolean result) { + typeCheckCache.put(key, result); + return result; + } + // Private methods private static boolean checkTypeDescType(Type sourceType, BTypedescType targetType, @@ -3695,21 +3697,14 @@ public V get(TypeCheckMemoKey key) { } public void put(TypeCheckMemoKey key, V value) { - if (!isCacheable(key)) { - return; - } if (cache.size() > CACHE_SIZE) { // A more sophisticated cache replacement policy like LRU should be better if we can do it efficiently // while remaining threadsafe. + // TODO: randomly remove someone and see perf cache.clear(); } cache.put(key, value); } - - private boolean isCacheable(TypeCheckMemoKey key) { - // If either types are readonly then actual type check result may depend on runtime values. - return !key.sourceType.isReadOnly() && !key.destinationType.isReadOnly(); - } } private record TypeCheckMemoKey(Type sourceType, Type destinationType) { From e54cd48c586d159ea7586bb05dfb62e2699679a9 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Mon, 29 Jan 2024 08:09:16 +0530 Subject: [PATCH 16/16] Fix FiniteType simple type creation --- .../main/java/io/ballerina/runtime/api/SimpleType.java | 4 ++++ .../java/io/ballerina/runtime/api/values/BValue.java | 5 ++++- .../ballerina/runtime/internal/types/BFiniteType.java | 10 ++-------- 3 files changed, 10 insertions(+), 9 deletions(-) diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java index 8d8df4875a3a..ba75c00c72e3 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/SimpleType.java @@ -131,6 +131,10 @@ public static long except(Tag... basicTypes) { return bits; } + public static SimpleType asSome(SimpleType type) { + return new SimpleType(NONE, type.all | type.some); + } + public static SimpleType intersection(List types) { if (types.isEmpty()) { return new SimpleType(NONE, NONE); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java index 64a99b56079f..45adcab04da7 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BValue.java @@ -31,7 +31,10 @@ */ public interface BValue { - SimpleType getSimpleType(); + // TODO: remove this default implementation once all standard library classes are fixed + default SimpleType getSimpleType() { + return getType().getSimpleType(); + } /** * Method to perform a deep copy, recursively copying all structural values and their members. * diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java index bdf088826db1..7bf6006ec064 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BFiniteType.java @@ -63,14 +63,8 @@ public BFiniteType(String typeName, String originalName, Set values, int private static SimpleType simpleType(Set values) { SimpleType ty = new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.NONE); for (Object value : values) { - if (!(value instanceof BValue)) { - return new SimpleType(SimpleType.Builder.NONE, SimpleType.Builder.ALL); - } - SimpleType valueTy = ((BValue) value).getSimpleType(); - // FIXME: why fallowing don't work? (TypeCastExpressionTest) -// SimpleType valueTy = TypeChecker.getType(value).getSimpleType(); -// SimpleType valueTy = value instanceof BValue ? ((BValue) value).getSimpleType() : -// TypeChecker.getType(value).getSimpleType(); + SimpleType valueTy = value instanceof BValue ? ((BValue) value).getSimpleType() : + SimpleType.Builder.asSome(TypeChecker.getType(value).getSimpleType()); ty = ty.union(valueTy); } return ty;