Create identifiers for anonymous types

[KavinduZoysa]

Introduction

According to the current implementation, anonymous types are named using the format $anonType$_x where x is an integer. x is just an incrementing value. Because of this naming format, we have to face some issues as mentioned below.

Original problem

The original problem can be explained using an example. Let’s say we are representing an anonymous type using $anonType$_1 in langlib Lib. Also, we have a module Mod, which uses Lib. We have built Mod on language version v1 which is an older version. Assume that there is a cast to $anonType$_1 in Mod. Now we build Lib in language version v2 which is a new version. In new Lib, $anonType$_1 points to a different anonymous type. Still, Mod is built on v1. Therefore we can see a runtime cast error.

Current solutions

In runtime

Generate a hash for each type based on its shape. Create a lookup method called getAnonType which accepts a hash and returns a type. This method can be found in module init. When an anonymous type that is defined in Mod1 is used in a different module Mod2, generate the hash and get the anonymous type using Mod1.getAnonType method. Please check #29792

In compile time

Let's say, there is an anonymous type $anonType$_0 which is defined in Mod1 and there is a reference to $anonType$_0 from Mod2.
Initially, both modules are built on older version v1. Now, Mod1 is built on newer version v2 and $anonType$_0 does not represent the previous type. When the symbols are entered in BIRPackageSymbolEnter for Mod2, it is unable to lookup the correct type for $anonType$_0 from Mod1.

In order to solve this problem, a method called getType was introduced in BIRTypeReader. This method reads the type from the byte stream and looks up the corresponding type from Mod2 and checks whether those shapes are the same. Please check #35870.

Use of anonymous types

Anonymous types are used to create a type node when the type name is not specified. The current format of anonymous type names is $anonType$_x (x is an integer which increases by 1). At runtime there is a class for each anonymous type.

Anonymous types creation

Anonymous types are created when the type is not defined explicitly. Please check the following examples.

1. Return type of a function

function bar() returns record {| int i; |} {
      return { i: 2 };
}

An anonymous type is created for record {| int i; |}.

2. Field of a record

public type Person record {
    	string name;
    	int age;
    	record {
        	string city;
        	string country;
    	} address;
};

An anonymous type is created for the type of address.

3. Local variable

record { int i; string s; } rec = { i: 2, s: "str" };

An anonymous type is created for the type of rec.

4. Type cast

type REC record {
    	int i;
    	string s;
};

function foo() returns REC? {
    	return;
}

public function main() returns error? {
    	_ = <record { int i; string s; }>foo();
    	_ = <record { int i; string s; }>foo();
}

Four anonymous types are created for each type cast.

5. Const declaration

const map<int> XX = { i: 2 };

An anonymous type is created for type of XX.

6. Module variable declaration

record { int i; string s; } rec;

function init() {
    	rec = { i: 2, s: "" };
}

An anonymous type is created for rec.

7. var declaration

	var _ = { i: 2 };

An anonymous type is created for the mapping value { i: 2 }.

8. Enum

enum ENUM {
 	RED,
        GREEN
}

Two anonymous types are created for two enum members.

Goal

The ultimate goal is to create anonymous types to be able to uniquely identify them.

Approach

Create the name of the anonymous type based on the place where it located.
Let's go through the each case that mentioned in Anonymous types creation.

Case 1

function bar() returns record {| int i; |} {
    	return { i: 2 };
}

Since the anonymous type created for the return type of function we can create the name of anonymous type like $anonType$FUNC_RETURN$foo$.

Case 2

public type Person record {
    	string name;
    	int age;
    	record {
        	string city;
        	string country;
    	} address;
};

The anonymous type of address can be created with a name like $anonType$FIELD$address$Person$.

Case 3

record { int i; string s; } rec = { i: 2, s: "str" };

The name of the anonymous type can be created using the local variable. But if the local variable is a wildcard, it cannot be used to create anonymous type name because the same statement can be repeated several times with a single block. Since the local variable are not referred outside it’s scope, it is not need to uniquely identify this anonymous type. Therefore a name like $anonType$x can be used. (x is an integer)

Case 4

This is same as Case 3.

Case 5

const map<int> XX = { i: 2 };

The anonymous type of XX can be created with a name like $anonType$CONST$XX$.

Case 6

record { int i; string s; } rec;

function init() {
         rec = { i: 2, s: "" };
}

The anonymous type of rec can be created with a name like $anonType$MODULE_VAR$rec$.

Case 7

var _ = { i: 2 };

This is same as Case 3.

Case 8

enum ENUM {
 	RED,
        GREEN
}

The two anonymous types for RED and GREEN can be created with names like $anonType$ENUM$RED$ and $anonType$ENUM$GREEN$.

Note: The org name and module name can be appended additionally.

[KavinduZoysa]

When creating identifiers for anonymous types, it is useless to have the type of node. i.e. CONSTANT, ENUM, MODULE_VAR etc.
The reason is that we try to create identifiers based on public nodes and those cannot be duplicated.
For example, if we have const map<int> XX = { i: 2 };, we can create identifier as $anonType$XX$ instead of $anonType$CONST$XX$, because we cannot define any other node with name XX. So CONSTANT is not mandatory suffix.

So when implementing this my plan is to create a stack and push relevant suffixes. We should start this from a public node identifier.

[rdulmina]

Enum members can be duplicated with the same name. But IIRC we create only one const for those kinds of enum members henc, it will not be an issue. Please check this.

enum enumName {
    A
}

enum enumName2 {
    A
}

[KavinduZoysa]

The identifier for A is associated with name of enum (i.e. enumName and enumName2). Therefore even if there are the same enum members, anonymous type names will not be duplicated.

[KRVPerera]

I think we need to improve case 3 and case 7 right. They have the same existing logic. imagine what happens if these are inside a loop. Can we still identify them uniquely?

foreach int i in 0 ... 9 {
        record {int i; string s;} rec = {i: 2, s: "str"};
}

[KavinduZoysa]

Since the rec cannot access in public we do not need to uniquely identify. So we can have a name like $anonType$_x where x is an integer.

[KRVPerera]

Is it guranteed? What if I update some public variables inside the loop?

[KavinduZoysa]

If we update some public variables inside the loop, that means we have to define them outside the function right? So, that can be case 6 right?
If I misunderstood please provide an example.