New Table implementation

.travis.yml

@@ -126,5 +126,6 @@ branches:
     - packerina-dev
     - next-release
     - release-stage
+    - new-table-impl
     - stage
     - /^ballerina-\d*[.]\d*[.]x$/

bvm/ballerina-core/src/main/java/org/ballerinalang/model/types/TypeTags.java

@@ -31,7 +31,8 @@ public class TypeTags {
     public static final int BOOLEAN_TAG = STRING_TAG + 1;
     public static final int JSON_TAG = BOOLEAN_TAG + 1;
     public static final int XML_TAG = JSON_TAG + 1;
-    public static final int NULL_TAG = XML_TAG + 1;
+    public static final int TABLE_TAG = XML_TAG + 1;
+    public static final int NULL_TAG = TABLE_TAG + 1;
     public static final int ANYDATA_TAG = NULL_TAG + 1;
     public static final int RECORD_TYPE_TAG = ANYDATA_TAG + 1;
     public static final int TYPEDESC_TAG = RECORD_TYPE_TAG + 1;

bvm/ballerina-rt/build.gradle

@@ -42,6 +42,7 @@ dependencies {
     dist project(path: ':ballerina-lang:map', configuration: 'birJar')
     dist project(path: ':ballerina-lang:object', configuration: 'birJar')
     dist project(path: ':ballerina-lang:stream', configuration: 'birJar')
+    dist project(path: ':ballerina-lang:table', configuration: 'birJar')
     dist project(path: ':ballerina-lang:string', configuration: 'birJar')
     dist project(path: ':ballerina-lang:typedesc', configuration: 'birJar')
     dist project(path: ':ballerina-lang:value', configuration: 'birJar')
@@ -62,6 +63,7 @@ dependencies {
     dist project(':ballerina-lang:map')
     dist project(':ballerina-lang:object')
     dist project(':ballerina-lang:stream')
+    dist project(':ballerina-lang:table')
     dist project(':ballerina-lang:string')
     dist project(':ballerina-lang:typedesc')
     dist project(':ballerina-lang:value')

bvm/ballerina-runtime/src/main/java/org/ballerinalang/jvm/TableUtils.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2020, 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 org.ballerinalang.jvm;
+
+import org.ballerinalang.jvm.types.BType;
+import org.ballerinalang.jvm.types.TypeTags;
+import org.ballerinalang.jvm.util.exceptions.BLangExceptionHelper;
+import org.ballerinalang.jvm.util.exceptions.BallerinaException;
+import org.ballerinalang.jvm.util.exceptions.RuntimeErrors;
+import org.ballerinalang.jvm.values.ArrayValue;
+import org.ballerinalang.jvm.values.IteratorValue;
+import org.ballerinalang.jvm.values.MapValue;
+import org.ballerinalang.jvm.values.RefValue;
+import org.ballerinalang.jvm.values.TableValue;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.ballerinalang.jvm.util.exceptions.BallerinaErrorReasons.CONSTRUCT_FROM_CYCLIC_VALUE_REFERENCE_ERROR;
+
+/**
+ * This class contains the utility methods required by the table implementation.
+ *
+ * @since 1.3.0
+ */
+
+public class TableUtils {
+
+    /**
+     * Generates a hash value which is same for the same shape.
+     *
+     * @param obj Ballerina value which the hash is generated from
+     * @param checkedValues List of already hashed objects
+     * @return The hash value
+     */
+    public static Integer hash(Object obj, List<Object> checkedValues) {
+        int result = 0;
+
+        if (checkedValues.contains(obj)) {
+            throw new BallerinaException(CONSTRUCT_FROM_CYCLIC_VALUE_REFERENCE_ERROR,
+                    BLangExceptionHelper.getErrorMessage(RuntimeErrors.CYCLIC_VALUE_REFERENCE,
+                            TypeChecker.getType(obj)));
+        }
+
+        checkedValues.add(obj);
+
+        if (obj instanceof RefValue) {
+            RefValue refValue = (RefValue) obj;
+            BType refType = refValue.getType();
+            if (refType.getTag() == TypeTags.MAP_TAG || refType.getTag() == TypeTags.RECORD_TYPE_TAG) {
+                MapValue mapValue = (MapValue) refValue;
+                for (Object entry : mapValue.entrySet()) {
+                    result = 31 * result + hash(((Map.Entry) entry).getKey(), checkedValues) +
+                            (((Map.Entry) entry).getValue() == null ? 0 : hash(((Map.Entry) entry).getValue(),
+                                    checkedValues));
+                }
+                return result;
+            } else if (refType.getTag() == TypeTags.ARRAY_TAG || refType.getTag() == TypeTags.TUPLE_TAG) {
+                ArrayValue arrayValue = (ArrayValue) refValue;
+                IteratorValue arrayIterator = arrayValue.getIterator();
+                while (arrayIterator.hasNext()) {
+                    result = 31 * result + hash(arrayIterator.next(), checkedValues);
+                }
+                return result;
+            } else {
+                return obj.hashCode();
+            }
+        } else {
+            return obj.hashCode();
+        }
+    }
+
+    /**
+     * Handles table insertion/store functionality.
+     *
+     * @param tableValue Table value which the values are inserted to
+     * @param key        The key associated with the value
+     * @param value      The value being inserted
+     */
+    public static void handleTableStore(TableValue<Object, Object> tableValue, Object key, Object value) {
+        tableValue.put(key, value);
+    }
+}

bvm/ballerina-runtime/src/main/java/org/ballerinalang/jvm/TypeChecker.java

@@ -33,6 +33,7 @@
 import org.ballerinalang.jvm.types.BPackage;
 import org.ballerinalang.jvm.types.BRecordType;
 import org.ballerinalang.jvm.types.BStreamType;
+import org.ballerinalang.jvm.types.BTableType;
 import org.ballerinalang.jvm.types.BTupleType;
 import org.ballerinalang.jvm.types.BType;
 import org.ballerinalang.jvm.types.BTypedescType;
@@ -626,6 +627,8 @@ private static boolean checkIsRecursiveType(BType sourceType, BType targetType,
                 return checkIsMapType(sourceType, (BMapType) targetType, unresolvedTypes);
             case TypeTags.STREAM_TAG:
                 return checkIsStreamType(sourceType, (BStreamType) targetType, unresolvedTypes);
+            case TypeTags.TABLE_TAG:
+                return checkIsTableType(sourceType, (BTableType) targetType, unresolvedTypes);
             case TypeTags.JSON_TAG:
                 return checkIsJSONType(sourceType, unresolvedTypes);
             case TypeTags.RECORD_TYPE_TAG:
@@ -695,12 +698,12 @@ private static boolean checkIsMapType(BType sourceType, BMapType targetType, Lis
         BType targetConstrainedType = targetType.getConstrainedType();
         switch (sourceType.getTag()) {
             case TypeTags.MAP_TAG:
-                return checkContraints(((BMapType) sourceType).getConstrainedType(), targetConstrainedType,
+                return checkConstraints(((BMapType) sourceType).getConstrainedType(), targetConstrainedType,
                         unresolvedTypes);
             case TypeTags.RECORD_TYPE_TAG:
                 BRecordType recType = (BRecordType) sourceType;
                 BUnionType wideTypeUnion = new BUnionType(getWideTypeComponents(recType));
-                return checkContraints(wideTypeUnion, targetConstrainedType, unresolvedTypes);
+                return checkConstraints(wideTypeUnion, targetConstrainedType, unresolvedTypes);
             default:
                 return false;
         }
@@ -741,10 +744,26 @@ private static boolean checkIsStreamType(BType sourceType, BStreamType targetTyp
         if (sourceType.getTag() != TypeTags.STREAM_TAG) {
             return false;
         }
-        return checkContraints(((BStreamType) sourceType).getConstrainedType(), targetType.getConstrainedType(),
+        return checkConstraints(((BStreamType) sourceType).getConstrainedType(), targetType.getConstrainedType(),
                                unresolvedTypes);
     }
 
+    private static boolean checkIsTableType(BType sourceType, BTableType targetType, List<TypePair> unresolvedTypes) {
+        if (sourceType.getTag() != TypeTags.TABLE_TAG) {
+            return false;
+        }
+        BTableType srcTableType  = (BTableType) sourceType;
+        boolean isTableType = checkConstraints(srcTableType.getConstrainedType(), targetType.getConstrainedType(),
+                unresolvedTypes);
+
+        String[] targetKeySpecifier = targetType.getFieldNames();
+        if (targetKeySpecifier == null || targetKeySpecifier.length == 0) {
+            return isTableType;
+        }
+
+        return isTableType && Arrays.equals(srcTableType.getFieldNames(), targetKeySpecifier);
+    }
+
     private static boolean checkIsJSONType(BType sourceType, List<TypePair> unresolvedTypes) {
         BJSONType jsonType = (BJSONType) BTypes.typeJSON;
 
@@ -987,7 +1006,7 @@ private static boolean checkIsFutureType(BType sourceType, BFutureType targetTyp
         if (sourceType.getTag() != TypeTags.FUTURE_TAG) {
             return false;
         }
-        return checkContraints(((BFutureType) sourceType).getConstrainedType(), targetType.getConstrainedType(),
+        return checkConstraints(((BFutureType) sourceType).getConstrainedType(), targetType.getConstrainedType(),
                 unresolvedTypes);
     }
 
@@ -1134,8 +1153,8 @@ private static boolean isReadonlyType(BType sourceType) {
         return false;
     }
 
-    private static boolean checkContraints(BType sourceConstraint, BType targetConstraint,
-                                           List<TypePair> unresolvedTypes) {
+    private static boolean checkConstraints(BType sourceConstraint, BType targetConstraint,
+                                            List<TypePair> unresolvedTypes) {
         if (sourceConstraint == null) {
             sourceConstraint = BTypes.typeAny;
         }

bvm/ballerina-runtime/src/main/java/org/ballerinalang/jvm/types/BTableType.java

@@ -0,0 +1,114 @@
+/*
+ *  Copyright (c) 2020, 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 org.ballerinalang.jvm.types;
+
+import org.ballerinalang.jvm.values.TableValue;
+
+/**
+ * {@code BTableType} represents tabular data in Ballerina.
+ *
+ * @since 1.3.0
+ */
+public class BTableType extends BType {
+
+    private BType constraint;
+    private BType keyType;
+    private String[] fieldNames;
+
+    public BTableType(BType constraint, String[] fieldNames) {
+        super(TypeConstants.TABLE_TNAME, null, TableValue.class);
+        this.constraint = constraint;
+        this.fieldNames = fieldNames;
+        this.keyType = null;
+    }
+
+    public BTableType(BType constraint) {
+        super(TypeConstants.TABLE_TNAME, null, TableValue.class);
+        this.constraint = constraint;
+    }
+
+    public BType getConstrainedType() {
+        return constraint;
+    }
+
+    public BType getKeyType() {
+        return keyType;
+    }
+
+    public String[] getFieldNames() {
+        return fieldNames;
+    }
+
+    @Override
+    public <V> V getZeroValue() {
+        return null;
+    }
+
+    @Override
+    public <V> V getEmptyValue() {
+        return null;
+    }
+
+    @Override
+    public int getTag() {
+        return TypeTags.TABLE_TAG;
+    }
+
+    @Override
+    public String toString() {
+        if (constraint == null) {
+            return super.toString();
+        }
+
+        StringBuilder keyStringBuilder = new StringBuilder();
+        if (fieldNames != null) {
+            for (String fieldName : fieldNames) {
+                if (!keyStringBuilder.toString().equals("")) {
+                    keyStringBuilder.append(", ");
+                }
+                keyStringBuilder.append(fieldName);
+            }
+            return super.toString() + "<" + constraint.getName() + "> key(" + keyStringBuilder.toString() + ")";
+        }
+
+        return super.toString() + "<" + constraint.getName() + "> " +
+                ((keyType != null) ? ("key<" + keyType + ">") : "");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!super.equals(obj) || !(obj instanceof BTableType)) {
+            return false;
+        }
+
+        BTableType other = (BTableType) obj;
+        if (constraint == other.constraint && keyType == other.keyType) {
+            return true;
+        }
+
+        if (constraint == null || other.constraint == null) {
+            return false;
+        }
+
+        if (keyType == null || other.keyType == null) {
+            return false;
+        }
+
+        return constraint.equals(other.constraint) && keyType.equals(other.keyType);
+    }
+}

bvm/ballerina-runtime/src/main/java/org/ballerinalang/jvm/types/TypeTags.java

@@ -31,7 +31,8 @@ public class TypeTags {
     public static final int BOOLEAN_TAG = STRING_TAG + 1;
     public static final int JSON_TAG = BOOLEAN_TAG + 1;
     public static final int XML_TAG = JSON_TAG + 1;
-    public static final int NULL_TAG = XML_TAG + 1;
+    public static final int TABLE_TAG = XML_TAG + 1;
+    public static final int NULL_TAG = TABLE_TAG + 1;
     public static final int ANYDATA_TAG = NULL_TAG + 1;
     public static final int RECORD_TYPE_TAG = ANYDATA_TAG + 1;
     public static final int TYPEDESC_TAG = RECORD_TYPE_TAG + 1;

bvm/ballerina-runtime/src/main/java/org/ballerinalang/jvm/util/exceptions/BallerinaErrorReasons.java

@@ -21,6 +21,7 @@
 import static org.ballerinalang.jvm.util.BLangConstants.FUTURE_LANG_LIB;
 import static org.ballerinalang.jvm.util.BLangConstants.MAP_LANG_LIB;
 import static org.ballerinalang.jvm.util.BLangConstants.STRING_LANG_LIB;
+import static org.ballerinalang.jvm.util.BLangConstants.TABLE_LANG_LIB;
 import static org.ballerinalang.jvm.util.BLangConstants.TYPEDESC_LANG_LIB;
 import static org.ballerinalang.jvm.util.BLangConstants.VALUE_LANG_LIB;
 import static org.ballerinalang.jvm.util.BLangConstants.XML_LANG_LIB;
@@ -78,6 +79,10 @@ public class BallerinaErrorReasons {
     public static final String XML_OPERATION_ERROR = getModulePrefixedReason(XML_LANG_LIB, "XMLOperationError");
     public static final String MAP_KEY_NOT_FOUND_ERROR = getModulePrefixedReason(MAP_LANG_LIB,
                                                                                  KEY_NOT_FOUND_ERROR_IDENTIFIER);
+    public static final String TABLE_KEY_NOT_FOUND_ERROR = getModulePrefixedReason(TABLE_LANG_LIB,
+            KEY_NOT_FOUND_ERROR_IDENTIFIER);
+    public static final String TABLE_HAS_A_VALUE_FOR_KEY_ERROR = getModulePrefixedReason(TABLE_LANG_LIB,
+            "KeyConstraintViolation");
     public static final String ILLEGAL_LIST_INSERTION_ERROR = getModulePrefixedReason(ARRAY_LANG_LIB,
                                                                                       "IllegalListInsertion");
     public static final String FUTURE_CANCELLED = getModulePrefixedReason(FUTURE_LANG_LIB, "FutureAlreadyCancelled");