Add validation of cyclic inheritance for declared types

Currently, no validation of this code, where type X extends Y, Y extends Z and Z extends X.

interface X extends Y {}
interface Y extends Z {}
interface Z extends X {}

[snarkipus]

@pluralia Sure, I’d be happy to - it will just take me a few days. I’m not sure that @msujew had a PR from me on his Christmas list. 😃

[snarkipus]

I implemented something similar to this when I was attempting to learn how to use Langium.

Helper Functions

export function classHierarchy(c: SJClass): Set<Reference<SJClass>> {
    let visited = new Set<Reference<SJClass>>();
    let current = c.superClass;
    while (current != undefined && !visited.has(current)) {
        visited.add(current);
        current = current.ref?.superClass;
    }
    return visited;
}

export function classHierarchyMethods(c: SJClass): Map<string, SJMethod> {
        let returnMap = new Map<string, SJMethod>();

        [...classHierarchy(c)]
            .reverse()
            .flatMap(r => r.ref?.members as SJMember[])
            .forEach(m => returnMap.set(m.name, m as SJMethod));

        return returnMap;
}

export function classHierarchyMembers(c: SJClass): Array<SJMember> {
    return [...classHierarchy(c)]
                .map(r => r.ref)
                .map(m => m?.members as SJMember[])
                .flat();
}

Validator

    checkClassHierarchy(c: SJClass, accept: ValidationAcceptor): void {
        const hierarchy = classHierarchy(c);
        hierarchy.forEach(ref => {
            if (ref.ref?.name === c.name) {
                accept(
                    'error',
                    "cycle in hierarchy of class '" + c.name + "'",
                    {
                        node: c,
                        property: 'name',
                        code: IssueCodes.ClassHierarchy
                    }
                );
            }
        })
    }

Test Code

describe('Small Java Validator: Valid Hierarchy', () => {
    const text=`
    class A extends C {}
    class C extends B {}
    class B {}
    `;

    let validationResult: ValidationResult<SJProgram>;

    beforeAll(async () => {
        validationResult = await validate(text);
    });

    it('Should detect no cycle hierarchies', () => {
        expectNoIssues(validationResult);
    });
});

describe('Small Java Validator: Hierarchy Cycles', () => {
    const text=`
    class A extends C {}
    class C extends B {}
    class B extends A {}
    `;

    let validationResult: ValidationResult<SJProgram>;

    beforeAll(async () => {
        validationResult = await validate(text);
    });

    it('Should detect cycle hierarchies', () => {
        const rule = validationResult.document.parseResult.value.classes;
        for (let i = 0; i < 3; i++) {
            expectError(validationResult, "cycle in hierarchy of class '" + rule[i].name + "'",
            {
                node: rule[i],
                property: {
                    name: 'name'
                }
            });
        }
    });
});

Not sure how helpful this is since it was married to my own nascent type computation implementation, but it worked for what I was attempting to do. Hopefully this saves you some time. 😃