Port never type

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/SemType/Builder.java

@@ -20,12 +20,12 @@
 
 import io.ballerina.runtime.api.types.Type;
 import io.ballerina.runtime.internal.types.BType;
+import io.ballerina.runtime.internal.types.BTypeConverter;
 import io.ballerina.runtime.internal.types.semtype.BBasicTypeBitSet;
 import io.ballerina.runtime.internal.types.semtype.BFloatSubType;
 import io.ballerina.runtime.internal.types.semtype.BIntSubType;
 import io.ballerina.runtime.internal.types.semtype.BSemType;
 import io.ballerina.runtime.internal.types.semtype.BStringSubType;
-import io.ballerina.runtime.internal.types.semtype.BSubType;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -49,7 +49,11 @@ public static SemType from(Type type) {
     }
 
     public static SemType from(BType innerType) {
-        return basicSubType(BasicTypeCode.BT_B_TYPE, BSubType.wrap(innerType));
+        return BTypeConverter.from(innerType);
+    }
+
+    public static SemType neverType() {
+        return basicTypeUnion(0);
     }
 
     public static SemType basicTypeUnion(int bitset) {

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/types/SemType/Core.java

@@ -38,6 +38,7 @@
 public final class Core {
 
     private static final SemType SEMTYPE_TOP = BBasicTypeBitSet.from((1 << (CODE_UNDEF + 1)) - 1);
+    private static final BasicTypeBitSet B_TYPE_TOP = BBasicTypeBitSet.from(1 << BT_B_TYPE.code());
 
     private Core() {
     }
@@ -225,7 +226,7 @@ public static SemType complement(SemType t1) {
     }
 
     public static boolean isNever(SemType t) {
-        throw new IllegalStateException("Unimplemented");
+        return t.all() == 0 && t.some() == 0;
     }
 
     public static boolean isSubType(Context cx, SemType t1, SemType t2) {
@@ -242,9 +243,14 @@ public static boolean isSubType(Context cx, SemType t1, SemType t2,
 
     private static boolean applyFallback(SemType t1, SemType t2,
                                          BiFunction<? super BType, ? super BType, Boolean> fallback) {
-        BType bType1 = (BType) subTypeData(t1, BT_B_TYPE);
-        BType bType2 = (BType) subTypeData(t2, BT_B_TYPE);
-        return fallback.apply(bType1, bType2);
+        boolean t1HasBType = containsBasicType(t1, B_TYPE_TOP);
+        boolean t2HasBType = containsBasicType(t2, B_TYPE_TOP);
+        if (t1HasBType && t2HasBType) {
+            BType bType1 = (BType) subTypeData(t1, BT_B_TYPE);
+            BType bType2 = (BType) subTypeData(t2, BT_B_TYPE);
+            return fallback.apply(bType1, bType2);
+        }
+        return !t1HasBType;
     }
 
     private static SubTypeData subTypeData(SemType s, BasicTypeCode code) {
@@ -257,8 +263,14 @@ private static SubTypeData subTypeData(SemType s, BasicTypeCode code) {
         return s.subTypeData().get(code.code()).data();
     }
 
+    private static boolean containsBasicType(SemType t1, BasicTypeBitSet t2) {
+        int bits = t1.all() | t1.some();
+        return (bits & t2.all()) != 0;
+    }
+
     public static boolean isSubTypeSimple(SemType t1, BasicTypeBitSet t2) {
-        throw new IllegalStateException("Unimplemented");
+        int bits = t1.all() | t1.some();
+        return (bits & ~t2.all()) == 0;
     }
 
     public static boolean isSameType(Context cx, SemType t1, SemType t2) {

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BTypeConverter.java

@@ -0,0 +1,105 @@
+/*
+ *  Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com).
+ *
+ *  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.internal.types;
+
+import io.ballerina.runtime.api.flags.SymbolFlags;
+import io.ballerina.runtime.api.types.Field;
+import io.ballerina.runtime.api.types.SemType.BasicTypeCode;
+import io.ballerina.runtime.api.types.SemType.Builder;
+import io.ballerina.runtime.api.types.SemType.Core;
+import io.ballerina.runtime.api.types.SemType.SemType;
+import io.ballerina.runtime.api.types.Type;
+import io.ballerina.runtime.internal.types.semtype.BSubType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// NOTE: this is so that we don't have to expose any utility constructors as public to builder
+public final class BTypeConverter {
+
+    private BTypeConverter() {
+    }
+
+    private static SemType from(Type type) {
+        if (type instanceof SemType semType) {
+            return semType;
+        } else if (type instanceof BType bType) {
+            return from(bType);
+        }
+        throw new IllegalArgumentException("Unsupported type: " + type);
+    }
+
+    public static SemType from(BType innerType) {
+        if (innerType instanceof BNeverType) {
+            return Builder.neverType();
+        } else if (innerType instanceof BUnionType unionType) {
+            return fromUnionType(unionType);
+        } else if (innerType instanceof BRecordType recordType) {
+            return fromRecordType(recordType);
+        } else if (innerType instanceof BTupleType tupleType) {
+            return fromTupleType(tupleType);
+        }
+        return wrapAsPureBType(innerType);
+    }
+
+    private static SemType fromTupleType(BTupleType tupleType) {
+        for (Type type : tupleType.getTupleTypes()) {
+            if (Core.isNever(from(type))) {
+                return Builder.neverType();
+            }
+        }
+        return wrapAsPureBType(tupleType);
+    }
+
+    private static SemType wrapAsPureBType(BType tupleType) {
+        return Builder.basicSubType(BasicTypeCode.BT_B_TYPE, BSubType.wrap(tupleType));
+    }
+
+    private static SemType fromRecordType(BRecordType recordType) {
+        for (Field field : recordType.fields.values()) {
+            if (!SymbolFlags.isFlagOn(field.getFlags(), SymbolFlags.OPTIONAL)) {
+                SemType fieldType = from(field.getFieldType());
+                if (Core.isNever(fieldType)) {
+                    return Builder.neverType();
+                }
+            }
+        }
+        return wrapAsPureBType(recordType);
+    }
+
+    private static SemType fromUnionType(BUnionType unionType) {
+        List<Type> members = unionType.getMemberTypes();
+        List<Type> bTypeMembers = new ArrayList<>(members.size());
+        SemType semTypePart = Builder.neverType();
+        for (Type member : members) {
+            if (isSemType(member)) {
+                semTypePart = Core.union(from(member), semTypePart);
+            } else {
+                bTypeMembers.add(member);
+            }
+        }
+        BUnionType newUnionType = unionType.cloneWithMembers(bTypeMembers);
+        SemType bTypePart = Builder.basicSubType(BasicTypeCode.BT_B_TYPE, BSubType.wrap(newUnionType));
+        return Core.union(semTypePart, bTypePart);
+    }
+
+    private static boolean isSemType(Type type) {
+        return type instanceof BNeverType;
+    }
+}

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/types/BUnionType.java

@@ -135,6 +135,27 @@ protected BUnionType(String typeName, Module pkg, boolean readonly, Class<? exte
         this.readonly = readonly;
     }
 
+    BUnionType cloneWithMembers(List<Type> newMembers) {
+        BUnionType newUnionType = new BUnionType(memberTypes, this.typeFlags, this.readonly, this.isCyclic);
+        newUnionType.isCyclic = isCyclic;
+        newUnionType.memberTypes = newMembers;
+        newUnionType.originalMemberTypes = newMembers;
+        newUnionType.nullable = nullable;
+        newUnionType.flags = flags;
+        newUnionType.typeFlags = typeFlags;
+        newUnionType.readonly = readonly;
+        newUnionType.immutableType = immutableType;
+        newUnionType.intersectionType = intersectionType;
+        newUnionType.cachedToString = cachedToString;
+        newUnionType.resolving = resolving;
+        newUnionType.resolvingReadonly = resolvingReadonly;
+
+        newUnionType.typeName = typeName;
+        newUnionType.pkg = pkg;
+
+        return newUnionType;
+    }
+
     /**
      * Constructor used when defining union type defs where cyclic reference is possible.
      *