From c69471e2985dbd47096631f71e4ee3cb004889d1 Mon Sep 17 00:00:00 2001 From: Heshan Padmasiri Date: Fri, 11 Oct 2024 13:23:12 +0530 Subject: [PATCH] WIP: Add jDoc comments to public API --- .../runtime/api/types/FunctionType.java | 1 - .../runtime/api/types/semtype/Atom.java | 8 ++++- .../runtime/api/types/semtype/AtomicType.java | 2 +- .../api/types/semtype/BasicTypeCode.java | 2 +- .../runtime/api/types/semtype/Bdd.java | 8 +++-- .../api/types/semtype/BddAllOrNothing.java | 2 +- .../types/semtype/BddIsEmptyPredicate.java | 12 +++++++ .../runtime/api/types/semtype/BddNode.java | 5 +++ .../api/types/semtype/BddNodeImpl.java | 4 +-- .../api/types/semtype/BddNodeSimple.java | 6 ++++ .../api/types/semtype/BddPredicate.java | 2 +- .../runtime/api/types/semtype/Builder.java | 2 +- .../semtype/CacheableTypeDescriptor.java | 22 +++++++++++++ .../types/semtype/ConcurrentLazySupplier.java | 6 ++++ .../ConcurrentLazySupplierWithCallback.java | 6 ++++ .../api/types/semtype/Conjunction.java | 5 +-- .../runtime/api/types/semtype/Context.java | 22 +++++++++---- .../runtime/api/types/semtype/Core.java | 2 +- .../runtime/api/types/semtype/Definition.java | 11 ++++++- .../runtime/api/types/semtype/Env.java | 12 ++++--- .../runtime/api/types/semtype/FieldPair.java | 11 +++++++ .../runtime/api/types/semtype/FieldPairs.java | 5 +++ .../runtime/api/types/semtype/ListProj.java | 2 +- .../api/types/semtype/MappingProj.java | 2 +- .../runtime/api/types/semtype/Pair.java | 2 +- .../runtime/api/types/semtype/RecAtom.java | 2 +- .../runtime/api/types/semtype/SemType.java | 11 +++---- .../api/types/semtype/ShapeAnalyzer.java | 5 +++ .../runtime/api/types/semtype/SubType.java | 2 +- .../runtime/api/types/semtype/TypeAtom.java | 9 ++++++ .../api/types/semtype/TypeCheckCache.java | 13 ++++++++ .../runtime/api/values/BArray.java.rej | 10 ------ .../ballerina/runtime/api/values/BValue.java | 3 ++ .../runtime/internal/types/BAnydataType.java | 5 ++- .../internal/types/BSemTypeWrapper.java | 9 +++--- .../runtime/internal/types/BStringType.java | 32 +++++++++---------- .../internal/types/DistinctIdSupplier.java | 5 +++ .../runtime/internal/types/ShapeSupplier.java | 5 +++ .../internal/types/TypeWithAcceptedType.java | 2 ++ .../runtime/internal/types/TypeWithShape.java | 2 ++ .../internal/types/semtype/AllOrNothing.java | 7 ++-- .../types/semtype/BBooleanSubType.java | 4 +-- .../internal/types/semtype/BCellSubType.java | 5 +++ .../types/semtype/BCellSubTypeImpl.java | 6 +--- .../types/semtype/BCellSubTypeSimple.java | 5 +++ .../types/semtype/BDecimalSubType.java | 2 +- .../internal/types/semtype/BErrorSubType.java | 5 +++ .../internal/types/semtype/BFloatSubType.java | 2 +- .../types/semtype/BFunctionSubType.java | 5 +++ .../types/semtype/BFutureSubType.java | 5 +++ .../internal/types/semtype/BIntSubType.java | 4 +-- .../internal/types/semtype/BListProj.java | 2 +- .../internal/types/semtype/BListSubType.java | 6 +++- .../internal/types/semtype/BMappingProj.java | 5 +++ .../types/semtype/BMappingSubType.java | 5 +++ .../types/semtype/BObjectSubType.java | 5 +++ .../types/semtype/BStreamSubType.java | 5 +++ .../types/semtype/BStringSubType.java | 4 +-- .../internal/types/semtype/BTableSubType.java | 5 +++ .../types/semtype/BTypedescSubType.java | 5 +++ .../internal/types/semtype/BXmlSubType.java | 5 +++ .../internal/types/semtype/BddMemo.java | 12 +++++++ .../types/semtype/CellAtomicType.java | 2 +- .../internal/types/semtype/Common.java | 5 +++ .../types/semtype/DelegatedSubType.java | 5 +++ .../types/semtype/EnumerableSubtypeData.java | 7 ++-- .../internal/types/semtype/ErrorUtils.java | 5 +++ .../types/semtype/FixedLengthArray.java | 7 ++++ .../types/semtype/FunctionAtomicType.java | 8 +++++ .../types/semtype/FunctionDefinition.java | 5 +++ .../types/semtype/FunctionQualifiers.java | 5 +++ .../internal/types/semtype/FutureUtils.java | 6 +++- .../types/semtype/ListAtomicType.java | 7 ++++ .../types/semtype/ListDefinition.java | 5 +++ .../types/semtype/MappingAtomicType.java | 12 +++++++ .../types/semtype/MappingDefinition.java | 5 +++ .../internal/types/semtype/Member.java | 11 +++++++ .../types/semtype/MutableSemType.java | 6 ++++ .../types/semtype/ObjectDefinition.java | 14 +++++++- .../types/semtype/ObjectQualifiers.java | 9 ++++++ .../internal/types/semtype/RegexUtils.java | 5 +++ .../internal/types/semtype/SemTypeHelper.java | 2 +- .../types/semtype/StreamDefinition.java | 6 ++++ .../internal/types/semtype/SubTypeData.java | 3 +- .../internal/types/semtype/SubtypePair.java | 10 ++++++ .../types/semtype/SubtypePairIterator.java | 2 +- .../internal/types/semtype/SubtypePairs.java | 2 +- .../internal/types/semtype/TableUtils.java | 5 +++ .../internal/types/semtype/TypedescUtils.java | 5 +++ .../internal/types/semtype/XmlUtils.java | 6 +++- .../runtime/internal/values/DecimalValue.java | 5 --- .../runtime/internal/values/FPValue.java | 6 ---- .../internal/values/RecursiveValue.java | 2 ++ 93 files changed, 459 insertions(+), 110 deletions(-) delete mode 100644 bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java.rej diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/FunctionType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/FunctionType.java index dcd676f3675e..94410bea3242 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/FunctionType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/FunctionType.java @@ -40,5 +40,4 @@ public interface FunctionType extends AnnotatableType { Type getRestType(); Parameter[] getParameters(); - } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Atom.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Atom.java index 4afe068ae55b..0ddea623de6c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Atom.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Atom.java @@ -21,9 +21,15 @@ /** * Represent the BDD atom. * - * @since 2201.10.0 + * @since 2201.11.0 */ public sealed interface Atom permits RecAtom, TypeAtom { + /** + * Get the index of the atom. For {@code TypeAtoms} this is a unique index within the {@code Env}. Each + * {@code RecAtom} that points to the same {@code TypeAtom} will have the same index. + * + * @return index of the atom + */ int index(); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/AtomicType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/AtomicType.java index 7407bc97f39a..7e5163fa8a78 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/AtomicType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/AtomicType.java @@ -26,7 +26,7 @@ /** * Marker type representing AtomicType. * - * @since 2201.10.0 + * @since 2201.11.0 */ public sealed interface AtomicType permits CellAtomicType, FunctionAtomicType, ListAtomicType, MappingAtomicType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BasicTypeCode.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BasicTypeCode.java index ba01d29eb71c..c9158bce4bf5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BasicTypeCode.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BasicTypeCode.java @@ -21,7 +21,7 @@ /** * Represent bit field that indicate which basic type a semType belongs to. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BasicTypeCode { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Bdd.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Bdd.java index 7d9ef4060457..2573230f05a8 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Bdd.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Bdd.java @@ -23,10 +23,12 @@ import static io.ballerina.runtime.api.types.semtype.Conjunction.and; /** - * Represent BDD node. Subtypes that uses BDDs to represent subtypes such as list, mapping and cell should implement - * their own {@code SubType} implementation that wraps an implementation of this class. + * Represent BDD node. Subtypes that uses BDDs to represent subtypes such as + * list, mapping and cell should implement + * their own {@code SubType} implementation that wraps an implementation of this + * class. * - * @since 2201.10.0 + * @since 2201.11.0 */ public abstract sealed class Bdd extends SubType implements SubTypeData permits BddAllOrNothing, BddNode { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddAllOrNothing.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddAllOrNothing.java index f12f3c12f48b..e5b6c67ebad5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddAllOrNothing.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddAllOrNothing.java @@ -21,7 +21,7 @@ /** * Represent the leaf node of a Bdd. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BddAllOrNothing extends Bdd { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddIsEmptyPredicate.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddIsEmptyPredicate.java index 4b1f7bb6afa9..d08297a81b06 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddIsEmptyPredicate.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddIsEmptyPredicate.java @@ -18,8 +18,20 @@ package io.ballerina.runtime.api.types.semtype; +/** + * Predicate to check if a BDD is empty. + * + * @since 2201.11.0 + */ @FunctionalInterface public interface BddIsEmptyPredicate { + /** + * Check if the given BDD is empty. + * + * @param cx Type check context + * @param bdd BDD to check + * @return true if the BDD is empty, false otherwise + */ boolean apply(Context cx, Bdd bdd); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNode.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNode.java index 949d36ed5b2e..001f154701ee 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNode.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNode.java @@ -1,5 +1,10 @@ package io.ballerina.runtime.api.types.semtype; +/** + * Internal node of a BDD, which represents a disjunction of conjunctions of atoms. + * + * @since 2201.11.0 + */ public abstract sealed class BddNode extends Bdd permits BddNodeImpl, BddNodeSimple { private volatile Integer hashCode = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeImpl.java index 1f6239bbef60..71b1a9528220 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeImpl.java @@ -19,9 +19,9 @@ package io.ballerina.runtime.api.types.semtype; /** - * Internal node of a BDD, which represents a disjunction of conjunctions of atoms. + * Generalized implementation of {@code BddNode}. * - * @since 2201.10.0 + * @since 2201.11.0 */ final class BddNodeImpl extends BddNode { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeSimple.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeSimple.java index 10b31a5d754b..bd64cdcf9af5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeSimple.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddNodeSimple.java @@ -1,5 +1,11 @@ package io.ballerina.runtime.api.types.semtype; +/** + * Represent a Bdd node that contains a single atom as positive. This is used to reduce the memory overhead of + * BddNodeImpl in representing such nodes + * + * @since 2201.11.0 + */ final class BddNodeSimple extends BddNode { private final Atom atom; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddPredicate.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddPredicate.java index ec2cbea729f0..4a6e47f3c870 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddPredicate.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/BddPredicate.java @@ -22,7 +22,7 @@ /** * Represents a predicate that can be applied to a BDD conjunction. * - * @since 2201.10.0 + * @since 2201.11.0 */ @FunctionalInterface public interface BddPredicate { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Builder.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Builder.java index 5c0bbc1cc57a..4c4f1149387b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Builder.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Builder.java @@ -61,7 +61,7 @@ /** * Utility class for creating semtypes. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class Builder { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/CacheableTypeDescriptor.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/CacheableTypeDescriptor.java index fbcb7ca9709b..bad069886c65 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/CacheableTypeDescriptor.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/CacheableTypeDescriptor.java @@ -11,9 +11,31 @@ */ public interface CacheableTypeDescriptor extends Type { + /** + * Check whether the type check result of this type descriptor should be cached. Can be used to avoid caching in + * cases where either directly doing the type check is cheaper or we can't determine if two instances of a type + * descriptor are equal without doing a type check. + * + * @return true if the type check result should be cached, false otherwise + */ boolean shouldCache(); + /** + * Check whether the type check result of this type descriptor is cached for the given type descriptor. + * + * @param cx Context in which the type check is performed + * @param other Type descriptor to check the cached result for + * @return Optional containing the cached result if it is cached, empty otherwise + */ Optional cachedTypeCheckResult(Context cx, CacheableTypeDescriptor other); + /** + * Cache the type check result of this type descriptor for the given type descriptor. Note that implementations of + * this method could choose to not cache the result if {@link #shouldCache()} returns false. In such cases, even + * after calling this method, {@link #cachedTypeCheckResult(Context, CacheableTypeDescriptor)} could return empty. + * + * @param other Type descriptor to cache the result for + * @param result Result of the type check + */ void cacheTypeCheckResult(CacheableTypeDescriptor other, boolean result); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplier.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplier.java index eaf7036cee5d..2ea49c4906f1 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplier.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplier.java @@ -2,6 +2,12 @@ import java.util.function.Supplier; +/** + * A thread-safe single lazy supplier that initialize the value only once. + * + * @param type of the value + * @since 2201.11.0 + */ public class ConcurrentLazySupplier implements Supplier { private Supplier initializer; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplierWithCallback.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplierWithCallback.java index 798717b164a3..94646141bb5b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplierWithCallback.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ConcurrentLazySupplierWithCallback.java @@ -21,6 +21,12 @@ import java.util.function.Consumer; import java.util.function.Supplier; +/** + * A thread-safe lazy supplier that initializes the value on the first call to {@link #get()} and calls the callback. + * + * @param the type of the value + * @since 2201.11.0 + */ public class ConcurrentLazySupplierWithCallback implements Supplier { private volatile E value = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Conjunction.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Conjunction.java index 34fbf71ded29..2faf2c559857 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Conjunction.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Conjunction.java @@ -23,8 +23,9 @@ * Represents the Conjunction in the BDD. * * @param atom Atom of this node - * @param next Next node in the conjunction, will be {@code null} if this is the last node - * @since 2201.10.0 + * @param next Next node in the conjunction, will be {@code null} if this is the + * last node + * @since 2201.11.0 */ public record Conjunction(Atom atom, Conjunction next) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java index c9d688d97adf..4d6634f89f76 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Context.java @@ -31,10 +31,12 @@ import java.util.WeakHashMap; /** - * Context in which type checking operations are performed. Note context is not thread safe, and multiple type check - * operations should not use the same context concurrently. Multiple contexts may share same environment without issue. + * Context in which type checking operations are performed. Note context is not + * thread safe, and multiple type check operations should not use the same + * context concurrently. Multiple contexts may share same environment without + * issue. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class Context { @@ -53,6 +55,8 @@ private Context(Env env) { } private static Map> createTypeCheckCacheMemo() { + // This is fine since this map is not going to get leaked out of the context and + // context is unique to a thread. So there will be no concurrent modifications return new LinkedHashMap<>(MAX_CACHE_SIZE, 1f, true) { @Override protected boolean removeEldestEntry( @@ -87,11 +91,14 @@ public boolean memoSubtypeIsEmpty(Map memoTable, BddIsEmptyPredica } private boolean memoSubTypeIsEmptyInner(BddIsEmptyPredicate isEmptyPredicate, Bdd bdd, BddMemo m) { + // We are staring the type check with the assumption our type is empty (see: inductive type) m.isEmpty = BddMemo.Status.PROVISIONAL; int initStackDepth = memoStack.size(); memoStack.add(m); boolean isEmpty = isEmptyPredicate.apply(this, bdd); boolean isLoop = m.isEmpty == BddMemo.Status.LOOP; + // if not empty our assumption is wrong so we need to reset the memoized values, otherwise we cleanup the stack + // at the end if (!isEmpty || initStackDepth == 0) { resetMemoizedValues(initStackDepth, isEmpty, isLoop, m); } @@ -103,16 +110,19 @@ private void resetMemoizedValues(int initStackDepth, boolean isEmpty, boolean is BddMemo.Status memoStatus = memoStack.get(i).isEmpty; if (Objects.requireNonNull(memoStatus) == BddMemo.Status.PROVISIONAL || memoStatus == BddMemo.Status.LOOP || memoStatus == BddMemo.Status.CYCLIC) { + // We started with the assumption our type is empty. Now we know for sure if we are empty or not + // if we are empty all of these who don't have anything except us should be empty as well. + // Otherwise, we don't know if they are empty or not memoStack.get(i).isEmpty = isEmpty ? BddMemo.Status.TRUE : BddMemo.Status.NULL; } } if (memoStack.size() > initStackDepth) { memoStack.subList(initStackDepth, memoStack.size()).clear(); } - // The only way that we have found that this can be empty is by going through a loop. - // This means that the shapes in the type would all be infinite. - // But we define types inductively, which means we only consider finite shapes. if (isLoop && isEmpty) { + // The only way that we have found that this can be empty is by going through a loop. + // This means that the shapes in the type would all be infinite. + // But we define types inductively, which means we only consider finite shapes. m.isEmpty = BddMemo.Status.CYCLIC; } else { m.isEmpty = isEmpty ? BddMemo.Status.TRUE : BddMemo.Status.FALSE; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Core.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Core.java index 7b329d817605..3eefea1b58e4 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Core.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Core.java @@ -61,7 +61,7 @@ /** * Contain functions defined in `core.bal` file. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class Core { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Definition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Definition.java index cd47a8302b3c..d759a4cdf87d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Definition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Definition.java @@ -18,8 +18,17 @@ package io.ballerina.runtime.api.types.semtype; -// NOTE: definitions are not thread safe +/** + * Represent a type definition which will act as a layer of indirection between {@code Env} and the type descriptor. + * + * @since 2201.11.0 + */ public interface Definition { + /** + * Get the {@code SemType} of this definition in the given environment. + * + * @param env type environment + */ SemType getSemType(Env env); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java index b787619f823d..10b00639a035 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Env.java @@ -37,9 +37,12 @@ import java.util.function.Supplier; /** - * Represent the environment in which {@code SemTypes} are defined in. Type checking types defined in different - * environments with each other in undefined. This is safe to be shared between multiple threads. - * @since 2201.10.0 + * Represent the environment in which {@code SemTypes} are defined in. Type + * checking types defined in different + * environments with each other in undefined. This is safe to be shared between + * multiple threads. + * + * @since 2201.11.0 */ public final class Env { // Currently there is no reason to worry about above restrictions since Env is a singleton, but strictly speaking @@ -48,7 +51,8 @@ public final class Env { private static final Env INSTANCE = new Env(); // Each atom is created once but will be accessed multiple times during type checking. Also in perfect world we - // will create atoms at the beginning of the execution and will eventually reach a steady state. + // will create atoms at the beginning of the execution and will eventually reach + // a steady state. private final ReadWriteLock atomLock = new ReentrantReadWriteLock(); private final Map> atomTable; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPair.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPair.java index 732e1f7f174f..29ce90a72be5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPair.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPair.java @@ -18,6 +18,17 @@ package io.ballerina.runtime.api.types.semtype; +/** + * Represent the matching fields types of two mapping atomic types. + * + * @param name name of the field + * @param type1 type of the field in the first mapping + * @param type2 type of the field in teh second mapping + * @param index1 corresponding index of the field in the first mapping. If matching field is rest value is {@code null} + * @param index2 corresponding index of the field in the second mapping. If matching field is rest value is + * {@code null} + * @since 2201.11.0 + */ public record FieldPair(String name, SemType type1, SemType type2, Integer index1, Integer index2) { } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPairs.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPairs.java index 78bc55284694..82618c4c93f6 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPairs.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/FieldPairs.java @@ -26,6 +26,11 @@ import java.util.Objects; import java.util.Optional; +/** + * {@code Iterable} over the matching fields of two mapping atomic types. + * + * @since 2201.11.0 + */ public class FieldPairs implements Iterable { MappingAtomicType m1; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ListProj.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ListProj.java index 10e75f2c1ad8..e1d579e9b266 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ListProj.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ListProj.java @@ -23,7 +23,7 @@ /** * Utility class for list type projection. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class ListProj { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/MappingProj.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/MappingProj.java index cd67382714c7..cd3c113054d3 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/MappingProj.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/MappingProj.java @@ -24,7 +24,7 @@ /** * Utility class for mapping type projection. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class MappingProj { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Pair.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Pair.java index e93e668d7e84..f8d4922c7f56 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Pair.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/Pair.java @@ -25,7 +25,7 @@ * @param type of second value * @param first first values * @param second second value - * @since 2201.10.0 + * @since 2201.11.0 */ public record Pair(E1 first, E2 second) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/RecAtom.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/RecAtom.java index 5e224575818f..f302a7dc3c45 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/RecAtom.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/RecAtom.java @@ -22,7 +22,7 @@ /** * Represent a recursive type atom. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class RecAtom implements Atom { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SemType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SemType.java index 8eea044f57be..d185c96b6c7f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SemType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SemType.java @@ -5,6 +5,11 @@ import io.ballerina.runtime.internal.types.semtype.MutableSemType; import io.ballerina.runtime.internal.types.semtype.SemTypeHelper; +/** + * Represent a type in runtime. + * + * @since 2201.11.0 + */ public sealed class SemType extends BasicTypeBitSet permits io.ballerina.runtime.internal.types.BType, ImmutableSemType { @@ -59,12 +64,6 @@ public static SemType tryInto(Type type) { return (SemType) type; } - public enum CachedResult { - TRUE, - FALSE, - NOT_FOUND - } - @Override public String toString() { return SemTypeHelper.stringRepr(this); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ShapeAnalyzer.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ShapeAnalyzer.java index caf5544c8a2e..99bc4c9a51f5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ShapeAnalyzer.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/ShapeAnalyzer.java @@ -9,6 +9,11 @@ import java.util.Optional; +/** + * Utility class for performing shape related operations. + * + * @since 2201.11.0 + */ public class ShapeAnalyzer { private ShapeAnalyzer() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SubType.java index 2850e95e5898..85fabfa2303b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/SubType.java @@ -25,7 +25,7 @@ /** * Describe set of operation supported by each basic Type. * - * @since 2201.10.0 + * @since 2201.11.0 */ public abstract class SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeAtom.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeAtom.java index cbc915ccf3f0..02080171937e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeAtom.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeAtom.java @@ -18,6 +18,15 @@ package io.ballerina.runtime.api.types.semtype; +/** + * Represent a TypeAtom. Each operand of a type operation could be thought of as + * an atom + * + * @param index unique index within the {@code Env} + * @param atomicType atomic type representing the actual type represented by + * this atom. + * @since 2201.11.0 + */ public record TypeAtom(int index, AtomicType atomicType) implements Atom { public TypeAtom { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckCache.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckCache.java index 05d54da822f6..cf9bc820da2a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckCache.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/semtype/TypeCheckCache.java @@ -6,8 +6,21 @@ import java.util.Optional; import java.util.WeakHashMap; +/** + * Generalized implementation of type check result cache. It is okay to access + * this from multiple threads but makes no + * guarantee about the consistency of the cache under parallel access. Given + * result don't change due to race conditions + * this should eventually become consistent. + * + * @param Type of the type descriptor which owns this cache + * @since 2201.11.0 + */ public class TypeCheckCache { + // Not synchronizing this should be fine since race conditions don't lead to inconsistent results. (i.e. results + // of doing multiple type checks are agnostic to the order of execution). Data races shouldn't lead to tearing in + // 64-bit JVMs. private final Map cachedResults = new WeakHashMap<>(); private final T owner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java.rej b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java.rej deleted file mode 100644 index 0ed99d03ea7b..000000000000 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java.rej +++ /dev/null @@ -1,10 +0,0 @@ -diff a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/values/BArray.java (rejected hunks) -@@ -30,7 +30,7 @@ import java.util.Optional; - * - * @since 1.1.0 - */ --public interface BArray extends BRefValue, BCollection, PatternMatchableValue, RecursiveValue { -+public interface BArray extends BRefValue, BCollection, PatternMatchableValue, RecursiveValue { - - /** - * Get value in the given array index. 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 2e0f3aac5db5..c23f563ff6d1 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 @@ -68,6 +68,9 @@ default String informalStringValue(BLink parent) { * @return {@code SemType} representing the value's basic type */ default SemType widenedType() { + // This is wrong since we are actually returning the actual (narrowed) type of the value. But since this is + // used only as an optimization (to avoid recalculating singleton type) in the type checker this is better + // than caching the widened types as well. return SemType.tryInto(getType()); } 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 3db083bf3e22..3abe79d5ca88 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 @@ -35,6 +35,7 @@ * @since 0.995.0 */ public class BAnydataType extends BUnionType implements AnydataType { + /** * Create a {@code BAnydataType} which represents the anydata type. * @@ -89,7 +90,9 @@ public String toString() { return super.toString(); } - // TODO: this type don't have mutable parts so this should be a immutable semtype + // TODO: this type don't have mutable parts so this should be a immutable + // semtype. But some things could depend on this being a union type descriptor + // as well (which has to be mutable) @Override public SemType createSemType() { SemType semType = Builder.getAnyDataType(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BSemTypeWrapper.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BSemTypeWrapper.java index 54cbdc95b242..da72ce5704d8 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BSemTypeWrapper.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BSemTypeWrapper.java @@ -31,14 +31,13 @@ import java.util.Objects; import java.util.function.Supplier; -// TODO: make this a sealed class with clearly defined extensions - /** - * Decorator on {@code BTypes} allowing them to behave as {@code SemType}. All {@code Types} that needs to behave as - * both a {@code BType} and a {@code SemType} should extend this class. + * Decorator on {@code BTypes} allowing them to behave as {@code SemType}. All + * {@code Types} that needs to behave as both a {@code BType} and a + * {@code SemType} should extend this class. * * @param The type of the {@code BType} that is being wrapped. - * @since 2201.10.0 + * @since 2201.11.0 */ public sealed class BSemTypeWrapper extends ImmutableSemType implements Type permits BAnyType, BBooleanType, BByteType, BDecimalType, BFloatType, BHandleType, BIntegerType, BNullType, 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 64c457091b82..781aed0b86d1 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 @@ -1,20 +1,20 @@ /* - * Copyright (c) 2019, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. - * - * WSO2 Inc. 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. - */ +* Copyright (c) 2019, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. +* +* WSO2 Inc. 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.internal.types; import io.ballerina.runtime.api.Module; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/DistinctIdSupplier.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/DistinctIdSupplier.java index 84d5f1151e84..771ea177cfa5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/DistinctIdSupplier.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/DistinctIdSupplier.java @@ -30,6 +30,11 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.function.Supplier; +/** + * A supplier that provides a list of distinct ids for a given type id set. + * + * @since 2201.11.0 + */ final class DistinctIdSupplier implements Supplier> { private List ids = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/ShapeSupplier.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/ShapeSupplier.java index d64f98145190..999986483930 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/ShapeSupplier.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/ShapeSupplier.java @@ -24,6 +24,11 @@ import java.util.Optional; +/** + * Function that can be used to get the shape of a value. + * + * @since 2201.11.0 + */ @FunctionalInterface public interface ShapeSupplier { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithAcceptedType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithAcceptedType.java index 32e8d4243751..3be380e83747 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithAcceptedType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithAcceptedType.java @@ -8,6 +8,8 @@ /** * Any {@code Type} that contains selectively immutable types must implement this interface. It represents the type * against which {@code isLikeType} operation is performed. + * + * @since 2201.11.0 */ public interface TypeWithAcceptedType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithShape.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithShape.java index 15b3623176b4..259062fc6896 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithShape.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/TypeWithShape.java @@ -29,6 +29,8 @@ * must implement this interface. Note that multiple values could share the same instance of TypeWithShape. Ideally * different objects should be able to do their shape calculations in a non-blocking manner, even when they share the * same instance of {@code TypeWithShape}. + * + * @since 2201.11.0 */ public interface TypeWithShape extends TypeWithAcceptedType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/AllOrNothing.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/AllOrNothing.java index d7e95aa12494..104ed50d84ba 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/AllOrNothing.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/AllOrNothing.java @@ -20,11 +20,12 @@ package io.ballerina.runtime.internal.types.semtype; /** - * Represent cases where a subtype is either all or nothing of the basic type. For example if StringSubType has All as - * it's subtype data that means subtype is actually String basic type and nothing means it doesn't have any string + * Represent cases where a subtype is either all or nothing of the basic type. + * For example if StringSubType has All as it's subtype data that means subtype + * is actually String basic type and nothing means it doesn't have any string * subtype * - * @since 2201.10.0 + * @since 2201.11.0 */ public enum AllOrNothing implements SubTypeData { ALL, diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BBooleanSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BBooleanSubType.java index 6cba94c8d23b..a93adceb286b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BBooleanSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BBooleanSubType.java @@ -22,9 +22,9 @@ import io.ballerina.runtime.api.types.semtype.SubType; /** - * Runtime representation of BooleanSubType. + * Runtime representation of Boolean Sub Type. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BBooleanSubType extends SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubType.java index b4c2cb8c156b..2192eec3e530 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubType.java @@ -9,6 +9,11 @@ import io.ballerina.runtime.api.types.semtype.SubType; import io.ballerina.runtime.api.types.semtype.TypeAtom; +/** + * Represents a subtype of a Cell. + * + * @since 2201.11.0 + */ public abstract sealed class BCellSubType extends SubType implements DelegatedSubType permits BCellSubTypeImpl, BCellSubTypeSimple { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeImpl.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeImpl.java index 8e1fec694ef3..0335d6513051 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeImpl.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeImpl.java @@ -30,14 +30,10 @@ import java.util.Objects; import java.util.function.Predicate; -// TODO: would making this a child class of say BddNode be faster than making this a delegate -// -- Problem with this is modeling type operations (union, intersect, complement) since parent must return a Cell -// as well - /** * Runtime representation of CellSubType. * - * @since 2201.10.0 + * @since 2201.11.0 */ final class BCellSubTypeImpl extends BCellSubType implements DelegatedSubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeSimple.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeSimple.java index 69ec9984032d..8166bf862624 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeSimple.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BCellSubTypeSimple.java @@ -19,6 +19,11 @@ import static io.ballerina.runtime.api.types.semtype.BddNode.bddAtom; +/** + * Simplified representation of cell if the type is only basic type union and mutability is limited. + * + * @since 2201.11.0 + */ final class BCellSubTypeSimple extends BCellSubType implements DelegatedSubType { private final List pos; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BDecimalSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BDecimalSubType.java index a25f5639478f..03d2902e17db 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BDecimalSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BDecimalSubType.java @@ -30,7 +30,7 @@ /** * Runtime representation of DecimalSubType. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BDecimalSubType extends SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BErrorSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BErrorSubType.java index a8689a0753b4..5045122f9a2a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BErrorSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BErrorSubType.java @@ -28,6 +28,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEveryPositive; +/** + * Runtime representation of a subtype of error type. + * + * @since 2201.11.0 + */ public class BErrorSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFloatSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFloatSubType.java index 3bc9e533abe3..333e986ae9be 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFloatSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFloatSubType.java @@ -29,7 +29,7 @@ /** * Runtime representation of FloatSubType. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BFloatSubType extends SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFunctionSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFunctionSubType.java index 12a6ba335eee..cad6312b7744 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFunctionSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFunctionSubType.java @@ -30,6 +30,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEvery; +/** + * Runtime representation of a subtype of function type. + * + * @since 2201.11.0 + */ public class BFunctionSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFutureSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFutureSubType.java index 06c6efa4403e..c9389cff9671 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFutureSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BFutureSubType.java @@ -26,6 +26,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEvery; +/** + * Runtime representation of a subtype of future type. + * + * @since 2201.11.0 + */ public final class BFutureSubType extends SubType implements DelegatedSubType { private final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BIntSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BIntSubType.java index 423c7bef51d7..30e123d338fe 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BIntSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BIntSubType.java @@ -29,9 +29,9 @@ import static io.ballerina.runtime.api.constants.RuntimeConstants.INT_MIN_VALUE; /** - * Runtime representation of IntSubType. + * Runtime representation of a int subtype. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BIntSubType extends SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListProj.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListProj.java index 97648305e235..adcd59d67c89 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListProj.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListProj.java @@ -55,7 +55,7 @@ /** * utility class for list type projection. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BListProj { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListSubType.java index 7cb6e0062275..bb3bbec3769a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BListSubType.java @@ -44,7 +44,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.intersectCellMemberSemTypes; import static io.ballerina.runtime.internal.types.semtype.BIntSubType.intSubtypeContains; -// TODO: this has lot of common code with cell (and future mapping), consider refactoring (problem is createDelegate) +/** + * Runtime representation of a subtype of list type. + * + * @since 2201.11.0 + */ public class BListSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingProj.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingProj.java index c9d04aaba928..94f344aa1e85 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingProj.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingProj.java @@ -36,6 +36,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.isNothingSubtype; import static io.ballerina.runtime.api.types.semtype.Core.stringSubtype; +/** + * Utility class for doing mapping type projection. + * + * @since 2201.11.0 + */ public final class BMappingProj { private BMappingProj() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingSubType.java index b4be2442d044..bc56809a3c66 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BMappingSubType.java @@ -34,6 +34,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEvery; +/** + * Runtime representation of a subtype of mapping type. + * + * @since 2201.11.0 + */ public class BMappingSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BObjectSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BObjectSubType.java index 49db4dd05f07..de6516a4086a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BObjectSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BObjectSubType.java @@ -26,6 +26,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEveryPositive; +/** + * Runtime representation of a subtype of object type. + * + * @since 2201.11.0 + */ public final class BObjectSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStreamSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStreamSubType.java index 54094b99c6ea..c666b54ce417 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStreamSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStreamSubType.java @@ -26,6 +26,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEvery; +/** + * Runtime representation of a subtype of stream type. + * + * @since 2201.11.0 + */ public class BStreamSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStringSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStringSubType.java index 6a2af0654a89..0527874f61f1 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStringSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BStringSubType.java @@ -27,9 +27,9 @@ import java.util.Objects; /** - * Runtime representation of StringSubType. + * Runtime representation of subtype of string type. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class BStringSubType extends SubType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTableSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTableSubType.java index 4a482f969734..91243d618228 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTableSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTableSubType.java @@ -28,6 +28,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEvery; +/** + * Represents the subtype of a table type. + * + * @since 2201.11.0 + */ public final class BTableSubType extends SubType implements DelegatedSubType { private final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTypedescSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTypedescSubType.java index 714f18d3b29d..b8b0e91212a3 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTypedescSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BTypedescSubType.java @@ -28,6 +28,11 @@ import static io.ballerina.runtime.api.types.semtype.Bdd.bddEveryPositive; +/** + * Represents the subtype of a typedesc type. + * + * @since 2201.11.0 + */ public class BTypedescSubType extends SubType implements DelegatedSubType { private final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BXmlSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BXmlSubType.java index f6137905b67f..35479680eb62 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BXmlSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BXmlSubType.java @@ -26,6 +26,11 @@ import java.util.Objects; +/** + * Represents the subtype of an XML type. + * + * @since 2201.11.0 + */ public class BXmlSubType extends SubType implements DelegatedSubType { public final Bdd inner; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BddMemo.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BddMemo.java index faee572d96c1..739117d179f5 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BddMemo.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/BddMemo.java @@ -21,6 +21,11 @@ import java.util.Objects; import java.util.Optional; +/** + * Represents the memoization emptiness of a BDD used in Context. + * + * @since 2201.11.0 + */ public final class BddMemo { public Status isEmpty; @@ -30,11 +35,15 @@ public BddMemo() { } public enum Status { + // We know where this BDD is empty or not TRUE, FALSE, + // There is some recursive part in this type LOOP, CYCLIC, + // We are in the process of determining if this BDD is empty or not PROVISIONAL, + // We just initialized the node, treated to be same as not having a memo NULL } @@ -56,9 +65,12 @@ public int hashCode() { public Optional isEmpty() { return switch (isEmpty) { + // Cyclic types are empty because we define types inductively case TRUE, CYCLIC -> Optional.of(true); case FALSE -> Optional.of(false); case LOOP, PROVISIONAL -> { + // If it was provisional we came from a back edge + // Again we treat the loop part as empty isEmpty = Status.LOOP; yield Optional.of(true); } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/CellAtomicType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/CellAtomicType.java index b83a655ea081..8e75f75af7b6 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/CellAtomicType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/CellAtomicType.java @@ -32,7 +32,7 @@ * * @param ty Type "wrapped" by this cell * @param mut Mutability of the cell - * @since 2201.10.0 + * @since 2201.11.0 */ public record CellAtomicType(SemType ty, CellMutability mut) implements AtomicType { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Common.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Common.java index d4dda91cf99d..8d057aa5e4ef 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Common.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Common.java @@ -19,6 +19,11 @@ package io.ballerina.runtime.internal.types.semtype; +/** + * Utility class for various operations related to semantic types. + * + * @since 2201.11.0 + */ public final class Common { private Common() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/DelegatedSubType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/DelegatedSubType.java index 8f0de442efce..6f798ca4d07c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/DelegatedSubType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/DelegatedSubType.java @@ -20,6 +20,11 @@ import io.ballerina.runtime.api.types.semtype.SubType; +/** + * Represents the subtype implemented by BDDs. + * + * @since 2201.11.0 + */ public interface DelegatedSubType extends SubTypeData { SubType inner(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/EnumerableSubtypeData.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/EnumerableSubtypeData.java index a7831a541c12..4f8429d51f1f 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/EnumerableSubtypeData.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/EnumerableSubtypeData.java @@ -25,11 +25,12 @@ import java.util.List; /** - * All {@code SubTypeData} where we can enumerate individual values must extend this class. It will provide common - * operations such as {@code union}, {@code intersect} and {@code diff} for all such data. + * All {@code SubTypeData} where we can enumerate individual values must extend + * this class. It will provide common operations such as {@code union}, + * {@code intersect} and {@code diff} for all such data. * * @param type individual value in the subset - * @since 2201.10.0 + * @since 2201.11.0 */ public abstract class EnumerableSubtypeData> { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ErrorUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ErrorUtils.java index 258469348fde..870fae6f4e7a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ErrorUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ErrorUtils.java @@ -31,6 +31,11 @@ import static io.ballerina.runtime.api.types.semtype.Builder.basicSubType; import static io.ballerina.runtime.api.types.semtype.RecAtom.createDistinctRecAtom; +/** + * Utility methods for creating error types. + * + * @since 2201.11.0 + */ public final class ErrorUtils { private ErrorUtils() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FixedLengthArray.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FixedLengthArray.java index 6ab864273f18..8284a390a38b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FixedLengthArray.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FixedLengthArray.java @@ -23,8 +23,15 @@ import java.util.Arrays; import java.util.Objects; +/** + * Represents required member part of a list atom. + * + * @since 2201.11.0 + */ public final class FixedLengthArray { + // We have a separate fixedLength so types such as {@code byte[500]} don't need to store 500 elements + // in {@code initial}. private final SemType[] initial; private final int fixedLength; private Integer hashCode; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionAtomicType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionAtomicType.java index 1a84adc9fa4b..349ca151de59 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionAtomicType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionAtomicType.java @@ -21,6 +21,14 @@ import io.ballerina.runtime.api.types.semtype.AtomicType; import io.ballerina.runtime.api.types.semtype.SemType; +/** + * Represents a function atomic type. + * + * @param paramType function parameters. This is a list type + * @param retType return type + * @param qualifiers function qualifiers. This is a list type + * @since 2201.11.0 + */ public record FunctionAtomicType(SemType paramType, SemType retType, SemType qualifiers) implements AtomicType { } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionDefinition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionDefinition.java index 200787c2c09b..bc9f8a25ca0e 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionDefinition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionDefinition.java @@ -27,6 +27,11 @@ import io.ballerina.runtime.api.types.semtype.RecAtom; import io.ballerina.runtime.api.types.semtype.SemType; +/** + * {@code Definition} used to create function subtypes. + * + * @since 2201.11.0 + */ public class FunctionDefinition implements Definition { private RecAtom rec; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionQualifiers.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionQualifiers.java index 2fd1a33b1096..0b90e9bad41d 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionQualifiers.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FunctionQualifiers.java @@ -22,6 +22,11 @@ import io.ballerina.runtime.api.types.semtype.Env; import io.ballerina.runtime.api.types.semtype.SemType; +/** + * Represents the qualifiers of a function. + * + * @since 2201.11.0 + */ public final class FunctionQualifiers { private static final FunctionQualifiers DEFAULT = new FunctionQualifiers(false, false); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FutureUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FutureUtils.java index 14c57d8e4bec..8c927ac0b442 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FutureUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/FutureUtils.java @@ -27,7 +27,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.createBasicSemType; import static io.ballerina.runtime.api.types.semtype.Core.subTypeData; -// TODO: this should be part of the public API +/** + * Utility methods for creating future types. + * + * @since 2201.11.0 + */ public final class FutureUtils { private static final MappingDefinition.Field[] EMPTY_FIELDS = new MappingDefinition.Field[0]; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListAtomicType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListAtomicType.java index 22d605b2844f..5631bbc55036 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListAtomicType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListAtomicType.java @@ -21,6 +21,13 @@ import io.ballerina.runtime.api.types.semtype.AtomicType; import io.ballerina.runtime.api.types.semtype.SemType; +/** + * Represent list atomic type. + * + * @param members required member types of the list + * @param rest rest of member type of the list + * @since 2201.11.0 + */ public record ListAtomicType(FixedLengthArray members, SemType rest) implements AtomicType { } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListDefinition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListDefinition.java index 24d5c832a028..bd2b310c9e1b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListDefinition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ListDefinition.java @@ -34,6 +34,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.union; import static io.ballerina.runtime.internal.types.semtype.CellAtomicType.CellMutability.CELL_MUT_NONE; +/** + * {@code Definition} used to create a list type. + * + * @since 2201.11.0 + */ public class ListDefinition implements Definition { private RecAtom rec = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingAtomicType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingAtomicType.java index d7e6032a2528..9ad1916a6637 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingAtomicType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingAtomicType.java @@ -32,8 +32,20 @@ import static io.ballerina.runtime.api.types.semtype.Core.intersectCellMemberSemTypes; import static io.ballerina.runtime.api.types.semtype.Core.isNever; +/** + * Represent mapping atomic type. + * + * @param names required member names of the mapping + * @param types required member types of the mapping + * @param rest rest of member type of the mapping + * @since 2201.11.0 + */ public record MappingAtomicType(String[] names, SemType[] types, SemType rest) implements AtomicType { + public MappingAtomicType { + assert names.length == types.length; + } + public MappingAtomicType intersectMapping(Env env, MappingAtomicType other) { int expectedSize = Integer.min(types().length, other.types().length); Collection names = new ArrayList<>(expectedSize); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingDefinition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingDefinition.java index ad99b5a09ee1..182c9b9f9bd3 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingDefinition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MappingDefinition.java @@ -37,6 +37,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.isNever; import static io.ballerina.runtime.api.types.semtype.Core.union; +/** + * {@code Definition} used to create a mapping type. + * + * @since 2201.11.0 + */ public class MappingDefinition implements Definition { private RecAtom rec = null; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Member.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Member.java index 5b10766a20ea..19a6938b9d68 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Member.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/Member.java @@ -23,6 +23,17 @@ import static io.ballerina.runtime.api.types.semtype.Builder.getStringConst; +/** + * Represents a member of an object type. + * + * @param name the name of the member. For methods, this is the method name, and for fields, this is the field + * name. + * @param valueTy the type of the member + * @param kind the kind of the member (either {@link Kind#Field} or {@link Kind#Method}) + * @param visibility the visibility of the member (either {@link Visibility#Public} or {@link Visibility#Private}) + * @param immutable whether the member is immutable + * @since 2201.11.0 + */ public record Member(String name, SemType valueTy, Kind kind, Visibility visibility, boolean immutable) { public enum Kind { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MutableSemType.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MutableSemType.java index 01b223b66460..2059cb237766 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MutableSemType.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/MutableSemType.java @@ -21,6 +21,12 @@ import io.ballerina.runtime.api.types.semtype.SemType; import io.ballerina.runtime.internal.types.BType; +/** + * Represents a mutable semantic type. Note in the current implementation we assume after type checking this is to be + * immutable. + * + * @since 2201.11.0 + */ public sealed interface MutableSemType permits BType { SemType createSemType(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectDefinition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectDefinition.java index 5fded96a4ca4..2d2ee5f92623 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectDefinition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectDefinition.java @@ -36,6 +36,16 @@ import static io.ballerina.runtime.api.types.semtype.Core.union; import static io.ballerina.runtime.api.types.semtype.RecAtom.createDistinctRecAtom; +/** + * {@code Definition} used to create an object type. + *

+ * Each object type is represented as mapping type (with its basic type set to object) as fallows + * {@code { "$qualifiers": { boolean isolated, "client"|"service" network }, [field_name]: { "field"|"method" kind, + * "public"|"private" visibility, VAL value; } ...{ "field" kind, "public"|"private" visibility, VAL value; } | { + * "method" kind, "public"|"private" visibility, FUNCTION value; } }} + * + * @since 2201.11.0 + */ public class ObjectDefinition implements Definition { private final MappingDefinition mappingDefinition = new MappingDefinition(); @@ -64,7 +74,9 @@ private SemType objectContaining(SemType mappingType) { private SemType restMemberType(Env env, CellAtomicType.CellMutability mut, boolean readonly) { MappingDefinition fieldDefn = new MappingDefinition(); SemType fieldMemberType = fieldDefn.defineMappingTypeWrapped(env, new MappingDefinition.Field[]{ - new MappingDefinition.Field("value", readonly ? Builder.getReadonlyType() : Builder.getValType(), + new MappingDefinition.Field( + "value", + readonly ? Builder.getReadonlyType() : Builder.getValType(), readonly, false), Member.Kind.Field.field(), Member.Visibility.ALL}, Builder.getNeverType(), diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectQualifiers.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectQualifiers.java index 46ee0dc30446..33d52a1816a9 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectQualifiers.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/ObjectQualifiers.java @@ -26,6 +26,15 @@ import static io.ballerina.runtime.api.types.semtype.Builder.getStringConst; import static io.ballerina.runtime.api.types.semtype.Core.union; +/** + * Represents the qualifiers of an object type. + * + * @param isolated whether the object is isolated + * @param readonly whether the object is readonly + * @param networkQualifier the network qualifier of the object (either {@link NetworkQualifier#Client}, + * {@link NetworkQualifier#Service}, or {@link NetworkQualifier#None}) + * @since 2201.11.0 + */ public record ObjectQualifiers(boolean isolated, boolean readonly, NetworkQualifier networkQualifier) { public MappingDefinition.Field field(Env env) { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/RegexUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/RegexUtils.java index 3809940eb105..39c4264ba8cc 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/RegexUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/RegexUtils.java @@ -22,6 +22,11 @@ import io.ballerina.runtime.api.types.semtype.Builder; import io.ballerina.runtime.api.types.semtype.SemType; +/** + * Utility class for creating semtypes of regex tagged basic type. + * + * @since 2201.11.0 + */ public final class RegexUtils { private RegexUtils() { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SemTypeHelper.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SemTypeHelper.java index 86bdcc2fe854..7bad30e0127b 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SemTypeHelper.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SemTypeHelper.java @@ -44,7 +44,7 @@ /** * Collection of utility function on {@code SemType}. * - * @since 2201.10.0 + * @since 2201.11.0 */ public final class SemTypeHelper { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/StreamDefinition.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/StreamDefinition.java index 1e65c0082044..3d879c011238 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/StreamDefinition.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/StreamDefinition.java @@ -29,6 +29,12 @@ import static io.ballerina.runtime.api.types.semtype.Core.createBasicSemType; import static io.ballerina.runtime.api.types.semtype.Core.subTypeData; +/** + * {@code Definition} used to create a stream type. Stream is represented as a + * tuple of {@code [valueType, completionType]} + * + * @since 2201.11.0 + */ public class StreamDefinition implements Definition { private final ListDefinition listDefinition = new ListDefinition(); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubTypeData.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubTypeData.java index d55a20832818..a418583d10af 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubTypeData.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubTypeData.java @@ -21,9 +21,8 @@ /** * Marker interface for SubTypeData. * - * @since 2201.10.0 + * @since 2201.11.0 */ -// TODO: move this to api public interface SubTypeData { } diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePair.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePair.java index 71ac6c9b31c4..d56e4bd33899 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePair.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePair.java @@ -20,6 +20,16 @@ import io.ballerina.runtime.api.types.semtype.SubType; +/** + * Represents the corresponding subtype pairs of two semtypes. + * + * @param typeCode the type code of the semtype + * @param subType1 the first subtype. This will if the first semtype don't have + * this subtype + * @param subType2 the second subtype. This will if the second semtype don't + * have this subtype + * @since 2201.11.0 + */ public record SubtypePair(int typeCode, SubType subType1, SubType subType2) { public SubtypePair { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairIterator.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairIterator.java index a79e346495b3..f061b012896a 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairIterator.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairIterator.java @@ -27,7 +27,7 @@ /** * Iteration implementation of `SubtypePairIterator`. * - * @since 2201.10.0 + * @since 2201.11.0 */ final class SubtypePairIterator implements Iterator { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairs.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairs.java index 07100a7b5ba6..95844611c535 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairs.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/SubtypePairs.java @@ -25,7 +25,7 @@ /** * Implements the iterable for `SubtypePairIteratorImpl`. * - * @since 2201.10.0 + * @since 2201.11.0 */ public class SubtypePairs implements Iterable { diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TableUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TableUtils.java index 46b4c16981a7..158259252366 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TableUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TableUtils.java @@ -33,6 +33,11 @@ import static io.ballerina.runtime.internal.types.semtype.CellAtomicType.CellMutability.CELL_MUT_NONE; import static io.ballerina.runtime.internal.types.semtype.CellAtomicType.CellMutability.CELL_MUT_UNLIMITED; +/** + * Utility class for creating semtypes of table type. + * + * @since 2201.11.0 + */ public final class TableUtils { private static final SemType[] EMPTY_SEMTYPE_ARR = new SemType[0]; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TypedescUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TypedescUtils.java index 83725da486d2..4bf7b6a78406 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TypedescUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/TypedescUtils.java @@ -28,6 +28,11 @@ import static io.ballerina.runtime.api.types.semtype.Core.createBasicSemType; import static io.ballerina.runtime.api.types.semtype.Core.subTypeData; +/** + * Utility class for creating semtypes of typedesc type. + * + * @since 2201.11.0 + */ public final class TypedescUtils { private static final MappingDefinition.Field[] EMPTY_FIELDS = new MappingDefinition.Field[0]; diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/XmlUtils.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/XmlUtils.java index 08986b9fc339..f05813ead001 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/XmlUtils.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/semtype/XmlUtils.java @@ -32,7 +32,11 @@ import static io.ballerina.runtime.api.types.semtype.BddNode.bddAtom; -// TODO: this should be a part of the public API +/** + * Utility class for creating semtypes of XML type. + * + * @since 2201.11.0 + */ public final class XmlUtils { public static final int XML_PRIMITIVE_NEVER = 1; 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 33d1556e632e..6de01ea4ee31 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 @@ -493,9 +493,4 @@ public static DecimalValue valueOfJ(BigDecimal value) { public Optional inherentTypeOf(Context cx) { return Optional.of(Builder.getDecimalConst(value)); } - - @Override - public SemType widenedType() { - return Builder.getDecimalType(); - } } 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 a7d0b0c06428..6b5a72d3f13d 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 @@ -20,7 +20,6 @@ import io.ballerina.runtime.api.async.StrandMetadata; import io.ballerina.runtime.api.constants.RuntimeConstants; import io.ballerina.runtime.api.types.Type; -import io.ballerina.runtime.api.types.semtype.Builder; import io.ballerina.runtime.api.types.semtype.Context; import io.ballerina.runtime.api.types.semtype.SemType; import io.ballerina.runtime.api.values.BFunctionPointer; @@ -133,11 +132,6 @@ public String toString() { return RuntimeConstants.EMPTY; } - @Override - public SemType widenedType() { - return Builder.getFunctionType(); - } - @Override public Optional inherentTypeOf(Context cx) { return Optional.of(SemType.tryInto(getType())); diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RecursiveValue.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RecursiveValue.java index d8f478a8f0ae..ac6270fe252c 100644 --- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RecursiveValue.java +++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/RecursiveValue.java @@ -6,6 +6,8 @@ * Every value that can contain a recursive reference should implement this interface. * * @param Type of the definition + * + * @since 2201.11.0 */ interface RecursiveValue {