Support record defaultable fields with closure values for runtime

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/api/constants/RuntimeConstants.java

@@ -50,7 +50,7 @@ public class RuntimeConstants {
     public static final String UNDERSCORE = "_";
     public static final String COLON = ":";
     public static final char DOLLAR = '$';
-
+    public static final String RECORD_DELIMITER = DOLLAR + "rec" + DOLLAR;
     public static final String BLANG_SRC_FILE_EXT = "bal";
     public static final String BLANG_SRC_FILE_SUFFIX = "." + BLANG_SRC_FILE_EXT;
 

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/ValueConverter.java

@@ -24,6 +24,7 @@
 import io.ballerina.runtime.api.types.AnydataType;
 import io.ballerina.runtime.api.types.ArrayType;
 import io.ballerina.runtime.api.types.Field;
+import io.ballerina.runtime.api.types.IntersectionType;
 import io.ballerina.runtime.api.types.MapType;
 import io.ballerina.runtime.api.types.RecordType;
 import io.ballerina.runtime.api.types.TableType;
@@ -45,9 +46,12 @@
 import io.ballerina.runtime.internal.errors.ErrorHelper;
 import io.ballerina.runtime.internal.errors.ErrorReasons;
 import io.ballerina.runtime.internal.regexp.RegExpFactory;
+import io.ballerina.runtime.internal.types.BIntersectionType;
+import io.ballerina.runtime.internal.types.BRecordType;
 import io.ballerina.runtime.internal.values.ArrayValue;
 import io.ballerina.runtime.internal.values.ArrayValueImpl;
 import io.ballerina.runtime.internal.values.MapValueImpl;
+import io.ballerina.runtime.internal.values.ReadOnlyUtils;
 import io.ballerina.runtime.internal.values.TableValueImpl;
 import io.ballerina.runtime.internal.values.TupleValueImpl;
 
@@ -56,6 +60,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import static io.ballerina.runtime.api.creators.ErrorCreator.createError;
@@ -209,6 +214,12 @@ private static BMap<BString, Object> convertToRecord(BMap<?, ?> map, Set<TypeVal
             Object newValue = convertRecordEntry(unresolvedValues, restFieldType, targetTypeField, entry);
             valueMap.put(entry.getKey().toString(), newValue);
         }
+        Optional<IntersectionType> intersectionType = ((BRecordType) TypeUtils.getImpliedType(recordRefType))
+                .getIntersectionType();
+        if (recordRefType.isReadOnly() && intersectionType.isPresent() && !map.getType().isReadOnly()) {
+            Type mutableType = ReadOnlyUtils.getMutableType((BIntersectionType) intersectionType.get());
+            return ValueCreator.createReadonlyRecordValue(mutableType.getPackage(), mutableType.getName(), valueMap);
+        }
         return ValueCreator.createRecordValue(recordRefType.getPackage(), recordRefType.getName(), valueMap);
     }
 
@@ -262,15 +273,28 @@ private static Object convertArray(BArray array, Type targetType, Type targetRef
     private static Object convertTable(BTable<?, ?> bTable, Type targetType,
                                        Type targetRefType, Set<TypeValuePair> unresolvedValues) {
         TableType tableType = (TableType) targetType;
+        Optional<IntersectionType> intersectionType = tableType.getIntersectionType();
+        if (targetRefType.isReadOnly() && intersectionType.isPresent() && !bTable.getType().isReadOnly()) {
+            tableType = (TableType) ReadOnlyUtils.getMutableType((BIntersectionType) intersectionType.get());
+            TableValueImpl<?, ?> tableValue = getTableValue(bTable, unresolvedValues, tableType, tableType);
+            tableValue.freezeDirect();
+            return tableValue;
+        }
+        return  getTableValue(bTable, unresolvedValues, tableType, targetRefType);
+    }
+
+    private static TableValueImpl<?, ?> getTableValue(BTable<?, ?> bTable, Set<TypeValuePair> unresolvedValues,
+                                                      TableType tableType, Type targetRefType) {
         Object[] tableValues = new Object[bTable.size()];
         int count = 0;
         for (Object tableValue : bTable.values()) {
             BMap<?, ?> bMap = (BMap<?, ?>) convert(tableValue, tableType.getConstrainedType(), unresolvedValues);
             tableValues[count++] = bMap;
         }
-        BArray data = ValueCreator.createArrayValue(tableValues,
-                TypeCreator.createArrayType(tableType.getConstrainedType()));
+        BArray data = ValueCreator.createArrayValue(tableValues, TypeCreator.createArrayType(
+                tableType.getConstrainedType()));
         BArray fieldNames = StringUtils.fromStringArray(tableType.getFieldNames());
-        return new TableValueImpl(targetRefType, (ArrayValue) data, (ArrayValue) fieldNames);
+        return new TableValueImpl<>(targetRefType, (ArrayValue) data, (ArrayValue) fieldNames);
     }
+
 }

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/ValueUtils.java

@@ -18,29 +18,44 @@
 package io.ballerina.runtime.internal;
 
 import io.ballerina.runtime.api.Module;
+import io.ballerina.runtime.api.async.StrandMetadata;
+import io.ballerina.runtime.api.creators.ErrorCreator;
 import io.ballerina.runtime.api.creators.TypeCreator;
 import io.ballerina.runtime.api.flags.SymbolFlags;
 import io.ballerina.runtime.api.types.Field;
+import io.ballerina.runtime.api.types.FunctionType;
 import io.ballerina.runtime.api.types.Type;
 import io.ballerina.runtime.api.utils.StringUtils;
+import io.ballerina.runtime.api.utils.TypeUtils;
 import io.ballerina.runtime.api.values.BError;
+import io.ballerina.runtime.api.values.BFunctionPointer;
 import io.ballerina.runtime.api.values.BMap;
 import io.ballerina.runtime.api.values.BObject;
 import io.ballerina.runtime.api.values.BString;
 import io.ballerina.runtime.api.values.BTypedesc;
 import io.ballerina.runtime.api.values.BValue;
 import io.ballerina.runtime.api.values.BXml;
+import io.ballerina.runtime.internal.scheduling.AsyncFunctionCallback;
 import io.ballerina.runtime.internal.scheduling.Scheduler;
 import io.ballerina.runtime.internal.scheduling.State;
 import io.ballerina.runtime.internal.scheduling.Strand;
 import io.ballerina.runtime.internal.types.BRecordType;
+import io.ballerina.runtime.internal.values.FutureValue;
 import io.ballerina.runtime.internal.values.MapValue;
 import io.ballerina.runtime.internal.values.MapValueImpl;
 import io.ballerina.runtime.internal.values.TypedescValueImpl;
 import io.ballerina.runtime.internal.values.ValueCreator;
 
+import java.io.PrintStream;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+import static io.ballerina.runtime.api.values.BError.ERROR_PRINT_PREFIX;
 
 /**
  * Class @{@link ValueUtils} provides utils to create Ballerina Values.
@@ -49,6 +64,8 @@
  */
 public class ValueUtils {
 
+    private static final PrintStream errStream = System.err;
+
     /**
      * Create a record value using the given package ID and record type name.
      *
@@ -57,19 +74,139 @@
      * @return               value of the record.
      */
     public static BMap<BString, Object> createRecordValue(Module packageId, String recordTypeName) {
+        return createRecordValue(packageId, recordTypeName, new HashSet<>());
+    }
+
+    public static BMap<BString, Object> createRecordValue(Module packageId, String recordTypeName,
+                                                          Set<String> providedFields) {
         ValueCreator valueCreator = ValueCreator.getValueCreator(ValueCreator.getLookupKey(packageId, false));
         try {
-            return valueCreator.createRecordValue(recordTypeName);
+            return getPopulatedRecordValue(valueCreator, recordTypeName, providedFields);
         } catch (BError e) {
             // If record type definition not found, get it from test module.
             String testLookupKey = ValueCreator.getLookupKey(packageId, true);
             if (ValueCreator.containsValueCreator(testLookupKey)) {
-                return ValueCreator.getValueCreator(testLookupKey).createRecordValue(recordTypeName);
+                return getPopulatedRecordValue(ValueCreator.getValueCreator(testLookupKey), recordTypeName,
+                        providedFields);
             }
             throw e;
         }
     }
 
+    private static BMap<BString, Object> getPopulatedRecordValue(ValueCreator valueCreator, String recordTypeName,
+                                                                 Set<String> providedFields) {
+        MapValue<BString, Object> recordValue = valueCreator.createRecordValue(recordTypeName);
+        BRecordType type = (BRecordType) TypeUtils.getImpliedType(recordValue.getType());
+        return populateDefaultValues(recordValue, type, providedFields);
+    }
+
+    public static BMap<BString, Object> populateDefaultValues(BMap<BString, Object> recordValue, BRecordType type,
+                                                              Set<String> providedFields) {
+        Map<String, BFunctionPointer<Object, ?>> defaultValues = type.getDefaultValues();
+        if (defaultValues.isEmpty()) {
+            return recordValue;
+        }
+        defaultValues = getNonProvidedDefaultValues(defaultValues, providedFields);
+        Strand strand = Scheduler.getStrandNoException();
+        if (strand == null) {
+            try {
+                final CountDownLatch latch = new CountDownLatch(defaultValues.size());
+                populateInitialValuesWithNoStrand(recordValue, latch, defaultValues);
+                latch.await();
+            } catch (InterruptedException e) {
+                throw ErrorCreator.createError(
+                        StringUtils.fromString("error occurred when populating default values"), e);
+            }
+        } else {
+            for (Map.Entry<String, BFunctionPointer<Object, ?>> field : defaultValues.entrySet()) {
+                recordValue.populateInitialValue(StringUtils.fromString(field.getKey()),
+                        field.getValue().call(new Object[]{strand}));
+            }
+        }
+        return recordValue;
+    }
+
+    private static Map<String, BFunctionPointer<Object, ?>> getNonProvidedDefaultValues(
+            Map<String, BFunctionPointer<Object, ?>> defaultValues, Set<String> providedFields) {
+        Map<String, BFunctionPointer<Object, ?>> result = new HashMap<>();
+        for (Map.Entry<String, BFunctionPointer<Object, ?>> entry : defaultValues.entrySet()) {
+            if (!providedFields.contains(entry.getKey())) {
+                result.put(entry.getKey(), entry.getValue());
+            }
+        }
+        return result;
+    }
+
+    private static void populateInitialValuesWithNoStrand(BMap<BString, Object> recordValue, CountDownLatch latch,
+                                                          Map<String, BFunctionPointer<Object, ?>> defaultValues) {
+        String[] fields = defaultValues.keySet().toArray(new String[0]);
+        invokeFPAsyncIterativelyWithNoStrand(recordValue, defaultValues, fields, "default",
+                Scheduler.getDaemonStrand().getMetadata(), defaultValues.size(), o -> {
+        }, Scheduler.getDaemonStrand().scheduler, latch);
+    }
+
+    public static void invokeFPAsyncIterativelyWithNoStrand(BMap<BString, Object> recordValue,
+                                                            Map<String, BFunctionPointer<Object, ?>> defaultValues,
+                                                            String[] fields, String strandName, StrandMetadata metadata,
+                                                            int noOfIterations, Consumer<Object> futureResultConsumer,
+                                                            Scheduler scheduler, CountDownLatch latch) {
+        if (noOfIterations <= 0) {
+            return;
+        }
+        AtomicInteger callCount = new AtomicInteger(0);
+        scheduleNextFunction(recordValue, defaultValues, fields, strandName, metadata, noOfIterations, callCount,
+                futureResultConsumer, scheduler, latch);
+    }
+
+    private static void scheduleNextFunction(BMap<BString, Object> recordValue,
+                                             Map<String, BFunctionPointer<Object, ?>> defaultValues, String[] fields,
+                                             String strandName, StrandMetadata metadata, int noOfIterations,
+                                             AtomicInteger callCount, Consumer<Object> futureResultConsumer,
+                                             Scheduler scheduler, CountDownLatch latch) {
+        BFunctionPointer<?, ?> func = defaultValues.get(fields[callCount.get()]);
+        Type retType = ((FunctionType) TypeUtils.getImpliedType(func.getType())).getReturnType();
+        FutureValue future = scheduler.createFuture(null, null, null, retType, strandName, metadata);
+        AsyncFunctionCallback callback = new AsyncFunctionCallback(null) {
+            @Override
+            public void notifySuccess(Object result) {
+                futureResultConsumer.accept(getFutureResult());
+                recordValue.populateInitialValue(StringUtils.fromString(fields[callCount.get()]), result);
+                int i = callCount.incrementAndGet();
+                latch.countDown();
+                if (i != noOfIterations) {
+                    scheduleNextFunction(recordValue, defaultValues, fields, strandName, metadata, noOfIterations,
+                            callCount, futureResultConsumer, scheduler, latch);
+                }
+            }
+
+            @Override
+            public void notifyFailure(BError error) {
+                errStream.println(ERROR_PRINT_PREFIX + error.getPrintableStackTrace());
+            }
+        };
+
+        invokeFunctionPointerAsync(func, retType, future, callback, scheduler, strandName, metadata);
+    }
+
+    private static void invokeFunctionPointerAsync(BFunctionPointer<?, ?> func, Type returnType, FutureValue future,
+                                                   AsyncFunctionCallback callback, Scheduler scheduler,
+                                                   String strandName, StrandMetadata metadata) {
+        future.callback = callback;
+        callback.setFuture(future);
+        AsyncFunctionCallback childCallback = new AsyncFunctionCallback(future.strand) {
+            @Override
+            public void notifySuccess(Object result) {
+                callback.notifySuccess(result);
+            }
+
+            @Override
+            public void notifyFailure(BError error) {
+                callback.notifyFailure(error);
+            }
+        };
+        scheduler.scheduleFunction(new Object[1], func, null, returnType, strandName, metadata, childCallback);
+    }
+
     /**
      * Create a record value that populates record fields using the given package ID, record type name and a map of
      * field names and associated values for the fields.
@@ -81,7 +218,7 @@
      */
     public static BMap<BString, Object> createRecordValue(Module packageId, String recordTypeName,
                                                           Map<String, Object> valueMap) {
-        BMap<BString, Object> recordValue = createRecordValue(packageId, recordTypeName);
+        BMap<BString, Object> recordValue = createRecordValue(packageId, recordTypeName, valueMap.keySet());
         for (Map.Entry<String, Object> fieldEntry : valueMap.entrySet()) {
             Object val = fieldEntry.getValue();
             // TODO: Remove the following String to BString conversion.
@@ -104,7 +241,11 @@
      */
     public static BMap<BString, Object> createRecordValue(Module packageId, String recordTypeName,
                                                           BMap<BString, Object> valueMap) {
-        BMap<BString, Object> recordValue = createRecordValue(packageId, recordTypeName);
+        Set<String> keySet = new HashSet<>();
+        for (BString key : valueMap.getKeys()) {
+            keySet.add(key.getValue());
+        }
+        BMap<BString, Object> recordValue = createRecordValue(packageId, recordTypeName, keySet);
         for (Map.Entry<BString, Object> fieldEntry : valueMap.entrySet()) {
             recordValue.populateInitialValue(fieldEntry.getKey(), fieldEntry.getValue());
         }
@@ -248,7 +389,7 @@
      * @param inherentType Inherent type of the value
      * @return     typedesc with the suitable type
      */
-    public static BTypedesc getTypedescValue(Boolean readOnly, BValue value, TypedescValueImpl inherentType) {
+    public static BTypedesc getTypedescValue(boolean readOnly, BValue value, TypedescValueImpl inherentType) {
         if (readOnly) {
             TypedescValueImpl typedesc = (TypedescValueImpl) createSingletonTypedesc(value);
             typedesc.annotations = inherentType.annotations;

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/cli/CliSpec.java

@@ -64,7 +64,7 @@ public Object[] getMainArgs() {
             mainArgs.add(optionLocation, recordVal);
         } else {
             RecordType type = TypeCreator.createRecordType("dummy", null, 1, new HashMap<>(), null, true, 6);
-            Option dummyOption = new Option(type, ValueCreator.createRecordValue(type));
+            Option dummyOption = new Option(type, 0);
             dummyOption.parseRecord(args);
             processOperands(dummyOption.getOperandArgs());
         }

bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/cli/Option.java

@@ -18,6 +18,7 @@
 
 package io.ballerina.runtime.internal.cli;
 
+import io.ballerina.runtime.api.Module;
 import io.ballerina.runtime.api.TypeTags;
 import io.ballerina.runtime.api.creators.ErrorCreator;
 import io.ballerina.runtime.api.creators.ValueCreator;
@@ -46,7 +47,7 @@
     private static final String NAMED_ARG_DELIMITER = "=";
 
     private final RecordType recordType;
-    private final BMap<BString, Object> recordVal;
+    private BMap<BString, Object> recordVal;
     private final List<String> operandArgs;
     private final Set<BString> recordKeysFound;
     private final int location;
@@ -55,23 +56,23 @@
     private static final Pattern HEX_LITERAL = Pattern.compile("[-+]?0[xX][\\dA-Fa-f.pP\\-+]+");
 
     public Option(Type recordType, int location) {
-        this((RecordType) getImpliedType(recordType),
-                ValueCreator.createRecordValue(recordType.getPackage(), recordType.getName()), location);
+        this((RecordType) getImpliedType(recordType), location);
     }
 
-    public Option(RecordType recordType, BMap<BString, Object> recordVal) {
-        this(recordType, recordVal, 0);
-    }
-
-    public Option(RecordType recordType, BMap<BString, Object> recordVal, int location) {
+    public Option(RecordType recordType, int location) {
         this.recordType = recordType;
-        this.recordVal = recordVal;
         operandArgs = new ArrayList<>();
         recordKeysFound = new HashSet<>();
         this.location = location;
     }
 
     public BMap<BString, Object> parseRecord(String[] args) {
+        Module packageId = recordType.getPackage();
+        if (packageId == null) {
+            this.recordVal = ValueCreator.createRecordValue(recordType);
+        } else {
+            this.recordVal = ValueCreator.createRecordValue(packageId, recordType.getName());
+        }
         int index = 0;
         while (index < args.length) {
             String arg = args[index++];