diff --git a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ValueCreator.java b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ValueCreator.java
index 60d88c9cf7be..def52c8b6cec 100644
--- a/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ValueCreator.java
+++ b/bvm/ballerina-runtime/src/main/java/io/ballerina/runtime/internal/values/ValueCreator.java
@@ -17,6 +17,7 @@
  */
 package io.ballerina.runtime.internal.values;
 
+import io.ballerina.runtime.api.types.Type;
 import io.ballerina.runtime.api.values.BError;
 import io.ballerina.runtime.api.values.BObject;
 import io.ballerina.runtime.api.values.BString;
@@ -86,4 +87,7 @@ public abstract BObject createObjectValue(String objectTypeName, Scheduler sched
 
     public abstract BError createErrorValue(String errorTypeName, BString message, BError cause, Object details)
             throws BError;
+
+    public abstract Type getAnonType(int typeHash, String typeShape) throws BError;
+
 }
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmConstants.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmConstants.java
index f1c0403676af..11ed2e247785 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmConstants.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmConstants.java
@@ -303,6 +303,7 @@ public class JvmConstants {
     public static final String CREATE_RECORD_VALUE = "createRecordValue";
     public static final String CREATE_OBJECT_VALUE = "createObjectValue";
     public static final String CREATE_ERROR_VALUE = "createErrorValue";
+    public static final String GET_ANON_TYPE = "getAnonType";
 
     // strand data related constants
     public static final String STRAND = "strand";
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java
index a2f2146ce9fe..7228237aafe2 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmPackageGen.java
@@ -455,13 +455,14 @@ private void generateModuleClasses(BIRPackage module, Map<String, byte[]> jarEnt
             ClassWriter cw = new BallerinaClassWriter(COMPUTE_FRAMES);
             AsyncDataCollector asyncDataCollector = new AsyncDataCollector(moduleClass);
             boolean isInitClass = Objects.equals(moduleClass, moduleInitClass);
-            JvmTypeGen jvmTypeGen = new JvmTypeGen(stringConstantsGen);
+            JvmTypeGen jvmTypeGen = new JvmTypeGen(stringConstantsGen, module.packageID);
             JvmCastGen jvmCastGen = new JvmCastGen(symbolTable, jvmTypeGen);
             LambdaGen lambdaGen = new LambdaGen(this, jvmCastGen);
             if (isInitClass) {
                 cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, moduleClass, null, VALUE_CREATOR, null);
                 JvmCodeGenUtil.generateDefaultConstructor(cw, VALUE_CREATOR);
                 jvmTypeGen.generateUserDefinedTypeFields(cw, module.typeDefs);
+                jvmTypeGen.generateGetAnonTypeMethod(cw, module.typeDefs, moduleInitClass);
                 jvmTypeGen.generateValueCreatorMethods(cw, module.typeDefs, module.packageID, moduleInitClass,
                                                        symbolTable, asyncDataCollector);
                 // populate global variable to class name mapping and generate them
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmTypeGen.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmTypeGen.java
index c87cef4e3f16..102612fc57b1 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmTypeGen.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmTypeGen.java
@@ -29,8 +29,10 @@
 import org.wso2.ballerinalang.compiler.bir.codegen.internal.BIRVarToJVMIndexMap;
 import org.wso2.ballerinalang.compiler.bir.codegen.internal.ScheduleFunctionInfo;
 import org.wso2.ballerinalang.compiler.bir.model.BIRNode.BIRTypeDefinition;
+import org.wso2.ballerinalang.compiler.parser.BLangAnonymousModelHelper;
 import org.wso2.ballerinalang.compiler.semantics.analyzer.IsAnydataUniqueVisitor;
 import org.wso2.ballerinalang.compiler.semantics.analyzer.IsPureTypeUniqueVisitor;
+import org.wso2.ballerinalang.compiler.semantics.analyzer.TypeHashVisitor;
 import org.wso2.ballerinalang.compiler.semantics.model.SymbolTable;
 import org.wso2.ballerinalang.compiler.semantics.model.symbols.BAttachedFunction;
 import org.wso2.ballerinalang.compiler.semantics.model.symbols.BObjectTypeSymbol;
@@ -66,6 +68,7 @@
 import org.wso2.ballerinalang.util.Flags;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -91,6 +94,7 @@
 import static org.objectweb.asm.Opcodes.IFEQ;
 import static org.objectweb.asm.Opcodes.IFNE;
 import static org.objectweb.asm.Opcodes.IFNONNULL;
+import static org.objectweb.asm.Opcodes.ILOAD;
 import static org.objectweb.asm.Opcodes.INSTANCEOF;
 import static org.objectweb.asm.Opcodes.INVOKEINTERFACE;
 import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
@@ -133,6 +137,7 @@
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.FUNCTION_TYPE_IMPL;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.FUTURE_TYPE_IMPL;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.FUTURE_VALUE;
+import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.GET_ANON_TYPE;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.HANDLE_TYPE;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.HANDLE_VALUE;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.INTEGER_TYPE;
@@ -195,6 +200,7 @@
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.XML_TYPE_IMPL;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmConstants.XML_VALUE;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmValueGen.NAME_HASH_COMPARATOR;
+import static org.wso2.ballerinalang.compiler.bir.codegen.JvmValueGen.TYPE_HASH_COMPARATOR;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmValueGen.createDefaultCase;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmValueGen.getTypeDescClassName;
 import static org.wso2.ballerinalang.compiler.bir.codegen.JvmValueGen.getTypeValueClassName;
@@ -209,11 +215,15 @@ public class JvmTypeGen {
     private final IsPureTypeUniqueVisitor isPureTypeUniqueVisitor;
     private final IsAnydataUniqueVisitor isAnydataUniqueVisitor;
     private final JvmBStringConstantsGen stringConstantsGen;
+    private final TypeHashVisitor typeHashVisitor;
+    private final PackageID packageID;
 
-    public JvmTypeGen(JvmBStringConstantsGen stringConstantsGen) {
+    public JvmTypeGen(JvmBStringConstantsGen stringConstantsGen, PackageID packageID) {
         this.stringConstantsGen = stringConstantsGen;
+        this.packageID = packageID;
         isPureTypeUniqueVisitor = new IsPureTypeUniqueVisitor();
         isAnydataUniqueVisitor = new IsAnydataUniqueVisitor();
+        typeHashVisitor = new TypeHashVisitor();
     }
 
     /**
@@ -501,6 +511,75 @@ static List<Label> createLabelsForEqualCheck(MethodVisitor mv, int nameRegIndex,
         return targetLabels;
     }
 
+    // -------------------------------------------------------
+    //              getAnonType() generation methods
+    // -------------------------------------------------------
+
+    void generateGetAnonTypeMethod(ClassWriter cw, List<BIRTypeDefinition> typeDefinitions, String typeOwnerClass) {
+        MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, GET_ANON_TYPE,
+                String.format("(IL%s;)L%s;", STRING_VALUE, TYPE), null, null);
+        mv.visitCode();
+
+        int hashParamRegIndex = 1;
+        int shapeParamRegIndex = 2;
+        Label defaultCaseLabel = new Label();
+
+        // filter anon types and sorts them before generating switch case.
+        Set<BIRTypeDefinition> typeDefSet = new TreeSet<>(TYPE_HASH_COMPARATOR);
+        for (BIRTypeDefinition t : typeDefinitions) {
+            if (t.internalName.value.contains(BLangAnonymousModelHelper.ANON_PREFIX)
+                    || Symbols.isFlagOn(t.type.flags, Flags.ANONYMOUS)) {
+                typeDefSet.add(t);
+            }
+        }
+
+        Map<String, Label> labels = createLabelsForAnonTypeHashSwitch(mv, hashParamRegIndex,
+                typeDefSet, defaultCaseLabel);
+
+        for (Map.Entry<String, Label> labelEntry : labels.entrySet()) {
+            String fieldName = labelEntry.getKey();
+            Label targetLabel = labelEntry.getValue();
+            mv.visitLabel(targetLabel);
+            mv.visitFieldInsn(GETSTATIC, typeOwnerClass, fieldName, String.format("L%s;", TYPE));
+            mv.visitInsn(ARETURN);
+        }
+
+        createDefaultCase(mv, defaultCaseLabel, shapeParamRegIndex, "No such type: ");
+        mv.visitMaxs(typeDefSet.size() + 10, typeDefSet.size() + 10);
+        mv.visitEnd();
+    }
+
+    private Map<String, Label> createLabelsForAnonTypeHashSwitch(MethodVisitor mv,
+                                                                 int nameRegIndex,
+                                                                 Set<BIRTypeDefinition> nodes,
+                                                                 Label defaultCaseLabel) {
+        mv.visitVarInsn(ILOAD, nameRegIndex);
+        // Create labels for the cases
+        Map<String, Label> labelFieldMapping = new LinkedHashMap<>();
+        Map<Integer, Label> labelHashMapping = new LinkedHashMap<>();
+        for (BIRTypeDefinition node : nodes) {
+            if (node != null) {
+                BType type = node.type;
+                String fieldName = getTypeFieldName(node.internalName.value);
+                Integer typeHash = typeHashVisitor.visit(type);
+                boolean fieldExists = labelFieldMapping.containsKey(fieldName);
+                boolean hashExists = labelHashMapping.containsKey(typeHash);
+                if (!fieldExists && !hashExists) {
+                    Label label = new Label();
+                    labelFieldMapping.put(fieldName, label);
+                    labelHashMapping.put(typeHash, label);
+                } else {
+                    assert fieldExists && hashExists; // hashing issues.
+                }
+                typeHashVisitor.reset();
+            }
+        }
+        int[] hashes = labelHashMapping.keySet().stream().mapToInt(Integer::intValue).toArray();
+        Label[] labels = labelHashMapping.values().toArray(new Label[0]);
+        mv.visitLookupSwitchInsn(defaultCaseLabel, hashes, labels);
+        return labelFieldMapping;
+    }
+
     // -------------------------------------------------------
     //              Runtime value creation methods
     // -------------------------------------------------------
@@ -1856,13 +1935,31 @@ private void loadTupleType(MethodVisitor mv, BTupleType bType) {
      * @param bType user defined type
      */
     private void loadUserDefinedType(MethodVisitor mv, BType bType) {
+        BTypeSymbol typeSymbol = bType.tsymbol.isTypeParamResolved ? bType.tsymbol.typeParamTSymbol : bType.tsymbol;
+        BType typeToLoad = bType.tsymbol.isTypeParamResolved ? typeSymbol.type : bType;
+        PackageID packageID = typeSymbol.pkgID;
+        String typeOwner = JvmCodeGenUtil.getPackageName(packageID) + MODULE_INIT_CLASS_NAME;
+        String fieldName = getTypeFieldName(toNameString(typeToLoad));
 
-        PackageID packageID = bType.tsymbol.pkgID;
+        // if name contains $anon and doesn't belong to the same package, load type using getAnonType() method.
+        if (!this.packageID.equals(packageID) &&
+                (fieldName.contains(BLangAnonymousModelHelper.ANON_PREFIX)
+                        || Symbols.isFlagOn(typeToLoad.flags, Flags.ANONYMOUS))) {
+            Integer hash = typeHashVisitor.visit(typeToLoad);
+            String shape = typeToLoad.toString();
+            typeHashVisitor.reset();
 
-        String typeOwner = JvmCodeGenUtil.getPackageName(packageID) + MODULE_INIT_CLASS_NAME;
-        String fieldName = getTypeFieldName(toNameString(bType));
+            mv.visitTypeInsn(NEW, typeOwner);
+            mv.visitInsn(DUP);
+            mv.visitMethodInsn(INVOKESPECIAL, typeOwner, JVM_INIT_METHOD, "()V", false);
 
-        mv.visitFieldInsn(GETSTATIC, typeOwner, fieldName, String.format("L%s;", TYPE));
+            mv.visitLdcInsn(hash);
+            mv.visitLdcInsn(String.format("Package: %s, TypeName: %s, Shape: %s", typeOwner, fieldName, shape));
+            mv.visitMethodInsn(INVOKEVIRTUAL, typeOwner, GET_ANON_TYPE,
+                    String.format("(IL%s;)L%s;", STRING_VALUE, TYPE), false);
+        } else {
+            mv.visitFieldInsn(GETSTATIC, typeOwner, fieldName, String.format("L%s;", TYPE));
+        }
     }
 
     /**
@@ -1871,7 +1968,7 @@ private void loadUserDefinedType(MethodVisitor mv, BType bType) {
      * @param typeName type name
      * @return name of the field that holds the type instance
      */
-    private String getTypeFieldName(String typeName) {
+    private static String getTypeFieldName(String typeName) {
 
         return String.format("$type$%s", typeName);
     }
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmValueGen.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmValueGen.java
index 12f3fe0e4182..04eaebb5b7da 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmValueGen.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/JvmValueGen.java
@@ -27,6 +27,7 @@
 import org.wso2.ballerinalang.compiler.bir.codegen.internal.AsyncDataCollector;
 import org.wso2.ballerinalang.compiler.bir.codegen.internal.FieldNameHashComparator;
 import org.wso2.ballerinalang.compiler.bir.codegen.internal.NameHashComparator;
+import org.wso2.ballerinalang.compiler.bir.codegen.internal.TypeHashComparator;
 import org.wso2.ballerinalang.compiler.bir.codegen.interop.BIRFunctionWrapper;
 import org.wso2.ballerinalang.compiler.bir.codegen.interop.ExternalMethodGen;
 import org.wso2.ballerinalang.compiler.bir.codegen.interop.JFieldBIRFunction;
@@ -144,6 +145,7 @@ class JvmValueGen {
 
     static final FieldNameHashComparator FIELD_NAME_HASH_COMPARATOR = new FieldNameHashComparator();
     static final NameHashComparator NAME_HASH_COMPARATOR = new NameHashComparator();
+    static final TypeHashComparator TYPE_HASH_COMPARATOR = new TypeHashComparator();
     static final String ENCODED_RECORD_INIT =
             IdentifierUtils.encodeFunctionIdentifier(Names.INIT_FUNCTION_SUFFIX.value);
     private final BIRNode.BIRPackage module;
@@ -668,7 +670,7 @@ private byte[] createRecordValueClass(BRecordType recordType, String className,
         } else {
             cw.visitSource(className, null);
         }
-        JvmTypeGen jvmTypeGen =  new JvmTypeGen(stringConstantsGen);
+        JvmTypeGen jvmTypeGen = new JvmTypeGen(stringConstantsGen, module.packageID);
         JvmCastGen jvmCastGen = new JvmCastGen(jvmPackageGen.symbolTable, jvmTypeGen);
         LambdaGen lambdaGen = new LambdaGen(jvmPackageGen, jvmCastGen);
         cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, className,
@@ -1383,7 +1385,7 @@ private byte[] createObjectValueClass(BObjectType objectType, String className,
         ClassWriter cw = new BallerinaClassWriter(COMPUTE_FRAMES);
         cw.visitSource(typeDef.pos.lineRange().filePath(), null);
 
-        JvmTypeGen jvmTypeGen = new JvmTypeGen(stringConstantsGen);
+        JvmTypeGen jvmTypeGen = new JvmTypeGen(stringConstantsGen, module.packageID);
         JvmCastGen jvmCastGen = new JvmCastGen(jvmPackageGen.symbolTable, jvmTypeGen);
         LambdaGen lambdaGen =  new LambdaGen(jvmPackageGen, jvmCastGen);
         cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, className, null, ABSTRACT_OBJECT_VALUE, new String[]{B_OBJECT});
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/internal/TypeHashComparator.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/internal/TypeHashComparator.java
new file mode 100644
index 000000000000..46e004e2c253
--- /dev/null
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/internal/TypeHashComparator.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2021, 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.wso2.ballerinalang.compiler.bir.codegen.internal;
+
+import org.wso2.ballerinalang.compiler.bir.model.BIRNode.BIRTypeDefinition;
+import org.wso2.ballerinalang.compiler.semantics.analyzer.TypeHashVisitor;
+
+import java.util.Comparator;
+
+/**
+ * BType hash comparator to sort BIRTypeDefinitions according its type hash code.
+ *
+ * @since 2.0.0
+ */
+public class TypeHashComparator implements Comparator<BIRTypeDefinition> {
+
+    private final TypeHashVisitor typeHashVisitor = new TypeHashVisitor();
+
+    @Override
+    public int compare(BIRTypeDefinition o1, BIRTypeDefinition o2) {
+        Integer o1TypeHash = typeHashVisitor.visit(o1.type);
+        typeHashVisitor.reset();
+        Integer o2TypeHash = typeHashVisitor.visit(o2.type);
+        typeHashVisitor.reset();
+        return Integer.compare(o1TypeHash, o2TypeHash);
+    }
+}
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/methodgen/ConfigMethodGen.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/methodgen/ConfigMethodGen.java
index a3c72df0a936..27da36cfdcf5 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/methodgen/ConfigMethodGen.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/bir/codegen/methodgen/ConfigMethodGen.java
@@ -97,7 +97,7 @@ public void generateConfigMapper(List<PackageID> imprtMods, BIRNode.BIRPackage p
         mv.visitEnd();
 
         generateConfigInit(cw, moduleInitClass, imprtMods, pkg.packageID);
-        populateConfigDataMethod(cw, moduleInitClass, pkg, new JvmTypeGen(stringConstantsGen));
+        populateConfigDataMethod(cw, moduleInitClass, pkg, new JvmTypeGen(stringConstantsGen, pkg.packageID));
         cw.visitEnd();
         jarEntries.put(innerClassName + ".class", cw.toByteArray());
     }
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/parser/BLangAnonymousModelHelper.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/parser/BLangAnonymousModelHelper.java
index 6163585da7c5..b24b68b13cb4 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/parser/BLangAnonymousModelHelper.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/parser/BLangAnonymousModelHelper.java
@@ -47,17 +47,18 @@ public class BLangAnonymousModelHelper {
     private Map<PackageID, Integer> intersectionRecordCount;
     private Map<PackageID, Integer> intersectionErrorCount;
 
-    private static final String ANON_TYPE = "$anonType$";
+    public static final String ANON_PREFIX = "$anon";
+    private static final String ANON_TYPE = ANON_PREFIX + "Type$";
     public static final String LAMBDA = "$lambda$";
     private static final String SERVICE = "$$service$";
-    private static final String ANON_SERVICE = "$anonService$";
-    private static final String BUILTIN_ANON_TYPE = "$anonType$builtin$";
+    private static final String ANON_SERVICE = ANON_PREFIX + "Service$";
+    private static final String BUILTIN_ANON_TYPE = ANON_PREFIX + "Type$builtin$";
     private static final String BUILTIN_LAMBDA = "$lambda$builtin$";
     private static final String FORK = "$fork$";
-    private static final String ANON_TYPE_ID = "$anonTypeid$";
+    private static final String ANON_TYPE_ID = ANON_PREFIX + "Typeid$";
     private static final String RAW_TEMPLATE_TYPE = "$rawTemplate$";
-    private static final String ANON_INTERSECTION_RECORD = "$anonIntersectionRecordType$";
-    private static final String ANON_INTERSECTION_ERROR_TYPE = "$anonIntersectionErrorType$";
+    private static final String ANON_INTERSECTION_RECORD = ANON_PREFIX + "IntersectionRecordType$";
+    private static final String ANON_INTERSECTION_ERROR_TYPE = ANON_PREFIX + "IntersectionErrorType$";
     private static final String TUPLE_VAR = "$tupleVar$";
     private static final String RECORD_VAR = "$recordVar$";
     private static final String ERROR_VAR = "$errorVar$";
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeHashVisitor.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeHashVisitor.java
new file mode 100644
index 000000000000..28f89e734cfb
--- /dev/null
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeHashVisitor.java
@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 2021, 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.wso2.ballerinalang.compiler.semantics.analyzer;
+
+import org.wso2.ballerinalang.compiler.semantics.model.UniqueTypeVisitor;
+import org.wso2.ballerinalang.compiler.semantics.model.symbols.BAttachedFunction;
+import org.wso2.ballerinalang.compiler.semantics.model.symbols.BObjectTypeSymbol;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BAnnotationType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BAnyType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BAnydataType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BArrayType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BBuiltInRefType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BErrorType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BField;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BFiniteType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BFutureType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BHandleType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BIntSubType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BIntersectionType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BInvokableType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BJSONType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BMapType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BNeverType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BNilType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BNoType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BObjectType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BPackageType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BParameterizedType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BReadonlyType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BRecordType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BStreamType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BStructureType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BTableType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BTupleType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BTypedescType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BUnionType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BXMLSubType;
+import org.wso2.ballerinalang.compiler.semantics.model.types.BXMLType;
+import org.wso2.ballerinalang.compiler.util.Names;
+import org.wso2.ballerinalang.compiler.util.TypeTags;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Stack;
+import java.util.stream.Collectors;
+
+import static java.util.Objects.hash;
+
+/**
+ * BType hash visitor to visit and generate a hash code for a given BType.
+ *
+ * @since 2.0.0
+ */
+public class TypeHashVisitor implements UniqueTypeVisitor<Integer> {
+    private Map<BType, Integer> visited;
+    private Map<Integer, Integer> generated;
+    private Stack<BType> visiting;
+
+    public TypeHashVisitor() {
+        visited = new HashMap<>();
+        generated = new HashMap<>();
+        visiting = new Stack<>();
+    }
+
+    @Override
+    public boolean isVisited(BType type) {
+        return visited.containsKey(type);
+    }
+
+    @Override
+    public void reset() {
+        visiting.clear();
+        visited.clear();
+        generated.clear();
+    }
+
+    @Override
+    public Integer visit(BType type) {
+        if (type == null) {
+            return 0;
+        }
+
+        switch (type.tag) {
+            case TypeTags.ANY:
+                return visit((BAnyType) type);
+            case TypeTags.NIL:
+                return visit((BNilType) type);
+            case TypeTags.NEVER:
+                return visit((BNeverType) type);
+            case TypeTags.ANYDATA:
+                return visit((BAnydataType) type);
+            case TypeTags.ANNOTATION:
+                return visit((BAnnotationType) type);
+            case TypeTags.RECORD:
+                return visit((BRecordType) type);
+            case TypeTags.ERROR:
+                return visit((BErrorType) type);
+            case TypeTags.OBJECT:
+                return visit((BObjectType) type);
+            case TypeTags.ARRAY:
+                return visit((BArrayType) type);
+            case TypeTags.UNION:
+                return visit((BUnionType) type);
+            case TypeTags.TYPEDESC:
+                return visit((BTypedescType) type);
+            case TypeTags.MAP:
+                return visit((BMapType) type);
+            case TypeTags.FINITE:
+                return visit((BFiniteType) type);
+            case TypeTags.TUPLE:
+                return visit((BTupleType) type);
+            case TypeTags.TABLE:
+                return visit((BTableType) type);
+            case TypeTags.STREAM:
+                return visit((BStreamType) type);
+            case TypeTags.INTERSECTION:
+                return visit((BIntersectionType) type);
+            case TypeTags.READONLY:
+                return visit((BReadonlyType) type);
+            case TypeTags.PARAMETERIZED_TYPE:
+                return visit((BParameterizedType) type);
+            case TypeTags.SIGNED8_INT:
+            case TypeTags.SIGNED16_INT:
+            case TypeTags.SIGNED32_INT:
+            case TypeTags.UNSIGNED8_INT:
+            case TypeTags.UNSIGNED16_INT:
+            case TypeTags.UNSIGNED32_INT:
+                return visit((BIntSubType) type);
+            case TypeTags.XML:
+                return visit((BXMLType) type);
+            case TypeTags.XML_ELEMENT:
+            case TypeTags.XML_PI:
+            case TypeTags.XML_COMMENT:
+            case TypeTags.XML_TEXT:
+                return visit((BXMLSubType) type);
+            case TypeTags.NONE:
+                return 0;
+            default: {
+                if (isVisited(type)) {
+                    return visited.get(type);
+                }
+
+                if (isCyclic(type)) {
+                    return 0;
+                }
+
+                return addToVisited(type, baseHash(type));
+            }
+        }
+    }
+
+    @Override
+    public Integer visit(BAnnotationType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BArrayType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.size, type.state.getValue(), visit(type.eType));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BBuiltInRefType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BAnyType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BFutureType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.constraint));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BHandleType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BMapType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.constraint));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BStreamType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.constraint), visit(type.error));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BTypedescType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.constraint));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BXMLType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.constraint));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BAnydataType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BErrorType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.typeIdSet, visit(type.detailType));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BInvokableType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> paramTypesHashes = getTypesHashes(type.paramTypes);
+        Integer hash = hash(baseHash(type), paramTypesHashes, visit(type.restType), visit(type.retType));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BJSONType type) {
+        return visit((BUnionType) type);
+    }
+
+    @Override
+    public Integer visit(BParameterizedType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.paramIndex, visit(type.paramValueType));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BNeverType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), Names.NEVER.value);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BNilType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), Names.NIL_VALUE.value);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BNoType type) {
+        return 0;
+    }
+
+    @Override
+    public Integer visit(BPackageType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.getKind().typeName());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BTupleType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> tupleTypesHashes = getTypesHashes(type.getTupleTypes());
+        Integer hash = hash(baseHash(type), tupleTypesHashes, visit(type.restType));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BIntersectionType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), visit(type.effectiveType), getTypesHashes(type.getConstituentTypes()));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BTableType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.fieldNameList,
+                visit(type.constraint), visit(type.keyTypeConstraint));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BFiniteType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> valueSpaceHashes = type.getValueSpace().stream().map(Object::toString)
+                .sorted().map(String::hashCode).collect(Collectors.toList());
+        Integer hash = hash(baseHash(type), type.isAnyData, valueSpaceHashes);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BStructureType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> fieldsHashes = getFieldsHashes(type.fields);
+        List<Integer> typeInclHashes = getTypesHashes(type.typeInclusions);
+        Integer hash = hash(baseHash(type), fieldsHashes, typeInclHashes);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BObjectType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> fieldsHashes = getFieldsHashes(type.fields);
+        List<Integer> typeInclHashes = getTypesHashes(type.typeInclusions);
+        final int initFunctionHash = getFunctionHash(((BObjectTypeSymbol) type.tsymbol).initializerFunc);
+        List<Integer> attachedFunctionsHashes = getFunctionsHashes(((BObjectTypeSymbol) type.tsymbol).attachedFuncs);
+        Integer hash = hash(baseHash(type), fieldsHashes, typeInclHashes, initFunctionHash,
+                attachedFunctionsHashes, type.typeIdSet);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BRecordType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        List<Integer> fieldsHashes = getFieldsHashes(type.fields);
+        List<Integer> typeInclHashes = getTypesHashes(type.typeInclusions);
+        Integer hash = hash(baseHash(type), type.sealed, fieldsHashes,
+                visit(type.restFieldType), typeInclHashes);
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BUnionType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), type.isAnyData, type.isPureType, type.isCyclic,
+                getTypesHashes(type.getMemberTypes()));
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BIntSubType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), Names.INT.value, type.name.getValue());
+        return addToVisited(type, hash);
+    }
+
+    @Override
+    public Integer visit(BXMLSubType type) {
+        if (isVisited(type)) {
+            return visited.get(type);
+        }
+        if (isCyclic(type)) {
+            return 0;
+        }
+        Integer hash = hash(baseHash(type), Names.XML.value, type.name.getValue());
+        return addToVisited(type, hash);
+    }
+
+    private boolean isCyclic(BType type) {
+        if (visiting.contains(type)) {
+            return true;
+        }
+        visiting.push(type);
+        return false;
+    }
+
+    private Integer addToVisited(BType type, Integer hash) {
+        Integer existing = Optional.ofNullable(generated.get(hash)).orElse(0);
+
+        generated.put(hash, existing + 1);
+        if (existing > 0 && !visited.containsKey(type)) {
+            hash += existing;
+        }
+        assert visiting.pop() == type;
+        visited.put(type, hash);
+        return hash;
+    }
+
+    private Integer baseHash(BType type) {
+        return hash(type.tag, type.flags, type.isNullable());
+    }
+
+    private List<Integer> getTypesHashes(Collection<BType> types) {
+        return types.stream().map(this::visit)
+                .sorted(Comparator.comparingInt(Integer::intValue))
+                .collect(Collectors.toList());
+    }
+
+    private List<Integer> getFieldsHashes(Map<String, BField> fields) {
+        return fields.values().stream()
+                .map(f -> hash(f.name.value, f.symbol != null ? f.symbol.flags : null, visit(f.type)))
+                .sorted(Comparator.comparingInt(Integer::intValue))
+                .collect(Collectors.toList());
+    }
+
+    private List<Integer> getFunctionsHashes(List<BAttachedFunction> attachedFunctions) {
+        return attachedFunctions.stream()
+                .map(this::getFunctionHash)
+                .sorted(Comparator.comparingInt(Integer::intValue))
+                .collect(Collectors.toList());
+    }
+
+    private int getFunctionHash(BAttachedFunction attachedFunction) {
+        if (attachedFunction == null) {
+            return 0;
+        }
+        return hash(attachedFunction.funcName.value,
+                attachedFunction.symbol != null ? attachedFunction.symbol.flags : null, visit(attachedFunction.type));
+    }
+
+}
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeParamAnalyzer.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeParamAnalyzer.java
index aa8fa8f0f463..6e2be1dc77af 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeParamAnalyzer.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/analyzer/TypeParamAnalyzer.java
@@ -760,6 +760,8 @@ private BRecordType getMatchingRecordBoundType(BRecordType expType, SymbolEnv en
                                                                     expTSymbol.pkgID, null,
                                                                     expType.tsymbol.scope.owner, expTSymbol.pos,
                                                                     VIRTUAL);
+        recordSymbol.isTypeParamResolved = true;
+        recordSymbol.typeParamTSymbol = expTSymbol;
         recordSymbol.scope = new Scope(recordSymbol);
         recordSymbol.initializerFunc = expTSymbol.initializerFunc;
 
@@ -802,6 +804,8 @@ private BInvokableType getMatchingFunctionBoundType(BInvokableType expType, Symb
                                                                                             expType.tsymbol.pos,
                                                                                             VIRTUAL));
 
+        invokableType.tsymbol.isTypeParamResolved = true;
+        invokableType.tsymbol.typeParamTSymbol = expType.tsymbol;
         if (Symbols.isFlagOn(flags, Flags.ISOLATED)) {
             invokableType.flags |= Flags.ISOLATED;
         }
@@ -815,6 +819,9 @@ private BType getMatchingObjectBoundType(BObjectType expType, SymbolEnv env, Has
                                                                        expType.tsymbol.name, expType.tsymbol.pkgID,
                                                                        null, expType.tsymbol.scope.owner,
                                                                        expType.tsymbol.pos, VIRTUAL);
+        actObjectSymbol.isTypeParamResolved = true;
+        actObjectSymbol.typeParamTSymbol = expType.tsymbol;
+
         BObjectType objectType = new BObjectType(actObjectSymbol);
         actObjectSymbol.type = objectType;
         actObjectSymbol.scope = new Scope(actObjectSymbol);
@@ -875,6 +882,8 @@ private BType getMatchingErrorBoundType(BErrorType expType, SymbolEnv env, HashS
                                                            symTable.errorType.tsymbol.name,
                                                            symTable.errorType.tsymbol.pkgID,
                                                            null, null, symTable.builtinPos, VIRTUAL);
+        typeSymbol.isTypeParamResolved = true;
+        typeSymbol.typeParamTSymbol = expType.tsymbol;
         BErrorType errorType = new BErrorType(typeSymbol, detailType);
         typeSymbol.type = errorType;
         return errorType;
diff --git a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/symbols/BTypeSymbol.java b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/symbols/BTypeSymbol.java
index 14691599309b..5fe193c931a6 100644
--- a/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/symbols/BTypeSymbol.java
+++ b/compiler/ballerina-lang/src/main/java/org/wso2/ballerinalang/compiler/semantics/model/symbols/BTypeSymbol.java
@@ -31,6 +31,8 @@
 public class BTypeSymbol extends BSymbol implements TypeSymbol {
 
     public boolean isLabel;
+    public boolean isTypeParamResolved;
+    public BTypeSymbol typeParamTSymbol;
 
     public BTypeSymbol(int symTag, long flags, Name name, PackageID pkgID, BType type, BSymbol owner,
                        Location pos, SymbolOrigin origin) {