private BType getActualNonNilArrayElementType(BType actualArrayElementType) { if (actualArrayElementType.getTag() == TypeTags.UNION_TAG) { return (((BUnionType) actualArrayElementType).getMemberTypes()).get(0); } else { return actualArrayElementType; } }
private static boolean checkUnionCast(BValue rhsValue, BType lhsType, List<TypePair> unresolvedTypes) { BUnionType unionType = (BUnionType) lhsType; for (BType memberType : unionType.getMemberTypes()) { if (checkCast(rhsValue, memberType, unresolvedTypes)) { return true; } } return false; }
private static boolean checkUnionAssignable(BType sourceType, BType targetType, List<TypePair> unresolvedTypes) { if (sourceType.getTag() == TypeTags.UNION_TAG) { for (BType sourceMemberType : ((BUnionType) sourceType).getMemberTypes()) { if (!checkUnionAssignable(sourceMemberType, targetType, unresolvedTypes)) { return false; } } return true; } else { BUnionType targetUnionType = (BUnionType) targetType; for (BType memberType : targetUnionType.getMemberTypes()) { if (isAssignable(sourceType, memberType, unresolvedTypes)) { return true; } } return false; } }
private int retrieveNonNilTypeTag(BType fieldType) { List<BType> members = ((BUnionType) fieldType).getMemberTypes(); return retrieveNonNilType(members).getTag(); }
private static BValue parseUnionArg(BUnionType type, String unionArg) { List<BType> unionMemberTypes = type.getMemberTypes(); if (unionMemberTypes.contains(BTypes.typeNull) && NIL.equals(unionArg)) { return null; } if (unionMemberTypes.contains(BTypes.typeString)) { return new BString(unionArg); } for (int memberTypeIndex = 0; memberTypeIndex < unionMemberTypes.size();) { try { BType memberType = unionMemberTypes.get(memberTypeIndex); if (memberType.getTag() == TypeTags.NULL_TAG) { memberTypeIndex++; continue; } return getBValue(memberType, unionArg); } catch (BLangUsageException e) { memberTypeIndex++; } } throw new BLangUsageException("invalid argument '" + unionArg + "' specified for union type: " + (type.isNullable() ? type.toString().replace("|null", "|()") : type)); } }
private void handleOIDValue(int index, BMap<String, BValue> bStruct, String fieldName, BType fieldType) throws SQLException { int fieldTypeTag = fieldType.getTag(); if (fieldTypeTag == TypeTags.UNION_TAG) { BType nonNilType = retrieveNonNilType(((BUnionType) fieldType).getMemberTypes()); assignOIDValue(nonNilType.getTag(), nonNilType, fieldName, index, bStruct, unassignableUnionTypeAssignmentHandler); } else { // Need to call a getter method before calling ResultSet#wasNull. long longValue = rs.getLong(index); boolean isOriginalValueNull = rs.wasNull(); if (longValue == 0 && isOriginalValueNull) { handleNilToNonNillableFieldAssignment(); } else { assignOIDValue(fieldTypeTag, fieldType, fieldName, index, bStruct, mismatchingFieldAssignmentHandler); } } }
isAnydata(recordType.restFieldType, unresolvedTypes)); case TypeTags.UNION_TAG: return isAnydata(((BUnionType) type).getMemberTypes(), unresolvedTypes); case TypeTags.TUPLE_TAG: return isAnydata(((BTupleType) type).getTupleTypes(), unresolvedTypes);
List<BType> memberTypes = new ArrayList<>(((BUnionType) stampType).getMemberTypes()); targetType = new BUnionType(memberTypes); ((BUnionType) targetType).getMemberTypes().removeIf(errorPredicate); if (((BUnionType) targetType).getMemberTypes().size() == 1) { targetType = ((BUnionType) stampType).getMemberTypes().get(0);
private static BValue convertMap(Strand ctx, BMap<String, BValue> mapValue, BType targetType, String key) { switch (targetType.getTag()) { case TypeTags.RECORD_TYPE_TAG: return convertMapToStruct(ctx, mapValue, (BStructureType) targetType); case TypeTags.JSON_TAG: return JSONUtils.convertMapToJSON(mapValue, (BJSONType) targetType); case TypeTags.UNION_TAG: for (BType memType : ((BUnionType) targetType).getMemberTypes()) { try { return convertMap(ctx, mapValue, memType, key); } catch (BallerinaException e) { // ignore conversion exception if thrown when the expected type is a union // type, to allow attempting conversion for other types } } break; default: if (checkCast(mapValue, targetType, new ArrayList<TypePair>())) { return mapValue; } } throw BLangExceptionHelper.getRuntimeException(RuntimeErrors.INCOMPATIBLE_FIELD_TYPE_FOR_CASTING, key, targetType, mapValue.getType()); }
@Override public void stamp(BType type) { if (type.getTag() == TypeTags.ANYDATA_TAG || type.getTag() == TypeTags.JSON_TAG) { return; } if (type.getTag() == TypeTags.UNION_TAG) { for (BType memberType : ((BUnionType) type).getMemberTypes()) { if (BVM.checkIsLikeType(this, memberType)) { this.stamp(memberType); type = memberType; break; } } } this.setType(type); } }
public static boolean checkIsLikeType(BValue sourceValue, BType targetType) { BType sourceType = sourceValue == null ? BTypes.typeNull : sourceValue.getType(); if (checkIsType(sourceType, targetType, new ArrayList<>())) { return true; } switch (targetType.getTag()) { case TypeTags.RECORD_TYPE_TAG: return checkIsLikeRecordType(sourceValue, (BRecordType) targetType); case TypeTags.JSON_TAG: return checkIsLikeJSONType(sourceValue, (BJSONType) targetType); case TypeTags.MAP_TAG: return checkIsLikeMapType(sourceValue, (BMapType) targetType); case TypeTags.ARRAY_TAG: return checkIsLikeArrayType(sourceValue, (BArrayType) targetType); case TypeTags.TUPLE_TAG: return checkIsLikeTupleType(sourceValue, (BTupleType) targetType); case TypeTags.ANYDATA_TAG: return checkIsLikeAnydataType(sourceValue, targetType); case TypeTags.FINITE_TYPE_TAG: return checkFiniteTypeAssignable(sourceValue, targetType); case TypeTags.UNION_TAG: return ((BUnionType) targetType).getMemberTypes().stream() .anyMatch(type -> checkIsLikeType(sourceValue, type)); default: return false; } }
for (BType memberType : ((BUnionType) type).getMemberTypes()) { if (BVM.checkIsLikeType(this, memberType)) { this.stamp(memberType);
return null; List<BType> matchingTypes = type.getMemberTypes().stream() .filter(memberType -> memberType != BTypes.typeNull).collect(Collectors.toList()); if (matchingTypes.size() == 1) {
private void handleStructValue(BMap<String, BValue> bStruct, String fieldName, Struct structData, BType fieldType) { int fieldTypeTag = fieldType.getTag(); if (fieldTypeTag == TypeTags.UNION_TAG) { BType structFieldType = retrieveNonNilType(((BUnionType) fieldType).getMemberTypes()); if (structFieldType.getTag() == TypeTags.RECORD_TYPE_TAG) { BMap<String, BValue> userDefinedType = createUserDefinedType(structData, (BRecordType) structFieldType); bStruct.put(fieldName, userDefinedType); } else { handleUnAssignableUnionTypeAssignment(); } } else if (fieldTypeTag == TypeTags.RECORD_TYPE_TAG) { validateAndSetRefRecordField(bStruct, fieldName, TypeTags.RECORD_TYPE_TAG, fieldTypeTag, createUserDefinedType(structData, (BRecordType) fieldType), MISMATCHING_FIELD_ASSIGNMENT); } else { handleMismatchingFieldAssignment(); } }
private void handleMappingArrayElementToUnionType(BArrayType expectedArrayType, BNewArray arrayTobeSet, String fieldName, BMap<String, BValue> bStruct) { BArrayType arrayType = (BArrayType) arrayTobeSet.getType(); if (arrayType.getElementType().getTag() == TypeTags.NULL_TAG) { bStruct.put(fieldName, arrayTobeSet); } else { BUnionType expectedArrayElementUnionType = (BUnionType) expectedArrayType.getElementType(); BType expectedNonNilArrayElementType = retrieveNonNilType(expectedArrayElementUnionType.getMemberTypes()); BType actualNonNilArrayElementType = getActualNonNilArrayElementType(arrayType.getElementType()); validateAndSetRefRecordField(bStruct, fieldName, expectedNonNilArrayElementType .getTag(), actualNonNilArrayElementType.getTag(), arrayTobeSet, UNASSIGNABLE_UNIONTYPE_EXCEPTION); } }
return checkIsTupleType(sourceType, (BTupleType) targetType, unresolvedTypes); case TypeTags.UNION_TAG: return ((BUnionType) targetType).getMemberTypes().stream() .anyMatch(type -> checkIsType(sourceType, type, unresolvedTypes)); case TypeTags.TABLE_TAG:
private void handleArrayValue(BMap<String, BValue> bStruct, String fieldName, Array data, BType fieldType) throws SQLException { int fieldTypeTag = fieldType.getTag(); BNewArray dataArray = getDataArray(data); if (dataArray != null) { BType nonNilType = fieldType; if (fieldTypeTag == TypeTags.UNION_TAG) { nonNilType = retrieveNonNilType(((BUnionType) fieldType).getMemberTypes()); } // The dataArray is created from the array returned from the database. There, an array of Union Type is // created only if the array includes NULL elements. boolean containsNull = dataArray.getType().getTag() == TypeTags.ARRAY_TAG && ((BArrayType) dataArray.getType()).getElementType().getTag() == TypeTags.UNION_TAG; handleMappingArrayValue(nonNilType, bStruct, dataArray, fieldName, containsNull); } else { if (fieldTypeTag == TypeTags.UNION_TAG) { bStruct.put(fieldName, null); } else { handleNilToNonNillableFieldAssignment(); } } }
private void handleBinaryValue(BMap<String, BValue> bStruct, String fieldName, byte[] bytes, BType fieldType) { int fieldTypeTag = fieldType.getTag(); if (fieldTypeTag == TypeTags.UNION_TAG) { BType nonNillType = retrieveNonNilType(((BUnionType) fieldType).getMemberTypes()); if (nonNillType.getTag() == TypeTags.ARRAY_TAG) { int elementTypeTag = ((BArrayType) nonNillType).getElementType().getTag();
for (BType memberType : ((BUnionType) type).getMemberTypes()) { if (BVM.checkIsLikeType(this, memberType)) { this.stamp(memberType);