Does not validate unknown members of a component in BrightScript mode

src/bscPlugin/validation/ScopeValidator.spec.ts

@@ -1836,6 +1836,43 @@ describe('ScopeValidator', () => {
             expectZeroDiagnostics(program);
         });
 
+        it('does not have diagnostic when accessing unknown member of node in Brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                ' @param {roSGNode} node
+                function testNodeMember(node)
+                    x = node.whatever
+                    return x
+                end function
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('does not have diagnostic when accessing unknown member of contentnode in Brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                ' @param {roSgNodeCOntentNode} node
+                function testNodeMember(node)
+                    x = node.whatever
+                    return x
+                end function
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('does not have diagnostic when accessing unknown member of created node  in Brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                ' @param {string} nodeSubtype
+                function testNodeMember(nodeSubtype)
+                    x = createObject("roSgNode",nodeSubtype)
+                    x.whatever = true
+                    return x
+                end function
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
         it('allows anything on m in an anonymous function', () => {
             program.setFile('source/main.bs', `
                 function test()

src/bscPlugin/validation/ScopeValidator.ts

@@ -1,5 +1,5 @@
 import { DiagnosticTag, type Range } from 'vscode-languageserver';
-import { isAliasStatement, isAssignmentStatement, isAssociativeArrayType, isBinaryExpression, isBooleanType, isBrsFile, isCallExpression, isCallableType, isClassStatement, isClassType, isComponentType, isDottedGetExpression, isDynamicType, isEnumMemberType, isEnumType, isFunctionExpression, isFunctionParameterExpression, isLiteralExpression, isNamespaceStatement, isNamespaceType, isNewExpression, isNumberType, isObjectType, isPrimitiveType, isReferenceType, isReturnStatement, isStringType, isTypedFunctionType, isUnionType, isVariableExpression, isVoidType, isXmlScope } from '../../astUtils/reflection';
+import { isAliasStatement, isAssignmentStatement, isAssociativeArrayType, isBinaryExpression, isBooleanType, isBrsFile, isCallExpression, isCallableType, isClassStatement, isClassType, isComponentType, isDottedGetExpression, isDynamicType, isEnumMemberType, isEnumType, isFunctionExpression, isFunctionParameterExpression, isInterfaceType, isLiteralExpression, isNamespaceStatement, isNamespaceType, isNewExpression, isNumberType, isObjectType, isPrimitiveType, isReferenceType, isReturnStatement, isStringType, isTypedFunctionType, isUnionType, isVariableExpression, isVoidType, isXmlScope } from '../../astUtils/reflection';
 import type { DiagnosticInfo } from '../../DiagnosticMessages';
 import { DiagnosticMessages } from '../../DiagnosticMessages';
 import type { BrsFile } from '../../files/BrsFile';
@@ -1239,6 +1239,8 @@ export class ScopeValidator {
      * In particular, since BrightScript does not support Unions, and there's no way to cast them to something else
      * if the result of .getType() is a union, and we're in a .brs (brightScript) file, treat the result as Dynamic
      *
+     * Also, for BrightScript parse-mode, if .getType() returns a node type, do not validate unknown members.
+     *
      * In most cases, this returns the result of node.getType()
      *
      * @param file the current file being processed
@@ -1265,6 +1267,11 @@ export class ScopeValidator {
                 //this is a union
                 return DynamicType.instance;
             }
+
+            if (isComponentType(type)) {
+                // modify type to allow any member access for Node types
+                type.changeUnknownMemberToDynamic = true;
+            }
         }
 
         // by default return the result of node.getType()

src/types/InheritableType.ts

@@ -1,5 +1,5 @@
 import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
-import { isInheritableType, isReferenceType } from '../astUtils/reflection';
+import { isAnyReferenceType, isInheritableType, isReferenceType } from '../astUtils/reflection';
 import { SymbolTypeFlag } from '../SymbolTypeFlag';
 import { BscType } from './BscType';
 import type { ReferenceType } from './ReferenceType';
@@ -14,14 +14,21 @@ export abstract class InheritableType extends BscType {
         }
     }
 
+    changeUnknownMemberToDynamic = false;
+
     getMemberType(memberName: string, options: GetTypeOptions) {
         let hasRoAssociativeArrayAsAncestor = this.name.toLowerCase() === 'roassociativearray' || this.getAncestorTypeList()?.find(ancestorType => ancestorType.name.toLowerCase() === 'roassociativearray');
 
         if (hasRoAssociativeArrayAsAncestor) {
             return super.getMemberType(memberName, options) ?? DynamicType.instance;
         }
 
-        return super.getMemberType(memberName, { ...options, fullName: memberName, tableProvider: () => this.memberTable });
+        const resultType = super.getMemberType(memberName, { ...options, fullName: memberName, tableProvider: () => this.memberTable });
+
+        if (this.changeUnknownMemberToDynamic && !resultType.isResolvable()) {
+            return DynamicType.instance;
+        }
+        return resultType;
     }
 
     public toString() {