Catch circular class extend references

src/DiagnosticMessages.ts

@@ -620,6 +620,11 @@ export let DiagnosticMessages = {
         message: `Missing expression(s) in 'dim' statement`,
         code: 1121,
         severity: DiagnosticSeverity.Error
+    }),
+    circularReferenceDetected: (items: string[]) => ({
+        message: `Circular reference detected between ${Array.isArray(items) ? items.join(' -> ') : ''}`,
+        code: 1122,
+        severity: DiagnosticSeverity.Error
     })
 };
 

src/files/BrsFile.Class.spec.ts

@@ -741,6 +741,46 @@ describe('BrsFile BrighterScript classes', () => {
         );
     });
 
+    it('detects direct circular extends', () => {
+        //direct
+        program.addOrReplaceFile('source/Direct.bs', `
+            class Parent extends Child
+            end class
+
+            class Child extends Parent
+            end class
+        `);
+        program.validate();
+        expect(
+            program.getDiagnostics().map(x => x.message).sort()
+        ).to.eql([
+            DiagnosticMessages.circularReferenceDetected(['Child', 'Parent', 'Child']).message,
+            DiagnosticMessages.circularReferenceDetected(['Parent', 'Child', 'Parent']).message
+        ]);
+    });
+
+    it('detects indirect circular extends', () => {
+        //direct
+        program.addOrReplaceFile('source/Direct.bs', `
+            class Parent extends Grandchild
+            end class
+
+            class Child extends Parent
+            end class
+
+            class Grandchild extends Child
+            end class
+        `);
+        program.validate();
+        expect(
+            program.getDiagnostics().map(x => x.message).sort()
+        ).to.eql([
+            DiagnosticMessages.circularReferenceDetected(['Child', 'Parent', 'Grandchild', 'Child']).message,
+            DiagnosticMessages.circularReferenceDetected(['Grandchild', 'Child', 'Parent', 'Grandchild']).message,
+            DiagnosticMessages.circularReferenceDetected(['Parent', 'Grandchild', 'Child', 'Parent']).message
+        ]);
+    });
+
     it('detects duplicate member names', () => {
         program.addOrReplaceFile({ src: `${rootDir}/source/main.bs`, dest: 'source/main.bs' }, `
             class Animal

src/validators/ClassValidator.ts

@@ -14,6 +14,9 @@ import type { BrsFile } from '../files/BrsFile';
 export class BsClassValidator {
     private scope: Scope;
     public diagnostics: BsDiagnostic[];
+    /**
+     * The key is the namespace-prefixed class name. (i.e. `NameA.NameB.SomeClass` or `CoolClass`
+     */
     private classes: Record<string, AugmentedClassStatement>;
 
     public validate(scope: Scope) {
@@ -24,6 +27,7 @@ export class BsClassValidator {
         this.findClasses();
         this.findNamespaceNonNamespaceCollisions();
         this.linkClassesWithParents();
+        this.detectCircularReferences();
         this.validateMemberCollisions();
         this.verifyChildConstructor();
         this.verifyNewExpressions();
@@ -156,6 +160,31 @@ export class BsClassValidator {
         }
     }
 
+    private detectCircularReferences() {
+        for (let key in this.classes) {
+            let cls = this.classes[key];
+            const names = new Map<string, string>();
+            do {
+                const className = cls.getName(ParseMode.BrighterScript);
+                const lowerClassName = className.toLowerCase();
+                //if we've already seen this class name before, then we have a circular dependency
+                if (names.has(lowerClassName)) {
+                    this.diagnostics.push({
+                        ...DiagnosticMessages.circularReferenceDetected([
+                            ...names.values(),
+                            className
+                        ]),
+                        file: cls.file,
+                        range: cls.name.range
+                    });
+                    break;
+                }
+                names.set(lowerClassName, className);
+                cls = cls.parentClass;
+            } while (cls);
+        }
+    }
+
     private validateMemberCollisions() {
         for (let key in this.classes) {
             let classStatement = this.classes[key];
@@ -270,7 +299,7 @@ export class BsClassValidator {
     /**
      * Get the closest member with the specified name (case-insensitive)
      */
-    private getAncestorMember(classStatement: AugmentedClassStatement, memberName: string) {
+    getAncestorMember(classStatement, memberName) {
         let lowerMemberName = memberName.toLowerCase();
         let ancestor = classStatement.parentClass;
         while (ancestor) {
@@ -281,7 +310,7 @@ export class BsClassValidator {
                     classStatement: ancestor
                 };
             }
-            ancestor = ancestor.parentClass;
+            ancestor = ancestor.parentClass !== ancestor ? ancestor.parentClass : null;
         }
     }