What's the recommended way to check a type's value?

[nbrouwers]

Hi all,

We are developing a DSL for the domain of Domain Driven Design. Amongst others, it contains Entities that have Attributes. Attributes have a name and type property. See below for a small example:

    Aggregate ItemBarcode {
        Entity ItemBarcode {
            - int id
            - Barcode barcode
        }
        ValueObject Barcode {
            string value
        }
   }

The attribute's type can be a TypeReference, e.g. referencing ValueObject Barcode, or a primitive/basic type, e.g. like assigning it a type like int.

For the development of a code generator for this DSL, we need to check the value of the Attribute's type. Specially, we'd like to do something like this:

    generateType(type:unknown) : Generated {
        let content : Generated;

        if (isTypeReference(type)) {
           // Fill content here 
        } else if (isType_Timestamp(type)) {
            content = 'Timestamp';
        } else if (isType_Integer(type)) {
            content = 'int';
        } else if (isType_String(type)) {
            content = 'string';
        } else {
            content = 'string'
        }
        return content
    } 
}

The problem is that the isType_ variants from the generated ast.ts never evaluate to true.
We suspect this has to do with BasicType not being considered as a specific type of Type, maybe since BasicType is a Langium type and not a parser rule?

So the question: could someone recommend a robust way to check on the value of a BasicType?

For reference, the relevant grammar is the following:

Entity infers Entity:
    "Entity" name=ID  
    '{' 
       ('-' attributes+=Attribute)* 
    "}"
;

Attribute infers Attribute:
    ^type=Type name=ID (isKey='key')?
;

Type infers Type:
    BasicType | TypeReference
;

TypeReference infers TypeReference:
    ref=[ValueObject:ID]
;

type BasicType =
      'string' 
    | 'int' 
    | 'double' 
    | 'float'
    | 'long' 
    | 'boolean' 
    | 'Date' 
    | 'DateTime' 
    | 'Timestamp' 
    | 'BigDecimal' 
    | 'BigInteger' 
;

BasicType returns BasicType:
      Type_String
    | Type_Integer 
    | Type_Double 
    | Type_Float
    | Type_Long 
    | Type_Boolean 
    | Type_Date 
    | Type_DateTime 
    | Type_Timestamp 
    | Type_BigDecimal 
    | Type_BigInteger
;

Type_String returns string: "string";
Type_Integer returns string: "int";
Type_Double returns string: "double";
Type_Float returns string: "float";
Type_Long returns string: "long";
Type_Boolean returns string: "boolean";
Type_Date returns string: "Date";
Type_DateTime returns string: "DateTime";
Type_Timestamp returns string: "Timestamp";
Type_BigDecimal returns string: "BigDecimal";
Type_BigInteger returns string: "BigInteger";

[msujew]

Hey @nbrouwers,

looking at the generated is<type> checking code, everything looks fine:

export function isType_BigDecimal(item: unknown): item is Type_BigDecimal {
    return item === 'BigDecimal';
}

Can you confirm that this is generated for your language as well? Can you also confirm (maybe via debugging or similar) that the values you pass in there are actually what you think you're passing in there? Given that the generated checking function is pretty simple, I assume there's something else going on.

[nbrouwers]

Hi @msujew,

thanks for your quick reply.
Much appreciated!

The generateType function is called from the generateAttribute function as shown below:

generateAttribute(gen) {
    return toNode `${gen.name} ${this.generateType(gen.type)}`;
}

In this context, the most generic type to pass is Type, generalizing both TypeReference and BasicType.
When it enters the generateType method, it indeed is passed as a Type.

Note that the check isTypeReference in the beginning works as expected; in case the type parameter is of type TypeReference, the expression evaluates to true.

And yes, I can confirm that these check functions are generated for all BasicType types.

export type BasicType = 'BigDecimal' | 'BigInteger' | 'Date' | 'DateTime' | 'Timestamp' | 'boolean' | 'double' | 'float' | 'int' | 'long' | 'string';

export type Type_BigDecimal = 'BigDecimal';

export function isType_BigDecimal(item: unknown): item is Type_BigDecimal {
    return item === 'BigDecimal';
}

export type Type_BigInteger = 'BigInteger';

export function isType_BigInteger(item: unknown): item is Type_BigInteger {
    return item === 'BigInteger';
}

export type Type_Boolean = 'boolean';

export function isType_Boolean(item: unknown): item is Type_Boolean {
    return item === 'boolean';
}

export type Type_Date = 'Date';

export function isType_Date(item: unknown): item is Type_Date {
    return item === 'Date';
}

export type Type_DateTime = 'DateTime';

export function isType_DateTime(item: unknown): item is Type_DateTime {
    return item === 'DateTime';
}

export type Type_Double = 'double';

export function isType_Double(item: unknown): item is Type_Double {
    return item === 'double';
}

export type Type_Float = 'float';

export function isType_Float(item: unknown): item is Type_Float {
    return item === 'float';
}

export type Type_Integer = 'int';

export function isType_Integer(item: unknown): item is Type_Integer {
    return item === 'int';
}

export type Type_Long = 'long';

export function isType_Long(item: unknown): item is Type_Long {
    return item === 'long';
}

export type Type_String = 'string';

export function isType_String(item: unknown): item is Type_String {
    return item === 'string';
}

export type Type_Timestamp = 'Timestamp';

export function isType_Timestamp(item: unknown): item is Type_Timestamp {
    return item === 'Timestamp';
}

[nbrouwers]

Btw, one other possibly important observation:

• In case the type of the Attribute is a TypeReference, the type parameter as it enters the generateType function is indeed of type TypeReference.
• However, in case the type is (supposed to be) a BasicType, the type parameter as it enters the generateType function is of type Type (instead of BasicType).

The latter is of course suspicious. Why is it passed as the more generic Type?

[nbrouwers]

Btw. one other possibly important observation:

Type seems to be aliased by TypeReference, where we otherwise would expect it to be a generic type specializing both TypeReference and BasicType.

export type Type = TypeReference;

export const Type = 'Type';

[msujew]

The issue is probably that Type is inferred as an AST type, while all your BasicType types are actually just of type string. This probably messes with the generator and parser code in some way. I would recommend to refactor it:

Type infers Type:
    SimpleType | TypeReference
;

SimpleType: value=BasicType;

[nbrouwers]

I did the refactoring as suggested (but with different naming), and the issue is the same.

The check function now receives indeed a SimpleType as item parameter, but the implementation is not correct. Instead of checking the item itself to be equal to the SimpleType value (e.g. int), it should check against item's value property.

So in this case, the correct implementation would be:

export function isType_Integer(item: unknown): item is Type_Integer {
    return item.value === 'int';
}

Despite this, your refactoring suggestion does now allow us to implement a simple check ourselves, since it's now a SimpleType entering the generateType function, which has an explicit value property with the BasicType as string representation.

Still, I think the AST generation can be improved to support this pattern. How to file this as a feature request?

Thank you so much for your help!

[msujew]

So in this case, the correct implementation would be:

No, the generated code is still correct. You just need to pass in item.value yourself into isType_Integer.

since it's now a SimpleType entering the generateType function, which has an explicit value property with the BasicType as string representation.

Yes, exactly, that was the purpose. You now just need to put an additional isSimpleType in there and you're done :)

Still, I think the AST generation can be improved to support this pattern. How to file this as a feature request?

You can go ahead and file an issue for the generated

export type Type = TypeReference;

export const Type = 'Type';

stuff. It's supposed to be:

export type Type = BasicType | TypeReference;

export const Type = 'Type';