diff --git a/src/AstValidationSegmenter.ts b/src/AstValidationSegmenter.ts
index 41586c199..06fa3f964 100644
--- a/src/AstValidationSegmenter.ts
+++ b/src/AstValidationSegmenter.ts
@@ -1,5 +1,5 @@
 import type { DottedGetExpression, TypeExpression, VariableExpression } from './parser/Expression';
-import { isAliasStatement, isBinaryExpression, isBlock, isBody, isClassStatement, isConditionalCompileStatement, isDottedGetExpression, isInterfaceStatement, isNamespaceStatement, isTypeExpression, isVariableExpression } from './astUtils/reflection';
+import { isAliasStatement, isBinaryExpression, isBlock, isBody, isClassStatement, isConditionalCompileStatement, isDottedGetExpression, isInterfaceStatement, isNamespaceStatement, isTypecastStatement, isTypeExpression, isVariableExpression } from './astUtils/reflection';
 import { ChildrenSkipper, WalkMode, createVisitor } from './astUtils/visitors';
 import type { ExtraSymbolData, GetTypeOptions, TypeChainEntry } from './interfaces';
 import type { AstNode, Expression } from './parser/AstNode';
@@ -9,6 +9,7 @@ import { SymbolTypeFlag } from './SymbolTypeFlag';
 import type { Token } from './lexer/Token';
 import type { BrsFile } from './files/BrsFile';
 import { TokenKind } from './lexer/TokenKind';
+import type { BscSymbol } from './SymbolTable';
 
 // eslint-disable-next-line no-bitwise
 export const InsideSegmentWalkMode = WalkMode.visitStatements | WalkMode.visitExpressions | WalkMode.recurseChildFunctions;
@@ -73,12 +74,20 @@ export class AstValidationSegmenter {
             return this.checkExpressionForUnresolved(segment, expression.expression.left as VariableExpression, assignedSymbolsNames) ||
                 this.checkExpressionForUnresolved(segment, expression.expression.right as VariableExpression, assignedSymbolsNames);
         }
+        if (isTypeExpression(expression)) {
+            const typeIntypeExpression = expression.getType({ flags: SymbolTypeFlag.typetime });
+            if (typeIntypeExpression.isResolvable()) {
+                return this.handleTypeCastTypeExpression(segment, expression);
+            }
+        }
+        return this.addUnresolvedSymbol(segment, expression, assignedSymbolsNames);
+    }
 
+    private addUnresolvedSymbol(segment: AstNode, expression: Expression, assignedSymbolsNames?: Set<string>) {
         const flag = util.isInTypeExpression(expression) ? SymbolTypeFlag.typetime : SymbolTypeFlag.runtime;
         let typeChain: TypeChainEntry[] = [];
         const extraData = {} as ExtraSymbolData;
         const options: GetTypeOptions = { flags: flag, onlyCacheResolvedTypes: true, typeChain: typeChain, data: extraData };
-
         const nodeType = expression.getType(options);
         if (!nodeType?.isResolvable()) {
             let symbolsSet: Set<UnresolvedSymbol>;
@@ -126,6 +135,8 @@ export class AstValidationSegmenter {
 
     private currentNamespaceStatement: NamespaceStatement;
     private currentClassStatement: ClassStatement;
+    private unresolvedTypeCastTypeExpressions: TypeExpression[] = [];
+
 
     checkSegmentWalk(segment: AstNode) {
         if (isNamespaceStatement(segment) || isBody(segment)) {
@@ -161,6 +172,7 @@ export class AstValidationSegmenter {
             return;
         }
 
+
         this.segmentsForValidation.push(segment);
         this.validatedSegments.set(segment, false);
         let foundUnresolvedInSegment = false;
@@ -169,6 +181,16 @@ export class AstValidationSegmenter {
         const assignedSymbolsNames = new Set<string>();
         this.currentClassStatement = segment.findAncestor(isClassStatement);
 
+        if (isTypecastStatement(segment)) {
+            if (this.checkExpressionForUnresolved(segment, segment.typecastExpression.typeExpression)) {
+                this.unresolvedTypeCastTypeExpressions.push(segment.typecastExpression.typeExpression);
+            }
+        }
+        let unresolvedTypeCastTypeExpression: TypeExpression;
+        if (this.unresolvedTypeCastTypeExpressions.length > 0) {
+            unresolvedTypeCastTypeExpression = this.unresolvedTypeCastTypeExpressions[this.unresolvedTypeCastTypeExpressions.length - 1];
+        }
+
         segment.walk(createVisitor({
             AssignmentStatement: (stmt) => {
                 if (stmt.tokens.equals.kind === TokenKind.Equal) {
@@ -186,7 +208,11 @@ export class AstValidationSegmenter {
                 assignedSymbolsNames.add(stmt.tokens.item.text.toLowerCase());
             },
             VariableExpression: (expr) => {
-                if (!assignedSymbolsNames.has(expr.tokens.name.text.toLowerCase())) {
+                const hasUnresolvedTypecastedM = unresolvedTypeCastTypeExpression && expr.tokens.name.text.toLowerCase() === 'm';
+                if (hasUnresolvedTypecastedM) {
+                    this.addUnresolvedSymbol(segment, unresolvedTypeCastTypeExpression);
+
+                } else if (!assignedSymbolsNames.has(expr.tokens.name.text.toLowerCase())) {
                     const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr, assignedSymbolsNames);
                     foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
                 }
@@ -195,6 +221,18 @@ export class AstValidationSegmenter {
             DottedGetExpression: (expr) => {
                 const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr, assignedSymbolsNames);
                 foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
+                if (!foundUnresolvedInSegment && unresolvedTypeCastTypeExpression) {
+                    let startOfDottedGet: Expression = expr;
+                    while (isDottedGetExpression(startOfDottedGet)) {
+                        startOfDottedGet = startOfDottedGet.obj;
+                    }
+                    if (isVariableExpression(startOfDottedGet)) {
+                        const hasUnresolvedTypeCastedM = unresolvedTypeCastTypeExpression && startOfDottedGet.tokens.name.text.toLowerCase() === 'm';
+                        if (hasUnresolvedTypeCastedM) {
+                            this.handleTypeCastTypeExpression(segment, unresolvedTypeCastTypeExpression);
+                        }
+                    }
+                }
                 skipper.skip();
             },
             TypeExpression: (expr) => {
@@ -212,7 +250,32 @@ export class AstValidationSegmenter {
         }
         this.currentClassStatement = undefined;
         this.currentClassStatement = undefined;
+    }
+
+
+    private handleTypeCastTypeExpression(segment: AstNode, typecastTypeExpression: TypeExpression) {
+        const expression = typecastTypeExpression;
+        if (isTypeExpression(expression)) {
+            const typeIntypeExpression = expression.getType({ flags: SymbolTypeFlag.typetime });
+
+            if (typeIntypeExpression.isResolvable()) {
+                const memberSymbols = typeIntypeExpression.getMemberTable().getAllSymbols(SymbolTypeFlag.runtime);
+                const unresolvedMembers: BscSymbol[] = [];
+                for (const memberSymbol of memberSymbols) {
+                    if (!memberSymbol.type.isResolvable()) {
+                        unresolvedMembers.push(memberSymbol);
+                    }
+                }
+                let addedSymbol = false;
+                for (const unresolvedMember of unresolvedMembers) {
+                    addedSymbol = this.addUnresolvedSymbol(segment, unresolvedMember?.data?.definingNode) || addedSymbol;
 
+                }
+                return addedSymbol;
+            }
+            return this.addUnresolvedSymbol(segment, expression);
+        }
+        return false;
     }
 
     getAllUnvalidatedSegments() {
@@ -228,6 +291,7 @@ export class AstValidationSegmenter {
 
     getSegmentsWithChangedSymbols(changedSymbols: Map<SymbolTypeFlag, Set<string>>): AstNode[] {
         const segmentsToWalkForValidation: AstNode[] = [];
+
         for (const segment of this.segmentsForValidation) {
             if (this.validatedSegments.get(segment)) {
                 continue;
diff --git a/src/CrossScopeValidator.ts b/src/CrossScopeValidator.ts
index 89c3fa230..179478d26 100644
--- a/src/CrossScopeValidator.ts
+++ b/src/CrossScopeValidator.ts
@@ -277,7 +277,7 @@ export class CrossScopeValidator {
         if (this.providedTreeMap.has(scope)) {
             return this.providedTreeMap.get(scope);
         }
-        const providedTree = new ProvidedNode('', this.componentsMap);
+        const providedTree = new ProvidedNode('');//, this.componentsMap);
         const duplicatesMap = new Map<string, Set<FileSymbolPair>>();
 
         const referenceTypesMap = new Map<{ symbolName: string; file: BscFile; symbolObj: ProvidedSymbol }, Array<{ name: string; namespacedName?: string }>>();
@@ -499,7 +499,7 @@ export class CrossScopeValidator {
             const typeName = 'rosgnode' + componentName;
             const component = this.program.getComponent(componentName);
             const componentSymbol = this.program.globalScope.symbolTable.getSymbol(typeName, SymbolTypeFlag.typetime)?.[0];
-            if (componentSymbol && component) {
+            if (componentSymbol && component && componentSymbol.type.isBuiltIn) {
                 this.componentsMap.set(typeName, { file: component.file, symbol: componentSymbol });
             }
         }
diff --git a/src/DiagnosticManager.ts b/src/DiagnosticManager.ts
index 140788b27..65f108ebc 100644
--- a/src/DiagnosticManager.ts
+++ b/src/DiagnosticManager.ts
@@ -237,7 +237,7 @@ export class DiagnosticManager {
                     isMatch = !!context.tags?.includes(filter.tag);
                 }
                 if (isMatch && needToMatch.scope) {
-                    isMatch = context.scope === filter.scope;
+                    isMatch = context.scope?.name === filter.scope.name;
                 }
                 if (isMatch && needToMatch.fileUri) {
                     isMatch = cachedData.diagnostic.location?.uri === filter.fileUri;
diff --git a/src/DiagnosticMessages.ts b/src/DiagnosticMessages.ts
index c0817ffef..e53530c0d 100644
--- a/src/DiagnosticMessages.ts
+++ b/src/DiagnosticMessages.ts
@@ -1031,6 +1031,17 @@ export let DiagnosticMessages = {
         legacyCode: 1151,
         severity: DiagnosticSeverity.Error,
         code: 'return-type-coercion-mismatch'
+    }),
+    cannotFindCallFuncFunction: (name: string, fullName: string, typeName: string) => ({
+        message: `Cannot find callfunc function '${name}' for type '${typeName}'`,
+        data: {
+            name: name,
+            fullName: fullName,
+            typeName: typeName,
+            isCallfunc: true
+        },
+        severity: DiagnosticSeverity.Error,
+        code: 'cannot-find-callfunc'
     })
 };
 export const defaultMaximumTruncationLength = 160;
diff --git a/src/PluginInterface.ts b/src/PluginInterface.ts
index a245b60a2..f9cddf326 100644
--- a/src/PluginInterface.ts
+++ b/src/PluginInterface.ts
@@ -54,6 +54,7 @@ export default class PluginInterface<T extends CompilerPlugin = CompilerPlugin>
      * Call `event` on plugins
      */
     public emit<K extends keyof PluginEventArgs<T> & string>(event: K, ...args: PluginEventArgs<T>[K]) {
+        this.logger.debug(`Emitting plugin event: ${event}`);
         for (let plugin of this.plugins) {
             if ((plugin as any)[event]) {
                 try {
@@ -75,6 +76,7 @@ export default class PluginInterface<T extends CompilerPlugin = CompilerPlugin>
      * Call `event` on plugins, but allow the plugins to return promises that will be awaited before the next plugin is notified
      */
     public async emitAsync<K extends keyof PluginEventArgs<T> & string>(event: K, ...args: PluginEventArgs<T>[K]): Promise< PluginEventArgs<T>[K][0]> {
+        this.logger.debug(`Emitting async plugin event: ${event}`);
         for (let plugin of this.plugins) {
             if ((plugin as any)[event]) {
                 try {
diff --git a/src/Program.spec.ts b/src/Program.spec.ts
index 50ef5cf3b..8ad1efee0 100644
--- a/src/Program.spec.ts
+++ b/src/Program.spec.ts
@@ -19,7 +19,7 @@ import type { SinonSpy } from 'sinon';
 import { createSandbox } from 'sinon';
 import { SymbolTypeFlag } from './SymbolTypeFlag';
 import { AssetFile } from './files/AssetFile';
-import type { ProvideFileEvent, CompilerPlugin, BeforeProvideFileEvent, AfterProvideFileEvent, BeforeFileAddEvent, AfterFileAddEvent, BeforeFileRemoveEvent, AfterFileRemoveEvent } from './interfaces';
+import type { ProvideFileEvent, CompilerPlugin, BeforeProvideFileEvent, AfterProvideFileEvent, BeforeFileAddEvent, AfterFileAddEvent, BeforeFileRemoveEvent, AfterFileRemoveEvent, ScopeValidationOptions } from './interfaces';
 import { StringType, TypedFunctionType, DynamicType, FloatType, IntegerType, InterfaceType, ArrayType, BooleanType, DoubleType, UnionType } from './types';
 import { AssociativeArrayType } from './types/AssociativeArrayType';
 import { ComponentType } from './types/ComponentType';
@@ -584,6 +584,161 @@ describe('Program', () => {
             program.validate();
             expectZeroDiagnostics(program);
         });
+
+        describe('changed symbols', () => {
+            it('includes components when component interface changes', () => {
+                program.setFile('components/widget.xml', trim`
+                    <component name="Widget" extends="Group">
+                        <interface>
+                            <field id="foo" type="string" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('components/other.xml', trim`
+                    <component name="Other" extends="Group">
+                        <interface>
+                            <field id="foo" type="string" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('source/main.bs', `
+                    sub sourceScopeFunc()
+                    end sub
+                `);
+                program.validate();
+                let options: ScopeValidationOptions = program['currentScopeValidationOptions'];
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.true;
+
+                expectZeroDiagnostics(program);
+                //change widget
+                program.setFile('components/widget.xml', trim`
+                    <component name="Widget" extends="Group">
+                        <interface>
+                            <field id="foo" type="integer" />
+                        </interface>
+                    </component>
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                options = program['currentScopeValidationOptions'];
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.false;
+            });
+
+            it('includes components when component callfunc changes', () => {
+                program.setFile('components/widget.xml', trim`
+                    <component name="Widget" extends="Group">
+                        <script type="text/brightscript" uri="widget.bs" />
+                        <interface>
+                            <function name="foo" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('components/widget.bs', `
+                    sub foo()
+                    end sub
+                `);
+                program.setFile('components/other.xml', trim`
+                    <component name="Other" extends="Group">
+                        <interface>
+                            <field id="foo" type="string" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('source/main.bs', `
+                    sub sourceScopeFunc()
+                    end sub
+                `);
+                program.validate();
+                let options: ScopeValidationOptions = program['currentScopeValidationOptions'];
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.true;
+
+                expectZeroDiagnostics(program);
+                //change widget@.foo
+                program.setFile('components/widget.bs', `
+                    sub foo(input)
+                        print input
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                options = program['currentScopeValidationOptions'];
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.false;
+            });
+
+            it('includes types that depend on a changed component', () => {
+                program.setFile('components/widget.xml', trim`
+                    <component name="Widget" extends="Group">
+                        <script type="text/brightscript" uri="widget.bs" />
+                        <interface>
+                            <function name="foo" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('components/widget.bs', `
+                    sub foo()
+                    end sub
+                `);
+                program.setFile('components/other.xml', trim`
+                    <component name="Other" extends="Group">
+                        <interface>
+                            <field id="foo" type="string" />
+                        </interface>
+                    </component>
+                `);
+                program.setFile('source/main.bs', `
+                    interface IncludesWidget
+                        widget as roSGNodeWidget
+                    end interface
+
+                    sub sourceScopeFunc()
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                let options: ScopeValidationOptions = program['currentScopeValidationOptions'];
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('includeswidget')).to.be.true;
+
+                // change roSgNodeOther
+                program.setFile('components/other.xml', trim`
+                    <component name="Other" extends="Group">
+                        <interface>
+                            <field id="foo" type="integer" />
+                        </interface>
+                    </component>
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                options = program['currentScopeValidationOptions'];
+
+                // only rosgnodewidget changes
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.false;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('includeswidget')).to.be.false;
+
+                //change widget@.foo
+                program.setFile('components/widget.bs', `
+                    sub foo(input)
+                        print input
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                options = program['currentScopeValidationOptions'];
+
+                // has rosgnodewidget AND IncludesWidget, because it depends on roSgnodeWidget
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodewidget')).to.be.true;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('rosgnodeother')).to.be.false;
+                expect(options.changedSymbols.get(SymbolTypeFlag.typetime).has('includeswidget')).to.be.true;
+            });
+
+        });
+
     });
 
     describe('hasFile', () => {
diff --git a/src/Program.ts b/src/Program.ts
index 4900ccf2d..e4f7b15b3 100644
--- a/src/Program.ts
+++ b/src/Program.ts
@@ -5,7 +5,7 @@ import type { CodeAction, Position, Range, SignatureInformation, Location, Docum
 import type { BsConfig, FinalizedBsConfig } from './BsConfig';
 import { Scope } from './Scope';
 import { DiagnosticMessages } from './DiagnosticMessages';
-import type { FileObj, SemanticToken, FileLink, ProvideHoverEvent, ProvideCompletionsEvent, Hover, ProvideDefinitionEvent, ProvideReferencesEvent, ProvideDocumentSymbolsEvent, ProvideWorkspaceSymbolsEvent, BeforeFileAddEvent, BeforeFileRemoveEvent, PrepareFileEvent, PrepareProgramEvent, ProvideFileEvent, SerializedFile, TranspileObj, SerializeFileEvent } from './interfaces';
+import type { FileObj, SemanticToken, FileLink, ProvideHoverEvent, ProvideCompletionsEvent, Hover, ProvideDefinitionEvent, ProvideReferencesEvent, ProvideDocumentSymbolsEvent, ProvideWorkspaceSymbolsEvent, BeforeFileAddEvent, BeforeFileRemoveEvent, PrepareFileEvent, PrepareProgramEvent, ProvideFileEvent, SerializedFile, TranspileObj, SerializeFileEvent, ScopeValidationOptions } from './interfaces';
 import { standardizePath as s, util } from './util';
 import { XmlScope } from './XmlScope';
 import { DependencyGraph } from './DependencyGraph';
@@ -16,7 +16,7 @@ import { globalCallables, globalFile } from './globalCallables';
 import { parseManifest, getBsConst } from './preprocessor/Manifest';
 import { URI } from 'vscode-uri';
 import PluginInterface from './PluginInterface';
-import { isBrsFile, isXmlFile, isXmlScope, isNamespaceStatement } from './astUtils/reflection';
+import { isBrsFile, isXmlFile, isXmlScope, isNamespaceStatement, isReferenceType } from './astUtils/reflection';
 import type { FunctionStatement, MethodStatement, NamespaceStatement } from './parser/Statement';
 import { BscPlugin } from './bscPlugin/BscPlugin';
 import { Editor } from './astUtils/Editor';
@@ -54,6 +54,8 @@ import { DiagnosticManager } from './DiagnosticManager';
 import { ProgramValidatorDiagnosticsTag } from './bscPlugin/validation/ProgramValidator';
 import type { ProvidedSymbolInfo, BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
+import { SymbolTable } from './SymbolTable';
+import { ReferenceType } from './types';
 
 const bslibNonAliasedRokuModulesPkgPath = s`source/roku_modules/rokucommunity_bslib/bslib.brs`;
 const bslibAliasedRokuModulesPkgPath = s`source/roku_modules/bslib/bslib.brs`;
@@ -115,6 +117,7 @@ export class Program {
         this.scopes.global = this.globalScope;
 
         this.populateGlobalSymbolTable();
+        this.globalScope.symbolTable.addSibling(this.componentsTable);
 
         //hardcode the files list for global scope to only contain the global file
         this.globalScope.getAllFiles = () => [globalFile];
@@ -144,6 +147,7 @@ export class Program {
             }
             nodeType = new ComponentType(nodeData.name, parentNode);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             if (nodeData.name === 'Node') {
                 // Add `roSGNode` as shorthand for `roSGNodeNode`
                 this.globalScope.symbolTable.addSymbol('roSGNode', { description: nodeData.description }, nodeType, SymbolTypeFlag.typetime);
@@ -181,12 +185,14 @@ export class Program {
         for (const ifaceData of Object.values(interfaces) as BRSInterfaceData[]) {
             const nodeType = new InterfaceType(ifaceData.name);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             this.globalScope.symbolTable.addSymbol(ifaceData.name, { description: ifaceData.description }, nodeType, SymbolTypeFlag.typetime);
         }
 
         for (const componentData of Object.values(components) as BRSComponentData[]) {
             const nodeType = new InterfaceType(componentData.name);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             if (componentData.name !== 'roSGNode') {
                 // we will add `roSGNode` as shorthand for `roSGNodeNode`, since all roSgNode components are SceneGraph nodes
                 this.globalScope.symbolTable.addSymbol(componentData.name, { description: componentData.description }, nodeType, SymbolTypeFlag.typetime);
@@ -200,6 +206,7 @@ export class Program {
         for (const eventData of Object.values(events) as BRSEventData[]) {
             const nodeType = new InterfaceType(eventData.name);
             nodeType.addBuiltInInterfaces();
+            nodeType.isBuiltIn = true;
             this.globalScope.symbolTable.addSymbol(eventData.name, { description: eventData.description }, nodeType, SymbolTypeFlag.typetime);
         }
 
@@ -228,6 +235,22 @@ export class Program {
 
     private fileSymbolInformation = new Map<string, { provides: ProvidedSymbolInfo; requires: UnresolvedSymbol[] }>();
 
+    private currentScopeValidationOptions: ScopeValidationOptions;
+
+    /**
+     *  Map of typetime symbols which depend upon the key symbol
+     */
+    private symbolDependencies = new Map<string, Set<string>>();
+
+
+    /**
+     * Symbol Table for storing custom component types
+     * This is a sibling to the global table (as Components can be used/referenced anywhere)
+     * Keeping custom components out of the global table and in a specific symbol table
+     * compartmentalizes their use
+     */
+    private componentsTable = new SymbolTable('Custom Components');
+
     public addFileSymbolInfo(file: BrsFile) {
         this.fileSymbolInformation.set(file.pkgPath, {
             provides: file.providedSymbols,
@@ -334,8 +357,9 @@ export class Program {
 
     /**
      * Keeps a set of all the components that need to have their types updated during the current validation cycle
+     * Map <componentKey, componentName>
      */
-    private componentSymbolsToUpdate = new Set<{ componentKey: string; componentName: string }>();
+    private componentSymbolsToUpdate = new Map<string, string>();
 
     /**
      * Register (or replace) the reference to a component in the component map
@@ -385,8 +409,12 @@ export class Program {
      * @param xmlFile XML file with <component> tag
      */
     private addDeferredComponentTypeSymbolCreation(xmlFile: XmlFile) {
-        this.componentSymbolsToUpdate.add({ componentKey: this.getComponentKey(xmlFile), componentName: xmlFile.componentName?.text });
-
+        const componentKey = this.getComponentKey(xmlFile);
+        const componentName = xmlFile.componentName?.text;
+        if (this.componentSymbolsToUpdate.has(componentKey)) {
+            return;
+        }
+        this.componentSymbolsToUpdate.set(componentKey, componentName);
     }
 
     private getComponentKey(xmlFile: XmlFile) {
@@ -394,7 +422,7 @@ export class Program {
     }
 
     /**
-     * Updates the global symbol table with the first component in this.components to have the same name as the component in the file
+     * Resolves symbol table with the first component in this.components to have the same name as the component in the file
      * @param componentKey key getting a component from `this.components`
      * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
      */
@@ -404,18 +432,56 @@ export class Program {
             return;
         }
         const components = this.components[componentKey] || [];
+        const previousComponentType = this.componentsTable.getSymbolType(symbolName, { flags: SymbolTypeFlag.typetime });
         // Remove any existing symbols that match
-        this.globalScope.symbolTable.removeSymbol(symbolName);
-        // There is a component that can be added - use it.
+        this.componentsTable.removeSymbol(symbolName);
         if (components.length > 0) {
+            // There is a component that can be added - use it.
             const componentScope = components[0].scope;
-            // TODO: May need to link symbol tables to get correct types for callfuncs
-            // componentScope.linkSymbolTable();
+
+            this.componentsTable.removeSymbol(symbolName);
+            componentScope.linkSymbolTable();
             const componentType = componentScope.getComponentType();
             if (componentType) {
-                this.globalScope.symbolTable.addSymbol(symbolName, {}, componentType, SymbolTypeFlag.typetime);
+                this.componentsTable.addSymbol(symbolName, {}, componentType, SymbolTypeFlag.typetime);
             }
-            // TODO: Remember to unlink! componentScope.unlinkSymbolTable();
+            const typeData = {};
+            const isSameAsPrevious = previousComponentType && componentType.isEqual(previousComponentType, typeData);
+            const isComponentTypeDifferent = !previousComponentType || isReferenceType(previousComponentType) || !isSameAsPrevious;
+            componentScope.unlinkSymbolTable();
+            return isComponentTypeDifferent;
+
+        }
+        // There was a previous component type, but no new one, so it's different
+        return !!previousComponentType;
+    }
+
+    /**
+     * Adds a reference type to the global symbol table with the first component in this.components to have the same name as the component in the file
+     * This is so on a first validation, these types can be resolved in teh future (eg. when the actual component is created)
+     * If we don't add reference types at this top level, they will be created at the file level, and will never get resolved
+     * @param componentKey key getting a component from `this.components`
+     * @param componentName the unprefixed name of the component that will be added (e.g. 'MyLabel' NOT 'roSgNodeMyLabel')
+     */
+    private addComponentReferenceType(componentKey: string, componentName: string) {
+        const symbolName = componentName ? util.getSgNodeTypeName(componentName) : undefined;
+        if (!symbolName) {
+            return;
+        }
+        const components = this.components[componentKey] || [];
+
+        if (components.length > 0) {
+            // There is a component that can be added,
+            if (!this.componentsTable.hasSymbol(symbolName, SymbolTypeFlag.typetime)) {
+                // it doesn't already exist in the table
+                const componentRefType = new ReferenceType(symbolName, symbolName, SymbolTypeFlag.typetime, () => this.componentsTable);
+                if (componentRefType) {
+                    this.componentsTable.addSymbol(symbolName, {}, componentRefType, SymbolTypeFlag.typetime);
+                }
+            }
+        } else {
+            // there is no component. remove from table
+            this.componentsTable.removeSymbol(symbolName);
         }
     }
 
@@ -626,7 +692,7 @@ export class Program {
                     let scope = new XmlScope(file, this);
                     this.addScope(scope);
 
-                    //register this compoent now that we have parsed it and know its component name
+                    //register this componet now that we have parsed it and know its component name
                     this.registerComponent(file, scope);
 
                     //notify plugins that the scope is created and the component is registered
@@ -772,6 +838,7 @@ export class Program {
             //if there is a scope named the same as this file's path, remove it (i.e. xml scopes)
             let scope = this.scopes[file.destPath];
             if (scope) {
+                this.logger.debug('Removing associated scope', scope.name);
                 const scopeDisposeEvent = {
                     program: this,
                     scope: scope
@@ -794,6 +861,8 @@ export class Program {
                 this.dependencyGraph.removeDependency('scope:source', file.dependencyGraphKey);
             }
             if (isBrsFile(file)) {
+                this.logger.debug('Removing file symbol info', file.srcPath);
+
                 if (!keepSymbolInformation) {
                     this.fileSymbolInformation.delete(file.pkgPath);
                 }
@@ -802,8 +871,12 @@ export class Program {
 
             //if this is a component, remove it from our components map
             if (isXmlFile(file)) {
+                this.logger.debug('Unregistering component', file.srcPath);
+
                 this.unregisterComponent(file);
             }
+            this.logger.debug('Disposing file', file.srcPath);
+
             //dispose any disposable things on the file
             for (const disposable of file?.disposables ?? []) {
                 disposable();
@@ -839,18 +912,44 @@ export class Program {
                 scopesValidated: 0,
                 totalLinkTime: '',
                 totalScopeValidationTime: '',
-                componentValidationTime: ''
+                componentValidationTime: '',
+                changedSymbolsTime: ''
             };
 
             const validationStopwatch = new Stopwatch();
             //validate every file
             const brsFilesValidated: BrsFile[] = [];
+            const xmlFilesValidated: XmlFile[] = [];
+
             const afterValidateFiles: BscFile[] = [];
+            const sortedFiles = Object.values(this.files).sort(firstBy(x => x.srcPath));
+            this.logger.time(LogLevel.info, ['Prebuild component types'], () => {
+                // cast a wide net for potential changes in components
+                for (const file of sortedFiles) {
+                    if (file.isValidated) {
+                        continue;
+                    }
+                    if (isXmlFile(file)) {
+                        this.addDeferredComponentTypeSymbolCreation(file);
+                    } else if (isBrsFile(file)) {
+                        for (const scope of this.getScopesForFile(file)) {
+                            if (isXmlScope(scope)) {
+                                this.addDeferredComponentTypeSymbolCreation(scope.xmlFile);
+                            }
+                        }
+                    }
+                }
+
+                // Create reference component types for any component that changes
+                for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                    this.addComponentReferenceType(componentKey, componentName);
+                }
+            });
+
 
             metrics.fileValidationTime = validationStopwatch.getDurationTextFor(() => {
                 //sort files by path so we get consistent results
-                const files = Object.values(this.files).sort(firstBy(x => x.srcPath));
-                for (const file of files) {
+                for (const file of sortedFiles) {
                     //for every unvalidated file, validate it
                     if (!file.isValidated) {
                         const validateFileEvent = {
@@ -863,6 +962,8 @@ export class Program {
                         file.isValidated = true;
                         if (isBrsFile(file)) {
                             brsFilesValidated.push(file);
+                        } else if (isXmlFile(file)) {
+                            xmlFilesValidated.push(file);
                         }
                         afterValidateFiles.push(file);
                     }
@@ -879,32 +980,97 @@ export class Program {
 
             metrics.filesChanged = afterValidateFiles.length;
 
+            const changedComponentTypes: string[] = [];
+
             // Build component types for any component that changes
             this.logger.time(LogLevel.info, ['Build component types'], () => {
-                for (let { componentKey, componentName } of this.componentSymbolsToUpdate) {
-                    this.updateComponentSymbolInGlobalScope(componentKey, componentName);
+                for (let [componentKey, componentName] of this.componentSymbolsToUpdate.entries()) {
+                    if (this.updateComponentSymbolInGlobalScope(componentKey, componentName)) {
+                        changedComponentTypes.push(util.getSgNodeTypeName(componentName).toLowerCase());
+                    }
                 }
                 this.componentSymbolsToUpdate.clear();
             });
 
+            // get set of changed symbols
+            const changedSymbols = new Map<SymbolTypeFlag, Set<string>>();
+            metrics.changedSymbolsTime = validationStopwatch.getDurationTextFor(() => {
+
+                const changedSymbolsMapArr = [...brsFilesValidated, ...xmlFilesValidated]?.map(f => {
+                    if (isBrsFile(f)) {
+                        return f.providedSymbols.changes;
+                    }
+                    return null;
+                }).filter(x => x);
+
+                // update the map of typetime dependencies
+                for (const file of brsFilesValidated) {
+                    for (const [symbolName, provided] of file.providedSymbols.symbolMap.get(SymbolTypeFlag.typetime).entries()) {
+                        // clear existing dependencies
+                        for (const values of this.symbolDependencies.values()) {
+                            values.delete(symbolName);
+                        }
 
-            const changedSymbolsMapArr = brsFilesValidated?.map(f => {
-                if (isBrsFile(f)) {
-                    return f.providedSymbols.changes;
+                        // map types to the set of types that depend upon them
+                        for (const dependentSymbol of provided.requiredSymbolNames?.values() ?? []) {
+                            const dependentSymbolLower = dependentSymbol.toLowerCase();
+                            if (!this.symbolDependencies.has(dependentSymbolLower)) {
+                                this.symbolDependencies.set(dependentSymbolLower, new Set<string>());
+                            }
+                            const symbolsDependentUpon = this.symbolDependencies.get(dependentSymbolLower);
+                            symbolsDependentUpon.add(symbolName);
+                        }
+                    }
                 }
-                return null;
-            }).filter(x => x);
 
-            const changedSymbols = new Map<SymbolTypeFlag, Set<string>>();
-            for (const flag of [SymbolTypeFlag.runtime, SymbolTypeFlag.typetime]) {
-                const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
-                changedSymbols.set(flag, new Set(...changedSymbolsSetArr));
-            }
+                for (const flag of [SymbolTypeFlag.runtime, SymbolTypeFlag.typetime]) {
+                    const changedSymbolsSetArr = changedSymbolsMapArr.map(symMap => symMap.get(flag));
+                    const changedSymbolSet = new Set<string>();
+                    for (const changeSet of changedSymbolsSetArr) {
+                        for (const change of changeSet) {
+                            changedSymbolSet.add(change);
+                        }
+                    }
+                    changedSymbols.set(flag, changedSymbolSet);
+                }
+
+                // update changed symbol set with any changed component
+                for (const changedComponentType of changedComponentTypes) {
+                    changedSymbols.get(SymbolTypeFlag.typetime).add(changedComponentType);
+                }
+
+                // Add any additional types that depend on a changed type
+                // as each iteration of the loop might add new types, need to keep checking until nothing new is added
+                const dependentTypesChanged = new Set<string>();
+                let foundDependentTypes = false;
+                const changedTypeSymbols = changedSymbols.get(SymbolTypeFlag.typetime);
+                do {
+                    foundDependentTypes = false;
+                    const allChangedTypesSofar = [...Array.from(changedTypeSymbols), ...Array.from(dependentTypesChanged)];
+                    for (const changedSymbol of allChangedTypesSofar) {
+                        const symbolsDependentUponChangedSymbol = this.symbolDependencies.get(changedSymbol) ?? [];
+                        for (const symbolName of symbolsDependentUponChangedSymbol) {
+                            if (!changedTypeSymbols.has(symbolName) && !dependentTypesChanged.has(symbolName)) {
+                                foundDependentTypes = true;
+                                dependentTypesChanged.add(symbolName);
+                            }
+                        }
+                    }
+                } while (foundDependentTypes);
+
+                changedSymbols.set(SymbolTypeFlag.typetime, new Set([...changedTypeSymbols, ...dependentTypesChanged]));
+            }).durationText;
 
+            if (this.options.logLevel === LogLevel.debug) {
+                const changedRuntime = Array.from(changedSymbols.get(SymbolTypeFlag.runtime)).sort();
+                this.logger.debug('Changed Symbols (runTime):', changedRuntime.join(', '));
+                const changedTypetime = Array.from(changedSymbols.get(SymbolTypeFlag.typetime)).sort();
+                this.logger.debug('Changed Symbols (typeTime):', changedTypetime.join(', '));
+            }
             const filesToBeValidatedInScopeContext = new Set<BscFile>(afterValidateFiles);
 
             metrics.crossScopeValidationTime = validationStopwatch.getDurationTextFor(() => {
-                const scopesToCheck = this.getScopesForCrossScopeValidation();
+                const scopesToCheck = this.getScopesForCrossScopeValidation(changedComponentTypes.length > 0);
                 this.crossScopeValidation.buildComponentsMap();
                 this.crossScopeValidation.addDiagnosticsForScopes(scopesToCheck);
                 const filesToRevalidate = this.crossScopeValidation.getFilesRequiringChangedSymbol(scopesToCheck, changedSymbols);
@@ -919,22 +1085,26 @@ export class Program {
             let validationTime = 0;
             let scopesValidated = 0;
             let changedFiles = new Set<BscFile>(afterValidateFiles);
+            this.currentScopeValidationOptions = {
+                filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
+                changedSymbols: changedSymbols,
+                changedFiles: changedFiles,
+                initialValidation: this.isFirstValidation
+            };
             this.logger.time(LogLevel.info, ['Validate all scopes'], () => {
                 //sort the scope names so we get consistent results
                 const scopeNames = this.getSortedScopeNames();
                 for (const file of filesToBeValidatedInScopeContext) {
                     if (isBrsFile(file)) {
                         file.validationSegmenter.unValidateAllSegments();
+                        for (const scope of this.getScopesForFile(file)) {
+                            scope.invalidate();
+                        }
                     }
                 }
                 for (let scopeName of scopeNames) {
                     let scope = this.scopes[scopeName];
-                    const scopeValidated = scope.validate({
-                        filesToBeValidatedInScopeContext: filesToBeValidatedInScopeContext,
-                        changedSymbols: changedSymbols,
-                        changedFiles: changedFiles,
-                        initialValidation: this.isFirstValidation
-                    });
+                    const scopeValidated = scope.validate(this.currentScopeValidationOptions);
                     if (scopeValidated) {
                         scopesValidated++;
                     }
@@ -970,11 +1140,11 @@ export class Program {
         this.logger.info(`Validation Metrics: ${logs.join(', ')}`);
     }
 
-    private getScopesForCrossScopeValidation() {
+    private getScopesForCrossScopeValidation(someComponentTypeChanged = false) {
         const scopesForCrossScopeValidation = [];
         for (let scopeName of this.getSortedScopeNames()) {
             let scope = this.scopes[scopeName];
-            if (this.globalScope !== scope && !scope.isValidated) {
+            if (this.globalScope !== scope && (someComponentTypeChanged || !scope.isValidated)) {
                 scopesForCrossScopeValidation.push(scope);
             }
         }
diff --git a/src/Scope.spec.ts b/src/Scope.spec.ts
index 4093e116b..4c9dba3b1 100644
--- a/src/Scope.spec.ts
+++ b/src/Scope.spec.ts
@@ -3390,7 +3390,7 @@ describe('Scope', () => {
         });
 
         describe('callFunc invocations', () => {
-            it('TODO: should set correct return type', () => {
+            it('should set correct return type', () => {
 
                 program.setFile('components/Widget.xml', trim`
                     <?xml version="1.0" encoding="utf-8" ?>
@@ -3421,8 +3421,102 @@ describe('Scope', () => {
                 const opts = { flags: SymbolTypeFlag.runtime };
                 const sourceScope = program.getScopeByName('source');
                 sourceScope.linkSymbolTable();
-                //TODO: This *SHOULD* be float, but callfunc returns aren't inferred yet
-                expectTypeToBe(symbolTable.getSymbolType('pi', opts), DynamicType);
+                expectTypeToBe(symbolTable.getSymbolType('pi', opts), FloatType);
+                sourceScope.unlinkSymbolTable();
+            });
+
+            it('should set correct return type when using `callFunc()`', () => {
+                program.setFile('components/Widget.xml', trim`
+                    <?xml version="1.0" encoding="utf-8" ?>
+                    <component name="Widget" extends="Group">
+                        <script uri="Widget.brs"/>
+                        <interface>
+                            <function name="getFloatFromString" />
+                        </interface>
+                    </component>
+                `);
+
+                program.setFile('components/Widget.brs', `
+                    function getFloatFromString(input as string) as float
+                        return input.toFloat()
+                    end function
+                `);
+
+                let utilFile = program.setFile<BrsFile>('source/util.bs', `
+                    sub someFunc(widget as roSGNodeWidget)
+                        pi = widget.callfunc("getFloatFromString", "3.14")
+                        print pi
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                const processFnScope = utilFile.getFunctionScopeAtPosition(util.createPosition(3, 31));
+                const symbolTable = processFnScope.symbolTable;
+                const opts = { flags: SymbolTypeFlag.runtime };
+                const sourceScope = program.getScopeByName('source');
+                sourceScope.linkSymbolTable();
+                expectTypeToBe(symbolTable.getSymbolType('pi', opts), FloatType);
+                sourceScope.unlinkSymbolTable();
+            });
+
+            it('should set correct return type when using `<component>.createchild()`', () => {
+                let utilFile = program.setFile<BrsFile>('source/util.bs', `
+                    sub someFunc()
+                        rect = createObject("roSgNode", "Rectangle")
+                        label = rect.createChild("label")
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                const processFnScope = utilFile.getFunctionScopeAtPosition(util.createPosition(3, 31));
+                const symbolTable = processFnScope.symbolTable;
+                const opts = { flags: SymbolTypeFlag.runtime };
+                const sourceScope = program.getScopeByName('source');
+                sourceScope.linkSymbolTable();
+                const labelType = symbolTable.getSymbolType('label', opts) as ComponentType;
+                expectTypeToBe(labelType, ComponentType);
+                expect(labelType.toString()).to.eql('roSGNodeLabel');
+                sourceScope.unlinkSymbolTable();
+            });
+
+            it('should set correct return type with a custom type', () => {
+                program.setFile('components/Widget.xml', trim`
+                    <?xml version="1.0" encoding="utf-8" ?>
+                    <component name="Widget" extends="Group">
+                        <script uri="Widget.bs"/>
+                        <interface>
+                            <function name="getWidgetType" />
+                        </interface>
+                    </component>
+                `);
+
+                program.setFile('components/Widget.bs', `
+                    interface WidgetInternal
+                       name as string
+                    end interface
+
+                    function getWidgetType(input as string) as WidgetInternal
+                        return {name: input}
+                    end function
+                `);
+
+                let utilFile = program.setFile<BrsFile>('source/util.bs', `
+                    sub someFunc(widget as roSGNodeWidget)
+                        thing = widget@.getWidgetType("hello")
+                        print thing
+                    end sub
+                `);
+                program.validate();
+                expectZeroDiagnostics(program);
+                const processFnScope = utilFile.getFunctionScopeAtPosition(util.createPosition(3, 31));
+                const symbolTable = processFnScope.symbolTable;
+                const opts = { flags: SymbolTypeFlag.runtime };
+                const sourceScope = program.getScopeByName('source');
+                sourceScope.linkSymbolTable();
+                const thingType = symbolTable.getSymbolType('thing', opts) as InterfaceType;
+
+                expectTypeToBe(thingType, InterfaceType);
+                expect(thingType.name).to.eq('WidgetInternal');
                 sourceScope.unlinkSymbolTable();
             });
         });
diff --git a/src/SymbolTable.ts b/src/SymbolTable.ts
index 4457d26ca..f84ca3c6c 100644
--- a/src/SymbolTable.ts
+++ b/src/SymbolTable.ts
@@ -49,6 +49,7 @@ export class SymbolTable implements SymbolTypeGetter {
      * Push a function that will provide a parent SymbolTable when requested
      */
     public pushParentProvider(provider: SymbolTableProvider) {
+        this.cachedCircularReferenceCheck = null;
         this.parentProviders.push(provider);
         return () => {
             this.popParentProvider();
@@ -59,6 +60,7 @@ export class SymbolTable implements SymbolTypeGetter {
      * Pop the current parentProvider
      */
     public popParentProvider() {
+        this.cachedCircularReferenceCheck = null;
         this.parentProviders.pop();
     }
 
@@ -233,6 +235,7 @@ export class SymbolTable implements SymbolTypeGetter {
             options.data.isAlias = data?.isAlias;
             options.data.isInstance = data?.isInstance;
             options.data.isFromDocComment = data?.isFromDocComment;
+            options.data.isFromCallFunc = data?.isFromCallFunc;
         }
         return resolvedType;
     }
@@ -303,6 +306,23 @@ export class SymbolTable implements SymbolTypeGetter {
         return symbols;
     }
 
+
+    private cachedCircularReferenceCheck: null | boolean = null;
+
+    private hasCircularReferenceWithAncestor() {
+        if (this.cachedCircularReferenceCheck === false || this.cachedCircularReferenceCheck === true) {
+            return this.cachedCircularReferenceCheck;
+        }
+        let foundCircReference = false;
+        let p = this.parent;
+        while (!foundCircReference && p) {
+            foundCircReference = p === this;
+            p = p.parent;
+        }
+        this.cachedCircularReferenceCheck = foundCircReference;
+        return foundCircReference;
+    }
+
     /**
      * Get list of all symbols declared in this SymbolTable (includes parent SymbolTable).
      */
@@ -312,7 +332,8 @@ export class SymbolTable implements SymbolTypeGetter {
         for (let sibling of this.siblings) {
             symbols = symbols.concat(sibling.getAllSymbols(bitFlags));
         }
-        if (this.parent) {
+
+        if (this.parent && !this.hasCircularReferenceWithAncestor()) {
             symbols = symbols.concat(this.parent.getAllSymbols(bitFlags));
         }
         // eslint-disable-next-line no-bitwise
@@ -410,6 +431,7 @@ export interface SymbolTypeGetter {
     name: string;
     getSymbolType(name: string, options: GetSymbolTypeOptions): BscType;
     setCachedType(name: string, cacheEntry: TypeCacheEntry, options: GetSymbolTypeOptions);
+    addSibling(symbolTable: SymbolTable);
 }
 
 /**
diff --git a/src/XmlScope.ts b/src/XmlScope.ts
index 01df69b84..480aa6cd8 100644
--- a/src/XmlScope.ts
+++ b/src/XmlScope.ts
@@ -7,6 +7,7 @@ import type { BscFile } from './files/BscFile';
 import { DynamicType } from './types/DynamicType';
 import type { BaseFunctionType } from './types/BaseFunctionType';
 import { ComponentType } from './types/ComponentType';
+import type { ExtraSymbolData } from './interfaces';
 
 export class XmlScope extends Scope {
     constructor(
@@ -56,13 +57,9 @@ export class XmlScope extends Scope {
         //add functions
         for (const func of iface.functions ?? []) {
             if (func.name) {
-                const componentFuncType = this.symbolTable.getSymbolType(func.name, { flags: SymbolTypeFlag.runtime, fullName: func.name, tableProvider: () => this.symbolTable });
-                // TODO: Get correct function type, and fully resolve all param and return types of function
-                // eg.:
-                // callFuncType = new CallFuncType(componentFuncType) // does something to fully resolve & store all associated types
-
-                //TODO: add documentation - need to get previous comment from XML
-                result.addCallFuncMember(func.name, {}, componentFuncType as BaseFunctionType, SymbolTypeFlag.runtime);
+                const extraData: ExtraSymbolData = {};
+                const componentFuncType = this.symbolTable.getSymbolType(func.name, { flags: SymbolTypeFlag.runtime, data: extraData, fullName: func.name, tableProvider: () => this.symbolTable });
+                result.addCallFuncMember(func.name, extraData, componentFuncType as BaseFunctionType, SymbolTypeFlag.runtime, () => this.symbolTable);
             }
         }
         //add fields
diff --git a/src/bscPlugin/completions/CompletionsProcessor.spec.ts b/src/bscPlugin/completions/CompletionsProcessor.spec.ts
index 39a34a3a7..6cd784ca4 100644
--- a/src/bscPlugin/completions/CompletionsProcessor.spec.ts
+++ b/src/bscPlugin/completions/CompletionsProcessor.spec.ts
@@ -1824,7 +1824,7 @@ describe('CompletionsProcessor', () => {
             expect(completions.length).to.eql(1);
             expectCompletionsIncludes(completions, [{
                 label: 'someFunc',
-                kind: CompletionItemKind.Function
+                kind: CompletionItemKind.Method
             }]);
         });
 
@@ -1855,10 +1855,118 @@ describe('CompletionsProcessor', () => {
             expect(completions.length).to.eql(1);
             expectCompletionsIncludes(completions, [{
                 label: 'someFunc',
-                kind: CompletionItemKind.Function,
+                kind: CompletionItemKind.Method,
                 documentation: 'This is documentation'
             }]);
         });
+
+        it('does not include callfunc members for other components', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                     <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Widget.bs', `
+                function someFunc(input as string) as float
+                    return input.toFloat()
+                end function
+            `);
+            program.setFile('components/Thing.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Thing" extends="Group">
+                     <script uri="Thing.bs"/>
+                    <interface>
+                        <function name="otherFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Thing.bs', `
+                function otherFunc(input as string) as float
+                    return input.toFloat()
+                end function
+            `);
+
+            program.setFile('source/util.bs', `
+                sub callWidgetSomeFunc(widget as roSGNodeWidget)
+                    print widget@.
+                end sub
+            `);
+            program.validate();
+            // print widget@.|
+            let completions = program.getCompletions('source/util.bs', util.createPosition(2, 34));
+            expect(completions.length).to.eql(1);
+            expectCompletionsIncludes(completions, [{
+                label: 'someFunc',
+                kind: CompletionItemKind.Method
+            }]);
+            expectCompletionsExcludes(completions, [{
+                label: 'otherFunc',
+                kind: CompletionItemKind.Method
+            }]);
+        });
+
+        it('includes all possible callfuncs when used on a generic type', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                     <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Widget.bs', `
+                function someFunc(input as string) as float
+                    return input.toFloat()
+                end function
+            `);
+            program.setFile('components/Thing.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Thing" extends="Group">
+                     <script uri="Thing.bs"/>
+                    <interface>
+                        <function name="otherFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Thing.bs', `
+                function otherFunc(input as string) as float
+                    return input.toFloat()
+                end function
+            `);
+
+            program.setFile('source/util.bs', `
+                sub useCallfunc(dyn as dynamic, obj as object, node as roSGNode)
+                    print dyn@.
+                    print obj@.
+                    print node@.
+                end sub
+            `);
+            program.validate();
+            // print dyn@.|
+            let completions = program.getCompletions('source/util.bs', util.createPosition(2, 31));
+            const expectedCompletions = [{
+                label: 'someFunc',
+                kind: CompletionItemKind.Method
+            }, {
+                label: 'otherFunc',
+                kind: CompletionItemKind.Method
+            }];
+            expect(completions.length).to.eql(expectedCompletions.length);
+            expectCompletionsIncludes(completions, expectedCompletions);
+            // print obj@.|
+            completions = program.getCompletions('source/util.bs', util.createPosition(3, 31));
+            expect(completions.length).to.eql(expectedCompletions.length);
+            expectCompletionsIncludes(completions, expectedCompletions);
+            // print node@.|
+            completions = program.getCompletions('source/util.bs', util.createPosition(3, 32));
+            expect(completions.length).to.eql(expectedCompletions.length);
+            expectCompletionsIncludes(completions, expectedCompletions);
+        });
     });
 
     describe('type expressions', () => {
diff --git a/src/bscPlugin/completions/CompletionsProcessor.ts b/src/bscPlugin/completions/CompletionsProcessor.ts
index b8616e87f..f582a7187 100644
--- a/src/bscPlugin/completions/CompletionsProcessor.ts
+++ b/src/bscPlugin/completions/CompletionsProcessor.ts
@@ -433,7 +433,7 @@ export class CompletionsProcessor {
             const symbolNameLower = symbol?.name.toLowerCase();
             let nameMatchesType = symbolNameLower === finalTypeNameLower;
             if (isTypedFunctionType(type) && !nameMatchesType) {
-                if (symbolNameLower === type.name.replace(/\./gi, '_').toLowerCase()) {
+                if (symbolNameLower === type.name?.replace(/\./gi, '_').toLowerCase()) {
                     nameMatchesType = true;
                 }
             }
@@ -516,11 +516,11 @@ export class CompletionsProcessor {
         }));
     }
 
-    public createCompletionFromFunctionStatement(statement: FunctionStatement): CompletionItem {
+    public createCompletionFromFunctionStatement(statement: FunctionStatement, completionKind: CompletionItemKind = CompletionItemKind.Function): CompletionItem {
         const funcType = statement.getType({ flags: SymbolTypeFlag.runtime });
         return {
             label: statement.getName(ParseMode.BrighterScript),
-            kind: CompletionItemKind.Function,
+            kind: completionKind,
             detail: funcType.toString(),
             documentation: util.getNodeDocumentation(statement)
         };
@@ -601,12 +601,10 @@ export class CompletionsProcessor {
         const xmlScopes = this.event.program.getScopes().filter((s) => isXmlScope(s)) as XmlScope[];
         // is next to a @. callfunc invocation - must be an component interface method.
 
-
-        //TODO refactor this to utilize the actual variable's component type (when available)
         for (const scope of xmlScopes) {
             let fileLinks = this.event.program.getStatementsForXmlFile(scope);
             for (let fileLink of fileLinks) {
-                let pushItem = this.createCompletionFromFunctionStatement(fileLink.item);
+                let pushItem = this.createCompletionFromFunctionStatement(fileLink.item, CompletionItemKind.Method);
                 if (!completetionsLabels.includes(pushItem.label)) {
                     completetionsLabels.push(pushItem.label);
                     completionsArray.push(pushItem);
diff --git a/src/bscPlugin/hover/HoverProcessor.spec.ts b/src/bscPlugin/hover/HoverProcessor.spec.ts
index 9ff4a648e..0f409ad61 100644
--- a/src/bscPlugin/hover/HoverProcessor.spec.ts
+++ b/src/bscPlugin/hover/HoverProcessor.spec.ts
@@ -762,6 +762,34 @@ describe('HoverProcessor', () => {
             expect(hover?.contents).eql([fence('function roSGNodeWidget@.someFunc(input as string) as float')]);
         });
 
+        it('should include documentation on @callfunc hovers', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                     <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            const file = program.setFile('components/Widget.bs', `
+                sub foo()
+                    top = m.top as roSgNodeWidget
+                    print top@.someFunc("3.14")
+                end sub
+
+                ' Some Cool function
+                function someFunc(input as string) as float
+                    return input.toFloat()
+                end function
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+            // print top@.some|Func("3.14")
+            let hover = program.getHover(file.srcPath, util.createPosition(3, 35))[0];
+            expect(hover?.contents[0]).include('Some Cool function');
+        });
+
     });
 
     describe('multiple definition locations', () => {
diff --git a/src/bscPlugin/validation/BrsFileValidator.ts b/src/bscPlugin/validation/BrsFileValidator.ts
index e4c3ff0f4..865a32c84 100644
--- a/src/bscPlugin/validation/BrsFileValidator.ts
+++ b/src/bscPlugin/validation/BrsFileValidator.ts
@@ -109,7 +109,7 @@ export class BrsFileValidator {
                 const data: ExtraSymbolData = {};
                 //register this variable
                 const nodeType = node.getType({ flags: SymbolTypeFlag.runtime, data: data });
-                node.parent.getSymbolTable()?.addSymbol(node.tokens.name.text, { definingNode: node, isInstance: true, isFromDocComment: data.isFromDocComment }, nodeType, SymbolTypeFlag.runtime);
+                node.parent.getSymbolTable()?.addSymbol(node.tokens.name.text, { definingNode: node, isInstance: true, isFromDocComment: data.isFromDocComment, isFromCallFunc: data.isFromCallFunc }, nodeType, SymbolTypeFlag.runtime);
             },
             DottedSetStatement: (node) => {
                 this.validateNoOptionalChainingInVarSet(node, [node.obj]);
diff --git a/src/bscPlugin/validation/ScopeValidator.spec.ts b/src/bscPlugin/validation/ScopeValidator.spec.ts
index 47e350e03..ebc4ae6f2 100644
--- a/src/bscPlugin/validation/ScopeValidator.spec.ts
+++ b/src/bscPlugin/validation/ScopeValidator.spec.ts
@@ -203,6 +203,32 @@ describe('ScopeValidator', () => {
         });
 
         it('any number number of args on variadic (callFunc) functions', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.brs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Widget.brs', `
+                sub someFunc(input as object)
+                    print input
+                end sub
+            `);
+            program.setFile('source/util.bs', `
+                sub useCallFunc(input as roSGNodeWidget, funcToCall as string)
+                    input.callFunc(funcToCall, 1, 2, 3, {})
+                end sub
+            `);
+            program.validate();
+            // no error, because we can't know what function you're actually calling
+            expectZeroDiagnostics(program);
+        });
+
+
+        it('checks for target args count on callfunc', () => {
             program.setFile('components/Widget.xml', trim`
                 <?xml version="1.0" encoding="utf-8" ?>
                 <component name="Widget" extends="Group">
@@ -223,9 +249,9 @@ describe('ScopeValidator', () => {
                 end sub
             `);
             program.validate();
-            //TODO: do a better job of handling callFunc() invocations!
-            //should have an error
-            expectZeroDiagnostics(program);
+            expectDiagnostics(program, [
+                DiagnosticMessages.mismatchArgumentCount(2, 5)
+            ]);
         });
 
         it('validates against scope-defined func in inner namespace, when outer namespace has same named func', () => {
@@ -3637,6 +3663,232 @@ describe('ScopeValidator', () => {
                 DiagnosticMessages.cannotFindName('missingBool2', undefined, 'MediaObject').message
             ]);
         });
+
+        it('rechecks source when member type of import changes', () => {
+            // notice that width is wrongly typed as a boolean
+            program.setFile('source/type1.bs', `
+                interface SubType
+                    value as string
+                end interface
+            `);
+
+            program.setFile('source/type2.bs', `
+                interface ParentType
+                    child as Subtype
+                end interface
+            `);
+
+            program.setFile('source/main.bs', `
+                sub foo(input as ParentType)
+                    input.child.value = 1
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.assignmentTypeMismatch('integer', 'string').message
+            ]);
+
+            // fix width field type to integer
+            program.setFile('source/type1.bs', `
+                interface SubType
+                    value as integer
+                end interface
+            `);
+            program.validate();
+
+            // there should be no more errors
+            expectZeroDiagnostics(program);
+        });
+
+        it('rechecks component source when xml changes', () => {
+            // notice that width is wrongly typed as a boolean
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <field id="width" type="boolean" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                interface IWidget
+                    top as roSGNodeWidget
+                    data as roAssociativeArray
+                end interface
+
+                sub init()
+                    (m as IWidget).top.width =  100
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.assignmentTypeMismatch('integer', 'boolean').message
+            ]);
+
+            // fix width field type to integer
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <field id="width" type="integer" />
+                    </interface>
+                </component>
+            `);
+            program.validate();
+
+            // there should be no more errors
+            expectZeroDiagnostics(program);
+        });
+
+        it('rechecks complete file when type of typecasted m changes indirectly', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <interface>
+                        <field id="width" type="boolean" />
+                    </interface>
+                </component>
+            `);
+
+
+            // notice that width is wrongly typed as a boolean
+            program.setFile('components/WidgetContainer.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="WidgetContainer" extends="Group">
+                    <script uri="WidgetContainer.bs"/>
+                </component>
+            `);
+            program.setFile('components/WidgetContainerTypes.bs', `
+                interface IWidgetContainer
+                    top as roSGNodeWidgetContainer
+                    widget as roSGNodeWidget
+                end interface
+            `);
+
+            program.setFile('components/WidgetContainer.bs', `
+                import "WidgetContainerTypes.bs"
+                typecast m as IWidgetContainer
+
+                sub init()
+                    m.widget.width =  100
+                end sub
+            `);
+
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.assignmentTypeMismatch('integer', 'boolean').message
+            ]);
+
+            // fix width field type to integer
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <interface>
+                        <field id="width" type="integer" />
+                    </interface>
+                </component>
+            `);
+            program.validate();
+
+            // there should be no more errors
+            expectZeroDiagnostics(program);
+        });
+
+        it('rechecks file using callfunc when exported function type of xml changes', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="foo" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                sub foo(input as string)
+                    print input
+                end sub
+            `);
+
+
+            program.setFile('source/callFoo.bs', `
+                sub callFoo(widget as roSGNodeWidget)
+                    widget@.foo(123) ' foo expects string
+                end sub
+            `);
+
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.argumentTypeMismatch('integer', 'string').message
+            ]);
+
+            // fix function
+            program.setFile('components/Widget.bs', `
+                sub foo(input as integer)
+                    print input
+                end sub
+            `);
+            program.validate();
+
+            // there should be no more errors
+            expectZeroDiagnostics(program);
+        });
+
+        it('rechecks complete file when type of typecasted m  in same file changes indirectly', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <interface>
+                        <field id="width" type="boolean" />
+                    </interface>
+                </component>
+            `);
+
+
+            // notice that width is wrongly typed as a boolean
+            program.setFile('components/WidgetContainer.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="WidgetContainer" extends="Group">
+                    <script uri="WidgetContainer.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/WidgetContainer.bs', `
+                typecast m as IWidgetContainer
+
+                 interface IWidgetContainer
+                    top as roSGNodeWidgetContainer
+                    widget as roSGNodeWidget
+                end interface
+
+                sub init()
+                    m.widget.width =  100
+                end sub
+            `);
+
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.assignmentTypeMismatch('integer', 'boolean').message
+            ]);
+
+            // fix width field type to integer
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <interface>
+                        <field id="width" type="integer" />
+                    </interface>
+                </component>
+            `);
+            program.validate();
+
+            // there should be no more errors
+            expectZeroDiagnostics(program);
+        });
     });
 
 
@@ -3708,4 +3960,503 @@ describe('ScopeValidator', () => {
         });
     });
 
+    describe('callFunc', () => {
+        it('allows access to member of return type when return type is custom node', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getOther" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getOther(name as string) as roSgNodeOther
+                    other =  createObject("roSgNode", "Other")
+                    other.myValue = name
+                    return other
+                end function
+            `);
+
+            program.setFile('components/Other.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Other" extends="Group">
+                    <interface>
+                        <field id="myValue" type="string" />
+                    </interface>
+                </component>
+            `);
+
+
+            program.setFile('components/MainScene.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="MainScene" extends="Scene">
+                    <script uri="MainScene.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/MainScene.bs', `
+                sub someFunc(widget as roSGNodeWidget)
+                    otherNode = widget@.getOther("3.14")
+                    print otherNode.myValue
+                end sub
+            `);
+
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows access to member of return type when return type is custom type', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getOther" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/types.bs', `
+                interface SomeIFace
+                   myValue as string
+                end interface
+            `);
+
+            program.setFile('components/Widget.bs', `
+                import "pkg:/components/types.bs"
+
+                function getOther(name as string) as SomeIFace
+                    other = {myValue: name} as SomeIface
+                    other.myValue = name
+                    return other
+                end function
+            `);
+
+            program.setFile('components/MainScene.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="MainScene" extends="Scene">
+                    <script uri="MainScene.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/MainScene.bs', `
+                sub someFunc(widget as roSGNodeWidget)
+                    otherNode = widget@.getOther("3.14")
+                    print otherNode.myValue
+                end sub
+            `);
+
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows access to custom type member of return type when return type is custom type', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getOther" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/types.bs', `
+                interface SomeIFace
+                   subFace as SubIface
+                end interface
+
+                interface SubIface
+                    myValue as string
+                end interface
+            `);
+
+            program.setFile('components/Widget.bs', `
+                import "pkg:/components/types.bs"
+
+                function getOther(name as string) as SomeIFace
+                    other = {subFace: {myValue: name}} as SomeIface
+                    return other
+                end function
+            `);
+
+            program.setFile('components/MainScene.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="MainScene" extends="Scene">
+                    <script uri="MainScene.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/MainScene.bs', `
+                sub someFunc(widget as roSGNodeWidget)
+                    otherNode = widget@.getOther("3.14")
+                    print otherNode.subFace.myValue
+                end sub
+            `);
+
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('correctly finds error with using unknown member of callfunc return type when return type is custom type', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getOther" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/types.bs', `
+                interface SomeIFace
+                   subFace as SubIface
+                end interface
+
+                interface SubIface
+                    myValue as string
+                end interface
+            `);
+
+            program.setFile('components/Widget.bs', `
+                import "pkg:/components/types.bs"
+
+                function getOther(name as string) as SomeIFace
+                    other = {subFace: {myValue: name}} as SomeIface
+                    return other
+                end function
+            `);
+
+            program.setFile('components/MainScene.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="MainScene" extends="Scene">
+                    <script uri="MainScene.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/MainScene.bs', `
+                sub someFunc(widget as roSGNodeWidget)
+                    otherNode = widget@.getOther("3.14")
+                    print otherNode.subFace.notIncluded
+                end sub
+            `);
+
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindName('notIncluded', 'SubIface.notIncluded', 'SubIface').message
+            ]);
+        });
+
+        it('catches when a non-component type has callfunc invocation', () => {
+            program.setFile('source/test.bs', `
+                sub printName(widget as integer)
+                    print widget@.toStr()
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindCallFuncFunction('toStr', 'integer@.toStr', 'integer').message
+            ]);
+        });
+
+        it('allows to types that reference themselves', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getList" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/types.bs', `
+                interface LinkedList
+                    value as integer
+                    optional data as roAssociativeArray
+                    optional next as LinkedList
+                end interface
+            `);
+
+            program.setFile('components/Widget.bs', `
+                import "pkg:/components/types.bs"
+
+                function getList() as LinkedList
+                    list  = {
+                        value: 1,
+                        next: {
+                            value: 2,
+                            next: {
+                                value: 3
+                            }
+                        }
+                    } as LinkedList
+                    return list
+                end function
+            `);
+
+            program.setFile('components/MainScene.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="MainScene" extends="Scene">
+                    <script uri="MainScene.bs"/>
+                </component>
+            `);
+
+            program.setFile('components/MainScene.bs', `
+                sub someFunc(widget as roSGNodeWidget)
+                    list = widget@.getList()
+                    print list.next.next.value
+                end sub
+            `);
+
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('finds invalid func name of callfunc()', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName() as string
+                    return "John Doe"
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub printName(widget as roSGNodeWidget)
+                    print widget.callFunc("whatever")
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindCallFuncFunction('whatever', 'roSGNodeWidget@.whatever', 'roSGNodeWidget').message
+            ]);
+        });
+
+        it('finds invalid func name of @ callfunc invocation', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName() as string
+                    return "John Doe"
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub printName(widget as roSGNodeWidget)
+                    print widget@.whatever()
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindCallFuncFunction('whatever', 'roSGNodeWidget@.whatever', 'roSGNodeWidget').message
+            ]);
+        });
+
+        it('catches func name of callfunc() with spaces', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName() as string
+                    return "John Doe"
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub printName(widget as roSGNodeWidget)
+                    print widget.callFunc("whatever the name is")
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindCallFuncFunction('whatever the name is', 'roSGNodeWidget@.whatever the name is', 'roSGNodeWidget').message
+            ]);
+        });
+
+        it('validates arg type of callfunc()', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName(name as string, count as integer) as string
+                    return "John Doe"
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub printName(widget as roSGNodeWidget)
+                    print widget.callFunc("getName", 12, "not int")
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.argumentTypeMismatch('integer', 'string').message,
+                DiagnosticMessages.argumentTypeMismatch('string', 'integer').message
+            ]);
+        });
+
+        it('has no error on plain roSGNode', () => {
+            program.setFile('source/test.bs', `
+                sub doCallfunc(nodeName as string)
+                    node = createObject("roSgNode", nodeName)
+                    node.callfunc("someFunc", 1, 2, 3)
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('has error on regular builtIn types', () => {
+            program.setFile('source/test.bs', `
+                sub doCallfunc()
+                    node = createObject("roSgNode", "Rectangle")
+                    node.callfunc("someFunc", 1, 2, 3)
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.cannotFindCallFuncFunction('someFunc', 'roSGNodeRectangle@.someFunc', 'roSGNodeRectangle')
+            ]);
+        });
+
+        it('allows callfunc on flexible types', () => {
+            program.setFile('source/test.bs', `
+                sub doCallfunc(obj as object, dyn as dynamic, node as roSGNode)
+                    obj.callfunc("testFunc")
+                    obj@.testFunc()
+
+                    dyn.callfunc("testFunc")
+                    dyn@.testFunc()
+
+                    node.callfunc("testFunc")
+                    node@.testFunc()
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows callfunc on components from component library', () => {
+            program.setFile('source/test.bs', `
+                sub doCallfunc()
+                    fromComponentLibrary = CreateObject("roSGNode", "library:SomeComponent")
+                    fromComponentLibrary@.someFunc()
+                    fromComponentLibrary.callfunc("someFunc")
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('allows callfunc on the dynamic result of a function call', () => {
+            program.setFile('source/test.bs', `
+                sub doCallfunc(nodeName)
+                    getNode(nodeName)@.someCallFunc(1,2,3)
+                end sub
+
+                function getNode(nodeType)
+                    return CreateObject("roSGNode", nodeType)
+                end function
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
+
+        it('validates callfunc on a known result of a function call', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName(name as string, count as integer) as string
+                    return "John Doe"
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub doCallfunc()
+                    getWidget()@.getName("someStr", "not an int")
+                end sub
+
+                function getWidget() as roSGNodeWidget
+                    return CreateObject("roSGNode", "Widget")
+                end function
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.argumentTypeMismatch('string', 'integer').message
+            ]);
+        });
+
+        it('validates callfunc on a known result of a callfunc call', () => {
+            program.setFile('components/Widget.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <interface>
+                        <function name="getName" />
+                        <function name="getSelf" />
+                    </interface>
+                </component>
+            `);
+
+            program.setFile('components/Widget.bs', `
+                function getName(name as string, count as integer) as string
+                    return "John Doe"
+                end function
+
+                function getSelf() as roSGNodeWidget
+                    return m.top
+                end function
+            `);
+
+            program.setFile('source/test.bs', `
+                sub doCallfunc(widget as roSGNodeWidget)
+                    widget@.getSelf()@.getName("someStr", "not an int")
+                end sub
+            `);
+            program.validate();
+            expectDiagnostics(program, [
+                DiagnosticMessages.argumentTypeMismatch('string', 'integer').message
+            ]);
+        });
+    });
 });
+
diff --git a/src/bscPlugin/validation/ScopeValidator.ts b/src/bscPlugin/validation/ScopeValidator.ts
index d756b3992..eb444eee0 100644
--- a/src/bscPlugin/validation/ScopeValidator.ts
+++ b/src/bscPlugin/validation/ScopeValidator.ts
@@ -13,7 +13,7 @@ import type { Token } from '../../lexer/Token';
 import { AstNodeKind } from '../../parser/AstNode';
 import type { AstNode } from '../../parser/AstNode';
 import type { Expression } from '../../parser/AstNode';
-import type { VariableExpression, DottedGetExpression, BinaryExpression, UnaryExpression, NewExpression, LiteralExpression, FunctionExpression } from '../../parser/Expression';
+import type { VariableExpression, DottedGetExpression, BinaryExpression, UnaryExpression, NewExpression, LiteralExpression, FunctionExpression, CallfuncExpression } from '../../parser/Expression';
 import { CallExpression } from '../../parser/Expression';
 import { createVisitor, WalkMode } from '../../astUtils/visitors';
 import type { BscType } from '../../types/BscType';
@@ -31,6 +31,7 @@ import { VoidType } from '../../types/VoidType';
 import { BscTypeKind } from '../../types/BscTypeKind';
 import type { BrsDocWithType } from '../../parser/BrightScriptDocParser';
 import brsDocParser from '../../parser/BrightScriptDocParser';
+import type { Location } from 'vscode-languageserver';
 
 /**
  * The lower-case names of all platform-included scenegraph nodes
@@ -133,8 +134,12 @@ export class ScopeValidator {
                         this.validateVariableAndDottedGetExpressions(file, dottedGet);
                     },
                     CallExpression: (functionCall) => {
-                        this.validateFunctionCall(file, functionCall);
+                        this.validateCallExpression(file, functionCall);
                         this.validateCreateObjectCall(file, functionCall);
+                        this.validateComponentMethods(file, functionCall);
+                    },
+                    CallfuncExpression: (functionCall) => {
+                        this.validateCallFuncExpression(file, functionCall);
                     },
                     ReturnStatement: (returnStatement) => {
                         this.validateReturnStatement(file, returnStatement);
@@ -288,18 +293,8 @@ export class ScopeValidator {
         //if this is a `createObject('roSGNode'` call, only support known sg node types
         if (firstParamStringValueLower === 'rosgnode' && isLiteralExpression(call?.args[1])) {
             const componentName: Token = call?.args[1]?.tokens.value;
-            //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
-            if (!componentName || componentName?.text?.includes(':')) {
-                return;
-            }
-            //add diagnostic for unknown components
-            const unquotedComponentName = componentName?.text?.replace(/"/g, '');
-            if (unquotedComponentName && !platformNodeNames.has(unquotedComponentName.toLowerCase()) && !this.event.program.getComponent(unquotedComponentName)) {
-                this.addDiagnostic({
-                    ...DiagnosticMessages.unknownRoSGNode(unquotedComponentName),
-                    location: componentName.location
-                });
-            } else if (call?.args.length !== 2) {
+            this.checkComponentName(componentName);
+            if (call?.args.length !== 2) {
                 // roSgNode should only ever have 2 args in `createObject`
                 this.addDiagnostic({
                     ...DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, [2], call?.args.length),
@@ -340,68 +335,159 @@ export class ScopeValidator {
 
     }
 
+    private checkComponentName(componentName: Token) {
+        //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
+        if (!componentName || componentName?.text?.includes(':')) {
+            return;
+        }
+        //add diagnostic for unknown components
+        const unquotedComponentName = componentName?.text?.replace(/"/g, '');
+        if (unquotedComponentName && !platformNodeNames.has(unquotedComponentName.toLowerCase()) && !this.event.program.getComponent(unquotedComponentName)) {
+            this.addDiagnostic({
+                ...DiagnosticMessages.unknownRoSGNode(unquotedComponentName),
+                location: componentName.location
+            });
+        }
+    }
+
     /**
-     * Detect calls to functions with the incorrect number of parameters, or wrong types of arguments
+     * Validate every method call to `component.callfunc()`, `component.createChild()`, etc.
      */
-    private validateFunctionCall(file: BrsFile, expression: CallExpression) {
+    protected validateComponentMethods(file: BrsFile, call: CallExpression) {
+        const lowerMethodNamesChecked = ['callfunc', 'createchild'];
+        if (!isDottedGetExpression(call.callee)) {
+            return;
+        }
+
+        const callName = call.callee.tokens?.name?.text?.toLowerCase();
+        if (!callName || !lowerMethodNamesChecked.includes(callName) || !isLiteralExpression(call?.args[0])) {
+            return;
+        }
+
+        const callerType = call.callee.obj?.getType({ flags: SymbolTypeFlag.runtime });
+        if (!isComponentType(callerType)) {
+            return;
+        }
+        const firstArgToken = call?.args[0]?.tokens.value;
+        if (callName === 'createchild') {
+            this.checkComponentName(firstArgToken);
+        } else if (callName === 'callfunc' && !util.isGenericNodeType(callerType)) {
+            const funcType = util.getCallFuncType(call, firstArgToken, { flags: SymbolTypeFlag.runtime, ignoreCall: true });
+            if (!funcType?.isResolvable()) {
+                const functionName = firstArgToken.text.replace(/"/g, '');
+                const functionFullname = `${callerType.toString()}@.${functionName}`;
+                this.addMultiScopeDiagnostic({
+                    ...DiagnosticMessages.cannotFindCallFuncFunction(functionName, functionFullname, callerType.toString()),
+                    location: firstArgToken?.location
+                });
+            } else {
+                this.validateFunctionCall(file, funcType, firstArgToken.location, call.args, 1);
+            }
+        }
+    }
+
+
+    private validateCallExpression(file: BrsFile, expression: CallExpression) {
         const getTypeOptions = { flags: SymbolTypeFlag.runtime, data: {} };
         let funcType = this.getNodeTypeWrapper(file, expression?.callee, getTypeOptions);
         if (funcType?.isResolvable() && isClassType(funcType)) {
             // We're calling a class - get the constructor
             funcType = funcType.getMemberType('new', getTypeOptions);
         }
-        if (funcType?.isResolvable() && isTypedFunctionType(funcType)) {
-            //funcType.setName(expression.callee. .name);
-
-            //get min/max parameter count for callable
-            let minParams = 0;
-            let maxParams = 0;
-            for (let param of funcType.params) {
-                maxParams++;
-                //optional parameters must come last, so we can assume that minParams won't increase once we hit
-                //the first isOptional
-                if (param.isOptional !== true) {
-                    minParams++;
-                }
-            }
-            if (funcType.isVariadic) {
-                // function accepts variable number of arguments
-                maxParams = CallExpression.MaximumArguments;
-            }
-            let expCallArgCount = expression.args.length;
-            if (expCallArgCount > maxParams || expCallArgCount < minParams) {
-                let minMaxParamsText = minParams === maxParams ? maxParams : `${minParams}-${maxParams}`;
-                this.addMultiScopeDiagnostic({
-                    ...DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount),
-                    location: expression.callee.location
-                });
+        const callErrorLocation = expression?.callee?.location;
+        return this.validateFunctionCall(file, funcType, callErrorLocation, expression.args);
+
+    }
+
+    private validateCallFuncExpression(file: BrsFile, expression: CallfuncExpression) {
+        const callerType = expression.callee?.getType({ flags: SymbolTypeFlag.runtime });
+        if (isDynamicType(callerType)) {
+            return;
+        }
+        const methodToken = expression.tokens.methodName;
+        const methodName = methodToken?.text ?? '';
+        const functionFullname = `${callerType.toString()}@.${methodName}`;
+        const callErrorLocation = expression.location;
+        if (util.isGenericNodeType(callerType) || isObjectType(callerType) || isDynamicType(callerType)) {
+            // ignore "general" node
+            return;
+        }
+
+        if (!isComponentType(callerType)) {
+            this.addMultiScopeDiagnostic({
+                ...DiagnosticMessages.cannotFindCallFuncFunction(methodName, functionFullname, callerType.toString()),
+                location: callErrorLocation
+            });
+            return;
+        }
+
+        const funcType = util.getCallFuncType(expression, methodToken, { flags: SymbolTypeFlag.runtime, ignoreCall: true });
+        if (!funcType?.isResolvable()) {
+            this.addMultiScopeDiagnostic({
+                ...DiagnosticMessages.cannotFindCallFuncFunction(methodName, functionFullname, callerType.toString()),
+                location: callErrorLocation
+            });
+        }
+        return this.validateFunctionCall(file, funcType, callErrorLocation, expression.args);
+    }
+
+    /**
+     * Detect calls to functions with the incorrect number of parameters, or wrong types of arguments
+     */
+    private validateFunctionCall(file: BrsFile, funcType: BscType, callErrorLocation: Location, args: Expression[], argOffset = 0) {
+        if (!funcType?.isResolvable() || !isTypedFunctionType(funcType)) {
+            return;
+        }
+
+        //get min/max parameter count for callable
+        let minParams = 0;
+        let maxParams = 0;
+        for (let param of funcType.params) {
+            maxParams++;
+            //optional parameters must come last, so we can assume that minParams won't increase once we hit
+            //the first isOptional
+            if (param.isOptional !== true) {
+                minParams++;
             }
-            let paramIndex = 0;
-            for (let arg of expression.args) {
-                const data = {} as ExtraSymbolData;
-                let argType = this.getNodeTypeWrapper(file, arg, { flags: SymbolTypeFlag.runtime, data: data });
-
-                const paramType = funcType.params[paramIndex]?.type;
-                if (!paramType) {
-                    // unable to find a paramType -- maybe there are more args than params
-                    break;
-                }
+        }
+        if (funcType.isVariadic) {
+            // function accepts variable number of arguments
+            maxParams = CallExpression.MaximumArguments;
+        }
+        const argsForCall = argOffset < 1 ? args : args.slice(argOffset);
 
-                if (isCallableType(paramType) && isClassType(argType) && isClassStatement(data.definingNode)) {
-                    argType = data.definingNode.getConstructorType();
-                }
+        let expCallArgCount = argsForCall.length;
+        if (expCallArgCount > maxParams || expCallArgCount < minParams) {
+            let minMaxParamsText = minParams === maxParams ? maxParams + argOffset : `${minParams + argOffset}-${maxParams + argOffset}`;
+            this.addMultiScopeDiagnostic({
+                ...DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount + argOffset),
+                location: callErrorLocation
+            });
+        }
+        let paramIndex = 0;
+        for (let arg of argsForCall) {
+            const data = {} as ExtraSymbolData;
+            let argType = this.getNodeTypeWrapper(file, arg, { flags: SymbolTypeFlag.runtime, data: data });
+
+            const paramType = funcType.params[paramIndex]?.type;
+            if (!paramType) {
+                // unable to find a paramType -- maybe there are more args than params
+                break;
+            }
 
-                const compatibilityData: TypeCompatibilityData = {};
-                const isAllowedArgConversion = this.checkAllowedArgConversions(paramType, argType);
-                if (!isAllowedArgConversion && !paramType?.isTypeCompatible(argType, compatibilityData)) {
-                    this.addMultiScopeDiagnostic({
-                        ...DiagnosticMessages.argumentTypeMismatch(argType.toString(), paramType.toString(), compatibilityData),
-                        location: arg.location
-                    });
-                }
-                paramIndex++;
+            if (isCallableType(paramType) && isClassType(argType) && isClassStatement(data.definingNode)) {
+                argType = data.definingNode.getConstructorType();
             }
 
+            const compatibilityData: TypeCompatibilityData = {};
+            const isAllowedArgConversion = this.checkAllowedArgConversions(paramType, argType);
+            if (!isAllowedArgConversion && !paramType?.isTypeCompatible(argType, compatibilityData)) {
+                this.addMultiScopeDiagnostic({
+                    ...DiagnosticMessages.argumentTypeMismatch(argType.toString(), paramType.toString(), compatibilityData),
+                    location: arg.location
+                });
+            }
+            paramIndex++;
         }
     }
 
@@ -696,7 +782,7 @@ export class ScopeValidator {
                     }
                 } else {
                     const typeChainScan = util.processTypeChain(typeChain);
-                    //if this is a function call, provide a different diganostic code
+                    //if this is a function call, provide a different diagnostic code
                     if (isCallExpression(typeChainScan.astNode.parent) && typeChainScan.astNode.parent.callee === expression) {
                         this.addMultiScopeDiagnostic({
                             ...DiagnosticMessages.cannotFindFunction(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan)),
@@ -710,7 +796,7 @@ export class ScopeValidator {
                     }
                 }
 
-            } else if (!typeData?.isFromDocComment) {
+            } else if (!(typeData?.isFromDocComment)) {
                 // only show "cannot find... " errors if the type is not defined from a doc comment
                 const typeChainScan = util.processTypeChain(typeChain);
                 if (isCallExpression(typeChainScan.astNode.parent) && typeChainScan.astNode.parent.callee === expression) {
diff --git a/src/files/BrsFile.spec.ts b/src/files/BrsFile.spec.ts
index 7a72616b1..ae48d1065 100644
--- a/src/files/BrsFile.spec.ts
+++ b/src/files/BrsFile.spec.ts
@@ -1845,8 +1845,8 @@ describe('BrsFile', () => {
                         print PKG_PATH
                         print LINE_NUM
                         print new Person()
-                        m@.someCallfunc()
-                        m@.someCallfunc(1, 2)
+                        m.node@.someCallfunc()
+                        m.node@.someCallfunc(1, 2)
                         print tag\`stuff\${LINE_NUM}\${LINE_NUM}\`
                         print 1 = 1 ? 1 : 2
                         print 1 = 1 ? m.one : m.two
@@ -1899,8 +1899,8 @@ describe('BrsFile', () => {
                         print "pkg:/source/main.brs"
                         print LINE_NUM
                         print Person()
-                        m.callfunc("someCallfunc")
-                        m.callfunc("someCallfunc", 1, 2)
+                        m.node.callfunc("someCallfunc")
+                        m.node.callfunc("someCallfunc", 1, 2)
                         print tag(["stuff", "", ""], [LINE_NUM, LINE_NUM])
                         print bslib_ternary(1 = 1, 1, 2)
                         print (function(__bsCondition, m)
@@ -4102,10 +4102,10 @@ describe('BrsFile', () => {
 
     describe('callfunc operator', () => {
         describe('transpile', () => {
-            it('does not produce diagnostics', () => {
+            it('does not produce diagnostics on plain roSGNode', () => {
                 program.setFile('source/main.bs', `
                     sub test()
-                        someNode = createObject("roSGNode", "Rectangle")
+                        someNode = createObject("roSGNode", "Node")
                         someNode@.someFunction({test: "value"})
                     end sub
                 `);
@@ -5078,15 +5078,22 @@ describe('BrsFile', () => {
                 end class
             `);
             validateFile(mainFile);
-
-            expect(mainFile.requiredSymbols.length).to.eq(5);
+            // 'DataKind' is there twice:
+            // - when used as a type
+            // - when DataObject.kind is used
+            expect(mainFile.requiredSymbols.length).to.eq(6);
             const requiredTypeChains = mainFile.requiredSymbols.map(x => x.typeChain.map(tc => tc.name).join('.'));
-            expect(requiredTypeChains).to.have.same.members([
-                'DataKind', 'SubData', 'BaseData', 'DataProcessor', 'ProcessedData'
+            expect(Array.from(requiredTypeChains)).to.have.same.members([
+                'DataKind', 'DataKind', 'SubData', 'BaseData', 'DataProcessor', 'ProcessedData'
             ]);
             const requiredSymbolsFlags = mainFile.requiredSymbols.map(x => x.flags);
             expect(requiredSymbolsFlags).to.have.same.members([
-                SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime
+                SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime
+            ]);
+
+            const requiredSymbolsEndFlags = mainFile.requiredSymbols.map(x => x.endChainFlags);
+            expect(requiredSymbolsEndFlags).to.have.same.members([
+                SymbolTypeFlag.typetime, SymbolTypeFlag.runtime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime, SymbolTypeFlag.typetime
             ]);
         });
 
diff --git a/src/files/BrsFile.ts b/src/files/BrsFile.ts
index d0a331f3e..3aab9cf81 100644
--- a/src/files/BrsFile.ts
+++ b/src/files/BrsFile.ts
@@ -46,6 +46,7 @@ import { DefinitionProvider } from '../bscPlugin/definition/DefinitionProvider';
 export interface ProvidedSymbol {
     symbol: BscSymbol;
     duplicates: BscSymbol[];
+    requiredSymbolNames?: Set<string>;
 }
 export type ProvidedSymbolMap = Map<SymbolTypeFlag, Map<string, ProvidedSymbol>>;
 export type ChangedSymbolMap = Map<SymbolTypeFlag, Set<string>>;
@@ -985,9 +986,10 @@ export class BrsFile implements BscFile {
 
     public processSymbolInformation() {
         // Get namespaces across imported files
+        this.program.logger.debug('Processing symbol information', this.srcPath);
+
         const nsTable = this.getNamespaceSymbolTable(false);
         this.linkSymbolTableDisposables.push(this.ast.symbolTable.addSibling(nsTable));
-
         this.validationSegmenter.processTree(this.ast);
         this.program.addFileSymbolInfo(this);
         this.unlinkNamespaceSymbolTables();
@@ -1051,6 +1053,8 @@ export class BrsFile implements BscFile {
 
     public get requiredSymbols() {
         return this.cache.getOrAdd(`requiredSymbols`, () => {
+            this.program.logger.debug('Getting required symbols', this.srcPath);
+
             const allNeededSymbolSets = this.validationSegmenter.unresolvedSegmentsSymbols.values();
 
             const requiredSymbols: UnresolvedSymbol[] = [];
@@ -1065,9 +1069,12 @@ export class BrsFile implements BscFile {
                         // this catches namespaced things
                         continue;
                     }
-                    if (this.ast.getSymbolTable().hasSymbol(fullSymbolKey, flag)) {
-                        //catches aliases
-                        continue;
+                    const existingSymbol = this.ast.getSymbolTable().getSymbol(fullSymbolKey, flag);
+                    if (existingSymbol?.length > 0) {
+                        if (symbol[0]?.data?.isAlias) {
+                            //catches aliases
+                            continue;
+                        }
                     }
                     if (!addedSymbols.get(flag)?.has(fullSymbolKey)) {
                         requiredSymbols.push(symbol);
@@ -1099,6 +1106,8 @@ export class BrsFile implements BscFile {
     }
 
     private getProvidedSymbols() {
+        this.program.logger.debug('Getting provided symbols', this.srcPath);
+
         const symbolMap = new Map<SymbolTypeFlag, Map<string, ProvidedSymbol>>();
         const runTimeSymbolMap = new Map<string, ProvidedSymbol>();
         const typeTimeSymbolMap = new Map<string, ProvidedSymbol>();
@@ -1161,9 +1170,16 @@ export class BrsFile implements BscFile {
                 if (symbolNameLower === 'm') {
                     continue;
                 }
+
                 const duplicates = getAnyDuplicates(symbolNameLower, typeTimeSymbolMap, referenceTypeTimeSymbolMap);
                 if (!isAnyReferenceType(symbol.type)) {
-                    typeTimeSymbolMap.set(symbolNameLower, { symbol: symbol, duplicates: duplicates });
+                    const requiredSymbolTypes = new Set<BscType>();
+                    util.getCustomTypesInSymbolTree(requiredSymbolTypes, symbol.type);
+                    const requiredSymbolNames = new Set<string>();
+                    for (const requiredType of requiredSymbolTypes.values()) {
+                        requiredSymbolNames.add(requiredType.toString());
+                    }
+                    typeTimeSymbolMap.set(symbolNameLower, { symbol: symbol, duplicates: duplicates, requiredSymbolNames: requiredSymbolNames });
                 } else {
                     referenceTypeTimeSymbolMap.set(symbolNameLower, { symbol: symbol, duplicates: duplicates });
                 }
@@ -1183,6 +1199,7 @@ export class BrsFile implements BscFile {
         const previousSymbolsChecked = new Map<SymbolTypeFlag, Set<string>>();
         previousSymbolsChecked.set(SymbolTypeFlag.runtime, new Set<string>());
         previousSymbolsChecked.set(SymbolTypeFlag.typetime, new Set<string>());
+
         for (const flag of [SymbolTypeFlag.runtime, SymbolTypeFlag.typetime]) {
             const newSymbolMapForFlag = symbolMap.get(flag);
             const oldSymbolMapForFlag = previouslyProvidedSymbols?.get(flag);
diff --git a/src/files/XmlFile.ts b/src/files/XmlFile.ts
index 56d8de497..0567f369e 100644
--- a/src/files/XmlFile.ts
+++ b/src/files/XmlFile.ts
@@ -299,7 +299,7 @@ export class XmlFile implements BscFile {
     private dependencyGraph: DependencyGraph;
 
     public onDependenciesChanged(event: DependencyChangedEvent) {
-        this.logDebug('clear cache because dependency graph changed');
+        this.logDebug('clear cache because dependency graph changed', event?.sourceKey);
         this.cache.clear();
     }
 
diff --git a/src/interfaces.ts b/src/interfaces.ts
index 36de3cc06..0eba1ae76 100644
--- a/src/interfaces.ts
+++ b/src/interfaces.ts
@@ -982,6 +982,10 @@ export interface ExtraSymbolData {
      * Is this type as defined in a doc comment?
      */
     isFromDocComment?: boolean;
+    /**
+     * was this a result of a callfunc?
+     */
+    isFromCallFunc?: boolean;
 }
 
 export interface GetTypeOptions {
@@ -1064,6 +1068,10 @@ export interface TypeChainProcessResult {
      * The AstNode of the item
      */
     astNode: AstNode;
+    /**
+     * Does the chain contain a type that crossed a callFunc boundary?
+     */
+    crossedCallFunc: boolean;
 }
 
 export interface TypeCompatibilityData {
@@ -1073,6 +1081,8 @@ export interface TypeCompatibilityData {
     // override for diagnostic message - useful for Arrays with different default types
     actualType?: BscType;
     expectedType?: BscType;
+    allowNameEquality?: boolean;
+    unresolveableTarget?: string;
 }
 
 export interface NamespaceContainer {
diff --git a/src/parser/Expression.ts b/src/parser/Expression.ts
index afd96022a..4b24fa60d 100644
--- a/src/parser/Expression.ts
+++ b/src/parser/Expression.ts
@@ -10,7 +10,7 @@ import * as fileUrl from 'file-url';
 import type { WalkOptions, WalkVisitor } from '../astUtils/visitors';
 import { WalkMode } from '../astUtils/visitors';
 import { walk, InternalWalkMode, walkArray } from '../astUtils/visitors';
-import { isAALiteralExpression, isAAMemberExpression, isArrayLiteralExpression, isArrayType, isCallExpression, isCallableType, isCallfuncExpression, isComponentType, isDottedGetExpression, isEscapedCharCodeLiteralExpression, isFunctionExpression, isFunctionStatement, isIntegerType, isInterfaceMethodStatement, isLiteralBoolean, isLiteralExpression, isLiteralNumber, isLiteralString, isLongIntegerType, isMethodStatement, isNamespaceStatement, isNewExpression, isPrimitiveType, isReferenceType, isStringType, isTemplateStringExpression, isTypecastExpression, isUnaryExpression, isVariableExpression } from '../astUtils/reflection';
+import { isAALiteralExpression, isAAMemberExpression, isArrayLiteralExpression, isArrayType, isCallExpression, isCallableType, isCallfuncExpression, isDottedGetExpression, isEscapedCharCodeLiteralExpression, isFunctionExpression, isFunctionStatement, isIntegerType, isInterfaceMethodStatement, isLiteralBoolean, isLiteralExpression, isLiteralNumber, isLiteralString, isLongIntegerType, isMethodStatement, isNamespaceStatement, isNewExpression, isPrimitiveType, isReferenceType, isStringType, isTemplateStringExpression, isTypecastExpression, isUnaryExpression, isVariableExpression } from '../astUtils/reflection';
 import type { GetTypeOptions, TranspileResult, TypedefProvider } from '../interfaces';
 import { TypeChainEntry } from '../interfaces';
 import { VoidType } from '../types/VoidType';
@@ -26,8 +26,6 @@ import { TypePropertyReferenceType } from '../types/ReferenceType';
 import { UnionType } from '../types/UnionType';
 import { ArrayType } from '../types/ArrayType';
 import { AssociativeArrayType } from '../types/AssociativeArrayType';
-import type { ComponentType } from '../types/ComponentType';
-import { createToken } from '../astUtils/creators';
 import { TypedFunctionType } from '../types';
 import { SymbolTypeFlag } from '../SymbolTypeFlag';
 import { FunctionType } from '../types/FunctionType';
@@ -199,7 +197,7 @@ export class CallExpression extends Expression {
         if (isNewExpression(this.parent)) {
             return calleeType;
         }
-        const specialCaseReturnType = util.getSpecialCaseCallExpressionReturnType(this);
+        const specialCaseReturnType = util.getSpecialCaseCallExpressionReturnType(this, options);
         if (specialCaseReturnType) {
             return specialCaseReturnType;
         }
@@ -1696,37 +1694,7 @@ export class CallfuncExpression extends Expression {
     }
 
     getType(options: GetTypeOptions) {
-        let result: BscType = DynamicType.instance;
-        // a little hacky here with checking options.ignoreCall because callFuncExpression has the method name
-        // It's nicer for CallExpression, because it's a call on any expression.
-        const calleeType = this.callee.getType({ ...options, flags: SymbolTypeFlag.runtime });
-        if (isComponentType(calleeType) || isReferenceType(calleeType)) {
-            const funcType = (calleeType as ComponentType).getCallFuncType?.(this.tokens.methodName.text, options);
-            if (funcType) {
-                options.typeChain?.push(new TypeChainEntry({
-                    name: this.tokens.methodName.text,
-                    type: funcType,
-                    data: options.data,
-                    location: this.tokens.methodName.location,
-                    separatorToken: createToken(TokenKind.Callfunc),
-                    astNode: this
-                }));
-                if (options.ignoreCall) {
-                    result = funcType;
-                }
-            }
-            /* TODO:
-                make callfunc return types work
-            else if (isCallableType(funcType) && (!isReferenceType(funcType.returnType) || funcType.returnType.isResolvable())) {
-                result = funcType.returnType;
-            } else if (!isReferenceType(funcType) && (funcType as any)?.returnType?.isResolvable()) {
-                result = (funcType as any).returnType;
-            } else {
-                return new TypePropertyReferenceType(funcType, 'returnType');
-            }
-            */
-        }
-
+        const result = util.getCallFuncType(this, this.tokens.methodName, options) ?? DynamicType.instance;
         return result;
     }
 
diff --git a/src/parser/Parser.spec.ts b/src/parser/Parser.spec.ts
index 36d9619fc..d196e1ca4 100644
--- a/src/parser/Parser.spec.ts
+++ b/src/parser/Parser.spec.ts
@@ -8,7 +8,7 @@ import type { AliasStatement, AssignmentStatement, Block, ClassStatement, Condit
 import { PrintStatement, FunctionStatement, NamespaceStatement, ImportStatement } from './Statement';
 import { Range } from 'vscode-languageserver';
 import { DiagnosticMessages } from '../DiagnosticMessages';
-import { isAliasStatement, isAssignmentStatement, isBinaryExpression, isBlock, isBody, isCallExpression, isClassStatement, isConditionalCompileConstStatement, isConditionalCompileErrorStatement, isConditionalCompileStatement, isDottedGetExpression, isExitStatement, isExpression, isExpressionStatement, isFunctionStatement, isGroupingExpression, isIfStatement, isIndexedGetExpression, isInterfaceStatement, isLiteralExpression, isNamespaceStatement, isPrintStatement, isTypecastExpression, isTypecastStatement, isUnaryExpression, isVariableExpression } from '../astUtils/reflection';
+import { isAliasStatement, isAssignmentStatement, isBinaryExpression, isBlock, isBody, isCallExpression, isCallfuncExpression, isClassStatement, isConditionalCompileConstStatement, isConditionalCompileErrorStatement, isConditionalCompileStatement, isDottedGetExpression, isExitStatement, isExpression, isExpressionStatement, isFunctionStatement, isGroupingExpression, isIfStatement, isIndexedGetExpression, isInterfaceStatement, isLiteralExpression, isNamespaceStatement, isPrintStatement, isTypecastExpression, isTypecastStatement, isUnaryExpression, isVariableExpression } from '../astUtils/reflection';
 import { expectDiagnostics, expectDiagnosticsIncludes, expectTypeToBe, expectZeroDiagnostics, rootDir } from '../testHelpers.spec';
 import { createVisitor, WalkMode } from '../astUtils/visitors';
 import type { Expression, Statement } from './AstNode';
@@ -648,6 +648,19 @@ describe('parser', () => {
                     expect(isBinaryExpression((stmt).expression)).to.be.true;
                 }
             });
+
+            it('adds callfunc expressions', () => {
+                let parser = parse(`
+                    sub foo(thing)
+                        thing@.
+                    end sub
+                `, ParseMode.BrighterScript);
+                expect(parser.diagnostics[0]?.message).to.exist;
+                let body = (parser.ast.statements[0] as FunctionStatement).func.body;
+
+                let callFunc = body.findChild<CallExpression>(isCallfuncExpression);
+                expect(callFunc).to.exist;
+            });
         });
 
         describe('comments', () => {
diff --git a/src/parser/Parser.ts b/src/parser/Parser.ts
index 520f6acbb..2b6634d8f 100644
--- a/src/parser/Parser.ts
+++ b/src/parser/Parser.ts
@@ -2862,19 +2862,24 @@ export class Parser {
     private callfunc(callee: Expression): Expression {
         this.warnIfNotBrighterScriptMode('callfunc operator');
         let operator = this.previous();
-        let methodName = this.consume(DiagnosticMessages.expectedIdentifier(), TokenKind.Identifier, ...AllowedProperties);
-        // force it into an identifier so the AST makes some sense
-        methodName.kind = TokenKind.Identifier;
-        let openParen = this.consume(DiagnosticMessages.expectedToken(TokenKind.LeftParen), TokenKind.LeftParen);
-        let call = this.finishCall(openParen, callee, false);
-
+        let methodName = this.tryConsume(DiagnosticMessages.expectedIdentifier(), TokenKind.Identifier, ...AllowedProperties);
+        let openParen: Token;
+        let call: CallExpression;
+        if (methodName) {
+            // force it into an identifier so the AST makes some sense
+            methodName.kind = TokenKind.Identifier;
+            openParen = this.tryConsume(DiagnosticMessages.expectedToken(TokenKind.LeftParen), TokenKind.LeftParen);
+            if (openParen) {
+                call = this.finishCall(openParen, callee, false);
+            }
+        }
         return new CallfuncExpression({
             callee: callee,
             operator: operator,
             methodName: methodName as Identifier,
             openingParen: openParen,
-            args: call.args,
-            closingParen: call.tokens.closingParen
+            args: call?.args,
+            closingParen: call?.tokens?.closingParen
         });
     }
 
diff --git a/src/parser/SGParser.ts b/src/parser/SGParser.ts
index f1a5fe876..bca245930 100644
--- a/src/parser/SGParser.ts
+++ b/src/parser/SGParser.ts
@@ -248,7 +248,7 @@ export default class SGParser {
             startTagName: this.mapToken(children.Name[0]),
             attributes: this.mapAttributes(children.attribute),
             // > or />
-            startTagClose: this.mapToken((children.SLASH_CLOSE ?? children.START_CLOSE)[0]),
+            startTagClose: this.mapToken((children.SLASH_CLOSE ?? children.START_CLOSE)?.[0]),
             elements: this.mapNodes(children.content?.[0]),
             // </
             endTagOpen: this.mapToken(children.SLASH_OPEN?.[0]),
diff --git a/src/testHelpers.spec.ts b/src/testHelpers.spec.ts
index 175ab6f7b..8d758e797 100644
--- a/src/testHelpers.spec.ts
+++ b/src/testHelpers.spec.ts
@@ -187,7 +187,7 @@ export function expectZeroDiagnostics(arg: DiagnosticCollection) {
         for (const diagnostic of diagnostics) {
             //escape any newlines
             diagnostic.message = diagnostic.message.replace(/\r/g, '\\r').replace(/\n/g, '\\n');
-            message += `\n        • bs${diagnostic.code} "${diagnostic.message}" at ${diagnostic.location?.uri ?? ''}#(${diagnostic.location?.range?.start.line}:${diagnostic.location?.range?.start.character})-(${diagnostic.location?.range?.end.line}:${diagnostic.location?.range?.end.character})`;
+            message += `\n        • bs:${diagnostic.code} "${diagnostic.message}" at ${diagnostic.location?.uri ?? ''}#(${diagnostic.location?.range?.start.line}:${diagnostic.location?.range?.start.character})-(${diagnostic.location?.range?.end.line}:${diagnostic.location?.range?.end.character})`;
             //print the line containing the error (if we can find it)srcPath
             if (arg instanceof Program) {
                 const file = arg.getFile(diagnostic.location.uri);
diff --git a/src/types/ArrayType.ts b/src/types/ArrayType.ts
index 75d003910..dae5ac204 100644
--- a/src/types/ArrayType.ts
+++ b/src/types/ArrayType.ts
@@ -18,6 +18,7 @@ export class ArrayType extends BscType {
     }
 
     public readonly kind = BscTypeKind.ArrayType;
+    public isBuiltIn = true;
 
     public innerTypes: BscType[] = [];
 
diff --git a/src/types/AssociativeArrayType.ts b/src/types/AssociativeArrayType.ts
index 4d94d29f0..3b61ea900 100644
--- a/src/types/AssociativeArrayType.ts
+++ b/src/types/AssociativeArrayType.ts
@@ -12,6 +12,8 @@ export class AssociativeArrayType extends BscType {
 
     public readonly kind = BscTypeKind.AssociativeArrayType;
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         if (isDynamicType(targetType)) {
             return true;
diff --git a/src/types/BaseFunctionType.ts b/src/types/BaseFunctionType.ts
index f9ebeede7..a6bc71955 100644
--- a/src/types/BaseFunctionType.ts
+++ b/src/types/BaseFunctionType.ts
@@ -5,6 +5,7 @@ import { DynamicType } from './DynamicType';
 export abstract class BaseFunctionType extends BscType {
 
     public returnType: BscType = DynamicType.instance;
+    public isBuiltIn = true;
 
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean {
         throw new Error('Method not implemented.');
diff --git a/src/types/BooleanType.ts b/src/types/BooleanType.ts
index af2044bec..ee65f1578 100644
--- a/src/types/BooleanType.ts
+++ b/src/types/BooleanType.ts
@@ -13,6 +13,7 @@ export class BooleanType extends BscType {
     }
 
     public readonly kind = BscTypeKind.BooleanType;
+    public isBuiltIn = true;
 
     public static instance = new BooleanType('boolean');
 
diff --git a/src/types/BscType.ts b/src/types/BscType.ts
index af70f8871..bfb54bdd1 100644
--- a/src/types/BscType.ts
+++ b/src/types/BscType.ts
@@ -10,6 +10,7 @@ export abstract class BscType {
     public readonly memberTable: SymbolTable;
     protected __identifier: string;
     protected hasAddedBuiltInInterfaces = false;
+    public isBuiltIn = false;
 
     constructor(name = '') {
         this.__identifier = `${this.constructor.name}${name ? ': ' + name : ''}`;
@@ -73,7 +74,7 @@ export abstract class BscType {
         throw new Error('Method not implemented.');
     }
 
-    checkCompatibilityBasedOnMembers(targetType: BscType, flags: SymbolTypeFlag, data: TypeCompatibilityData = {}) {
+    checkCompatibilityBasedOnMembers(targetType: BscType, flags: SymbolTypeFlag, data: TypeCompatibilityData = {}, memberTable?: SymbolTable, targetMemberTable?: SymbolTable) {
         if (!targetType) {
             return false;
         }
@@ -90,6 +91,7 @@ export abstract class BscType {
         }
 
         if (isReferenceType(targetType) && !targetType.isResolvable()) {
+            data.unresolveableTarget = targetType.fullName;
             // we can't resolve the other type. Assume it does not fail on member checks
             return true;
         }
@@ -98,9 +100,10 @@ export abstract class BscType {
             // some sort of circular reference
             return false;
         }
-        const mySymbols = this.getMemberTable()?.getAllSymbols(flags);
+        const mySymbols = (memberTable ?? this.getMemberTable())?.getAllSymbols(flags);
+        const targetTable = (targetMemberTable ?? targetType.getMemberTable());
         for (const memberSymbol of mySymbols) {
-            const targetTypesOfSymbol = targetType.getMemberTable()
+            const targetTypesOfSymbol = targetTable
                 .getSymbolTypes(memberSymbol.name, { flags: flags })
                 ?.map(symbol => symbol.type);
             if (!targetTypesOfSymbol || targetTypesOfSymbol.length === 0) {
diff --git a/src/types/ClassType.ts b/src/types/ClassType.ts
index bb513b595..445cc260e 100644
--- a/src/types/ClassType.ts
+++ b/src/types/ClassType.ts
@@ -50,8 +50,11 @@ export class ClassType extends InheritableType {
         }
     }
 
+    private hasStartedAddingBuiltInInterfaces = false;
+
     addBuiltInInterfaces() {
-        if (!this.hasAddedBuiltInInterfaces) {
+        if (!this.hasAddedBuiltInInterfaces && !this.hasStartedAddingBuiltInInterfaces) {
+            this.hasStartedAddingBuiltInInterfaces = true;
             if (this.parentType) {
                 this.parentType.addBuiltInInterfaces();
             }
diff --git a/src/types/ComponentType.ts b/src/types/ComponentType.ts
index 623a2a733..d0df28912 100644
--- a/src/types/ComponentType.ts
+++ b/src/types/ComponentType.ts
@@ -1,7 +1,7 @@
-import type { GetSymbolTypeOptions } from '../SymbolTable';
-import type { SymbolTypeFlag } from '../SymbolTypeFlag';
+import type { BscSymbol, GetSymbolTypeOptions, SymbolTableProvider } from '../SymbolTable';
+import { SymbolTypeFlag } from '../SymbolTypeFlag';
 import { SymbolTable } from '../SymbolTable';
-import { isComponentType, isDynamicType, isObjectType } from '../astUtils/reflection';
+import { isAnyReferenceType, isComponentType, isDynamicType, isObjectType, isPrimitiveType, isReferenceType, isTypedFunctionType } from '../astUtils/reflection';
 import type { ExtraSymbolData, TypeCompatibilityData } from '../interfaces';
 import type { BaseFunctionType } from './BaseFunctionType';
 import type { BscType } from './BscType';
@@ -16,6 +16,7 @@ export class ComponentType extends InheritableType {
     constructor(public name: string, superComponent?: ComponentType) {
         super(name, superComponent);
         this.callFuncMemberTable = new SymbolTable(`${this.name}: CallFunc`, () => this.parentComponent?.callFuncMemberTable);
+        this.callFuncAssociatedTypesTable = new SymbolTable(`${this.name}: CallFuncAssociatedTypes`, () => this.parentComponent?.callFuncAssociatedTypesTable);
     }
 
     public readonly kind = BscTypeKind.ComponentType;
@@ -39,8 +40,39 @@ export class ComponentType extends InheritableType {
 
     public static instance = new ComponentType('Node');
 
-    isEqual(targetType: BscType): boolean {
-        return isComponentType(targetType) && this.name.toLowerCase() === targetType.name.toLowerCase();
+    isEqual(targetType: BscType, data: TypeCompatibilityData = {}): boolean {
+        if (isReferenceType(targetType) && targetType.isResolvable()) {
+            targetType = targetType.getTarget?.() ?? targetType;
+        }
+        if (this === targetType) {
+            return true;
+        }
+        if (!isComponentType(targetType)) {
+            return false;
+        }
+
+        const thisNameLower = this.name.toLowerCase();
+        const targetNameLower = targetType.name.toLowerCase();
+        if (thisNameLower !== targetNameLower) {
+            return false;
+        }
+        if (this.isBuiltIn && targetType.isBuiltIn) {
+            return true;
+        }
+
+        if (!this.isParentTypeEqual(targetType, data)) {
+            return false;
+        }
+        if (!this.checkCompatibilityBasedOnMembers(targetType, SymbolTypeFlag.runtime, data) ||
+            !targetType.checkCompatibilityBasedOnMembers(this, SymbolTypeFlag.runtime, data)) {
+            return false;
+        }
+        if (!this.checkCompatibilityBasedOnMembers(targetType, SymbolTypeFlag.runtime, data, this.callFuncMemberTable, targetType.callFuncMemberTable) ||
+            !targetType.checkCompatibilityBasedOnMembers(this, SymbolTypeFlag.runtime, data, targetType.callFuncMemberTable, this.callFuncMemberTable)) {
+            return false;
+        }
+
+        return true;
     }
 
     public toString() {
@@ -60,9 +92,11 @@ export class ComponentType extends InheritableType {
         }
     }
 
+    private hasStartedAddingBuiltInInterfaces = false;
 
     addBuiltInInterfaces() {
-        if (!this.hasAddedBuiltInInterfaces) {
+        if (!this.hasAddedBuiltInInterfaces && !this.hasStartedAddingBuiltInInterfaces) {
+            this.hasStartedAddingBuiltInInterfaces = true;
             if (this.parentType) {
                 this.parentType.addBuiltInInterfaces();
             }
@@ -73,9 +107,12 @@ export class ComponentType extends InheritableType {
     }
 
     private hasAddedBuiltInFields = false;
+    private hasStartedAddingBuiltInFields = false;
+
 
     addBuiltInFields() {
-        if (!this.hasAddedBuiltInFields) {
+        if (!this.hasAddedBuiltInFields && !this.hasStartedAddingBuiltInFields) {
+            this.hasStartedAddingBuiltInFields = true;
             if (isComponentType(this.parentType)) {
                 this.parentType.addBuiltInFields();
             }
@@ -85,9 +122,49 @@ export class ComponentType extends InheritableType {
     }
 
     public readonly callFuncMemberTable: SymbolTable;
+    public readonly callFuncAssociatedTypesTable: SymbolTable;
+
+    /**
+     * Adds a function to the call func member table
+     * Also adds any associated custom types to its own table, so they can be used through a callfunc
+     */
+    addCallFuncMember(name: string, data: ExtraSymbolData, funcType: BaseFunctionType, flags: SymbolTypeFlag, associatedTypesTableProvider?: SymbolTableProvider) {
+        const originalTypesToCheck = new Set<BscType>();
+        if (isTypedFunctionType(funcType)) {
+            const paramTypes = (funcType.params ?? []).map(p => p.type);
+            for (const paramType of paramTypes) {
+                originalTypesToCheck.add(paramType);
+            }
+        }
+        if (funcType.returnType) {
+            originalTypesToCheck.add(funcType.returnType);
+        }
+        const additionalTypesToCheck = new Set<BscType>();
+
+        for (const type of originalTypesToCheck) {
+            if (!type.isBuiltIn) {
+                util.getCustomTypesInSymbolTree(additionalTypesToCheck, type, (subSymbol: BscSymbol) => {
+                    return !originalTypesToCheck.has(subSymbol.type);
+                });
+            }
+        }
+
+        for (const type of [...originalTypesToCheck.values(), ...additionalTypesToCheck.values()]) {
+            if (!isPrimitiveType(type) && type.isResolvable()) {
+                // This type is a reference type, but was able to be resolved here
+                // add it to the table of associated types, so it can be used through a callfunc
+                const extraData = {};
+                if (associatedTypesTableProvider) {
+                    associatedTypesTableProvider().getSymbolType(type.toString(), { flags: SymbolTypeFlag.typetime, data: extraData });
+                }
+                let targetType = isAnyReferenceType(type) ? type.getTarget?.() : type;
+
+                this.callFuncAssociatedTypesTable.addSymbol(type.toString(), { ...extraData, isFromCallFunc: true }, targetType, SymbolTypeFlag.typetime);
+            }
+        }
 
-    addCallFuncMember(name: string, data: ExtraSymbolData, type: BaseFunctionType, flags: SymbolTypeFlag) {
-        this.callFuncMemberTable.addSymbol(name, data, type, flags);
+        // add this function to be available through callfunc
+        this.callFuncMemberTable.addSymbol(name, data, funcType, flags);
     }
 
     getCallFuncTable() {
@@ -95,7 +172,33 @@ export class ComponentType extends InheritableType {
     }
 
     getCallFuncType(name: string, options: GetSymbolTypeOptions) {
-        return this.callFuncMemberTable.getSymbolType(name, options);
+        const callFuncType = this.callFuncMemberTable.getSymbolType(name, options);
+
+        const addAssociatedTypesTableAsSiblingToMemberTable = (type: BscType) => {
+            if (isReferenceType(type) &&
+                !type.isResolvable()) {
+                // This param or return type is a reference - make sure the associated types are included
+                type.tableProvider().addSibling(this.callFuncAssociatedTypesTable);
+
+                // add this as a sister table to member tables too!
+                const memberTable: SymbolTable = type.getMemberTable();
+                if (memberTable.getAllSymbols) {
+                    for (const memberSymbol of memberTable.getAllSymbols(SymbolTypeFlag.runtime)) {
+                        addAssociatedTypesTableAsSiblingToMemberTable(memberSymbol?.type);
+                    }
+                }
+            }
+        };
+
+        if (isTypedFunctionType(callFuncType)) {
+            const typesToCheck = [...callFuncType.params.map(p => p.type), callFuncType.returnType];
+
+            for (const type of typesToCheck) {
+                addAssociatedTypesTableAsSiblingToMemberTable(type);
+            }
+        }
+
+        return callFuncType;
     }
 }
 
diff --git a/src/types/DoubleType.ts b/src/types/DoubleType.ts
index fe406d8d3..244f97a80 100644
--- a/src/types/DoubleType.ts
+++ b/src/types/DoubleType.ts
@@ -17,6 +17,8 @@ export class DoubleType extends BscType {
 
     public static instance = new DoubleType('double');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isDynamicType(targetType) ||
diff --git a/src/types/DynamicType.ts b/src/types/DynamicType.ts
index 64e6189a2..14e1f60d3 100644
--- a/src/types/DynamicType.ts
+++ b/src/types/DynamicType.ts
@@ -15,6 +15,8 @@ export class DynamicType extends BscType {
 
     public static readonly instance = new DynamicType();
 
+    public isBuiltIn = true;
+
     get returnType() {
         return DynamicType.instance;
     }
diff --git a/src/types/FloatType.ts b/src/types/FloatType.ts
index 101f0dfa9..8a78b0dd7 100644
--- a/src/types/FloatType.ts
+++ b/src/types/FloatType.ts
@@ -16,6 +16,8 @@ export class FloatType extends BscType {
 
     public static instance = new FloatType('float');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isDynamicType(targetType) ||
diff --git a/src/types/InheritableType.ts b/src/types/InheritableType.ts
index 1271c87a1..b9e53fd0f 100644
--- a/src/types/InheritableType.ts
+++ b/src/types/InheritableType.ts
@@ -125,6 +125,15 @@ export abstract class InheritableType extends BscType {
         if (this === targetType) {
             return true;
         }
+        if (data?.allowNameEquality) {
+            const thisKind = (this as any).kind;
+            if (thisKind && thisKind === (targetType as any).kind) {
+                if (this.toString().toLowerCase() === targetType.toString().toLowerCase()) {
+                    return true;
+                }
+            }
+        }
+
         if (this.isAncestorUnresolvedReferenceType() || targetType.isAncestorUnresolvedReferenceType()) {
             return this.name.toLowerCase() === targetType.name?.toLowerCase() &&
                 this.isParentTypeEqual(targetType, data);
diff --git a/src/types/IntegerType.ts b/src/types/IntegerType.ts
index 496caf934..7b6751b67 100644
--- a/src/types/IntegerType.ts
+++ b/src/types/IntegerType.ts
@@ -16,6 +16,8 @@ export class IntegerType extends BscType {
 
     public static instance = new IntegerType('integer');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isDynamicType(targetType) ||
diff --git a/src/types/InvalidType.ts b/src/types/InvalidType.ts
index da09a0128..885d61ee6 100644
--- a/src/types/InvalidType.ts
+++ b/src/types/InvalidType.ts
@@ -15,6 +15,8 @@ export class InvalidType extends BscType {
 
     public static instance = new InvalidType('invalid');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType) {
         return (
             isInvalidType(targetType) ||
diff --git a/src/types/LongIntegerType.ts b/src/types/LongIntegerType.ts
index 5b653c1fb..08e8b1ffa 100644
--- a/src/types/LongIntegerType.ts
+++ b/src/types/LongIntegerType.ts
@@ -16,6 +16,8 @@ export class LongIntegerType extends BscType {
 
     public static instance = new LongIntegerType('longinteger');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isDynamicType(targetType) ||
diff --git a/src/types/ObjectType.ts b/src/types/ObjectType.ts
index 0bff8c6b5..ec2d912af 100644
--- a/src/types/ObjectType.ts
+++ b/src/types/ObjectType.ts
@@ -15,6 +15,8 @@ export class ObjectType extends BscType {
 
     public readonly kind = BscTypeKind.ObjectType;
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         //Brightscript allows anything passed "as object", so as long as a type is provided, this is true
         return !!targetType;
diff --git a/src/types/ReferenceType.ts b/src/types/ReferenceType.ts
index a5728744a..e0a8a7ba2 100644
--- a/src/types/ReferenceType.ts
+++ b/src/types/ReferenceType.ts
@@ -1,5 +1,5 @@
 import type { GetTypeOptions, TypeChainEntry, TypeCompatibilityData } from '../interfaces';
-import type { GetSymbolTypeOptions, SymbolTypeGetterProvider } from '../SymbolTable';
+import type { GetSymbolTypeOptions, SymbolTable, SymbolTableProvider, SymbolTypeGetterProvider } from '../SymbolTable';
 import type { SymbolTypeFlag } from '../SymbolTypeFlag';
 import { isAnyReferenceType, isArrayDefaultTypeReferenceType, isArrayType, isBinaryOperatorReferenceType, isComponentType, isDynamicType, isReferenceType, isTypePropertyReferenceType } from '../astUtils/reflection';
 import { BscType } from './BscType';
@@ -22,7 +22,7 @@ export class ReferenceType extends BscType {
      * @param flags is this type available at typetime, runtime, etc.
      * @param tableProvider function that returns a SymbolTable that we use for the lookup.
      */
-    constructor(public memberKey: string, public fullName, public flags: SymbolTypeFlag, private tableProvider: SymbolTypeGetterProvider) {
+    constructor(public memberKey: string, public fullName, public flags: SymbolTypeFlag, public tableProvider: SymbolTypeGetterProvider) {
         super(memberKey);
         // eslint-disable-next-line no-constructor-return
         return new Proxy(this, {
@@ -188,6 +188,8 @@ export class ReferenceType extends BscType {
                     } else if (propName === 'hasAddedBuiltInInterfaces') {
                         // this is an unknown type. There is no use in adding built in interfaces
                         return true;
+                    } else if (propName === 'isBuiltIn') {
+                        return false;
                     }
                 }
 
@@ -206,6 +208,9 @@ export class ReferenceType extends BscType {
 
                 // Look for circular references
                 if (!innerType || this.referenceChain.has(innerType)) {
+                    console.log(`Proxy set error`, name, value, innerType);
+                    const error = new Error();
+                    console.log(error.stack);
                     return false;
                 }
                 const result = Reflect.set(innerType, name, value, innerType);
@@ -217,6 +222,8 @@ export class ReferenceType extends BscType {
 
     public readonly kind = BscTypeKind.ReferenceType;
 
+    getTarget: () => BscType;
+
     /**
      * Resolves the type based on the original name and the table provider
      */
@@ -286,6 +293,12 @@ export class ReferenceType extends BscType {
                 if (resolvedType) {
                     resolvedType.memberTable.setCachedType(innerName, innerResolvedTypeCacheEntry, options);
                 }
+            },
+            addSibling: (symbolTable: SymbolTable) => {
+                const resolvedType = this.resolve();
+                if (resolvedType) {
+                    resolvedType.memberTable?.addSibling?.(symbolTable);
+                }
             }
         };
     };
@@ -304,6 +317,12 @@ export class ReferenceType extends BscType {
                 if (isComponentType(resolvedType)) {
                     resolvedType.getCallFuncTable().setCachedType(innerName, innerResolvedTypeCacheEntry, options);
                 }
+            },
+            addSibling: (symbolTable: SymbolTable) => {
+                const resolvedType = this.resolve();
+                if (isComponentType(resolvedType)) {
+                    resolvedType.getCallFuncTable()?.addSibling?.(symbolTable);
+                }
             }
         };
     };
@@ -350,6 +369,9 @@ export class TypePropertyReferenceType extends BscType {
                                     },
                                     setCachedType: (innerName: string, innerTypeCacheEntry: TypeChainEntry, innerOptions: GetTypeOptions) => {
                                         return this.outerType?.[this.propertyName]?.memberTable.setCachedType(innerName, innerTypeCacheEntry, innerOptions);
+                                    },
+                                    addSibling: (symbolTable: SymbolTable) => {
+                                        return this.outerType?.[this.propertyName]?.memberTable?.addSibling?.(symbolTable);
                                     }
                                 };
                             });
@@ -384,6 +406,10 @@ export class TypePropertyReferenceType extends BscType {
             }
         });
     }
+
+    getTarget: () => BscType;
+
+    tableProvider: SymbolTableProvider;
 }
 
 
@@ -437,6 +463,10 @@ export class BinaryOperatorReferenceType extends BscType {
             }
         });
     }
+
+    getTarget: () => BscType;
+
+    tableProvider: SymbolTableProvider;
 }
 
 
@@ -488,6 +518,10 @@ export class ArrayDefaultTypeReferenceType extends BscType {
             }
         });
     }
+
+    getTarget: () => BscType;
+
+    tableProvider: SymbolTableProvider;
 }
 
 /**
diff --git a/src/types/StringType.ts b/src/types/StringType.ts
index 2bbf342d3..888190f43 100644
--- a/src/types/StringType.ts
+++ b/src/types/StringType.ts
@@ -14,6 +14,7 @@ export class StringType extends BscType {
 
     public readonly kind = BscTypeKind.StringType;
 
+    public isBuiltIn = true;
     /**
      * A static instance that can be used to reduce memory and constructor costs, since there's nothing unique about this
      */
diff --git a/src/types/TypedFunctionType.ts b/src/types/TypedFunctionType.ts
index 1061e041f..89b3b7fd5 100644
--- a/src/types/TypedFunctionType.ts
+++ b/src/types/TypedFunctionType.ts
@@ -79,9 +79,15 @@ export class TypedFunctionType extends BaseFunctionType {
         return 'Function';
     }
 
-    isEqual(targetType: BscType) {
+    isEqual(targetType: BscType, data: TypeCompatibilityData = {}) {
         if (isTypedFunctionType(targetType)) {
-            return this.checkParamsAndReturnValue(targetType, false, (t1, t2) => t1.isEqual(t2));
+            if (this.toString().toLowerCase() === targetType.toString().toLowerCase()) {
+                // this function has the same param names and types and return type as the target
+                return true;
+            }
+            return this.checkParamsAndReturnValue(targetType, false, (t1, t2, predData = {}) => {
+                return t1.isEqual(t2, { ...predData, allowNameEquality: true });
+            }, data);
         }
         return false;
     }
diff --git a/src/types/UninitializedType.ts b/src/types/UninitializedType.ts
index 73d8c2f09..67728bc1b 100644
--- a/src/types/UninitializedType.ts
+++ b/src/types/UninitializedType.ts
@@ -14,6 +14,8 @@ export class UninitializedType extends BscType {
 
     public readonly kind = BscTypeKind.UninitializedType;
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isUninitializedType(targetType) ||
diff --git a/src/types/UnionType.ts b/src/types/UnionType.ts
index dc1e329fd..cc2d6a36e 100644
--- a/src/types/UnionType.ts
+++ b/src/types/UnionType.ts
@@ -56,6 +56,9 @@ export class UnionType extends BscType {
                     },
                     setCachedType: (innerName: string, innerCacheEntry: TypeCacheEntry, innerOptions: GetTypeOptions) => {
                         // TODO: is this even cachable? This is a NO-OP for now, and it shouldn't hurt anything
+                    },
+                    addSibling: (symbolTable: SymbolTable) => {
+                        // TODO: I don't know what this means in this context?
                     }
                 };
             });
diff --git a/src/types/VoidType.ts b/src/types/VoidType.ts
index 8d9288c86..8c6babdf9 100644
--- a/src/types/VoidType.ts
+++ b/src/types/VoidType.ts
@@ -16,6 +16,8 @@ export class VoidType extends BscType {
 
     public static instance = new VoidType('void');
 
+    public isBuiltIn = true;
+
     public isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData) {
         return (
             isVoidType(targetType) ||
diff --git a/src/util.ts b/src/util.ts
index a871e8659..e5bde099e 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -11,7 +11,8 @@ import { URI } from 'vscode-uri';
 import * as xml2js from 'xml2js';
 import type { BsConfig, FinalizedBsConfig } from './BsConfig';
 import { DiagnosticMessages } from './DiagnosticMessages';
-import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPluginFactory, CompilerPlugin, ExpressionInfo, TranspileResult, TypeChainEntry, TypeChainProcessResult, GetTypeOptions, ExtraSymbolData } from './interfaces';
+import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPluginFactory, CompilerPlugin, ExpressionInfo, TranspileResult, TypeChainProcessResult, GetTypeOptions, ExtraSymbolData } from './interfaces';
+import { TypeChainEntry } from './interfaces';
 import { BooleanType } from './types/BooleanType';
 import { DoubleType } from './types/DoubleType';
 import { DynamicType } from './types/DynamicType';
@@ -26,7 +27,7 @@ import type { CallExpression, CallfuncExpression, DottedGetExpression, FunctionP
 import { LogLevel, createLogger } from './logging';
 import { isToken, type Identifier, type Locatable, type Token } from './lexer/Token';
 import { TokenKind } from './lexer/TokenKind';
-import { isAnyReferenceType, isBinaryExpression, isBooleanType, isBrsFile, isCallExpression, isCallableType, isCallfuncExpression, isClassType, isDottedGetExpression, isDoubleType, isDynamicType, isEnumMemberType, isExpression, isFloatType, isIndexedGetExpression, isInvalidType, isLiteralString, isLongIntegerType, isNamespaceStatement, isNamespaceType, isNewExpression, isNumberType, isReferenceType, isStatement, isStringType, isTypeExpression, isTypedArrayExpression, isTypedFunctionType, isUnionType, isVariableExpression, isXmlAttributeGetExpression, isXmlFile } from './astUtils/reflection';
+import { isAnyReferenceType, isBinaryExpression, isBooleanType, isBrsFile, isCallExpression, isCallableType, isCallfuncExpression, isClassType, isComponentType, isDottedGetExpression, isDoubleType, isDynamicType, isEnumMemberType, isExpression, isFloatType, isIndexedGetExpression, isInvalidType, isLiteralString, isLongIntegerType, isNamespaceStatement, isNamespaceType, isNewExpression, isNumberType, isReferenceType, isStatement, isStringType, isTypeExpression, isTypedArrayExpression, isTypedFunctionType, isUnionType, isVariableExpression, isXmlAttributeGetExpression, isXmlFile } from './astUtils/reflection';
 import { WalkMode } from './astUtils/visitors';
 import { SourceNode } from 'source-map';
 import * as requireRelative from 'require-relative';
@@ -35,14 +36,14 @@ import type { XmlFile } from './files/XmlFile';
 import type { AstNode, Expression, Statement } from './parser/AstNode';
 import { AstNodeKind } from './parser/AstNode';
 import type { UnresolvedSymbol } from './AstValidationSegmenter';
-import type { SymbolTable } from './SymbolTable';
+import type { BscSymbol, GetSymbolTypeOptions, SymbolTable } from './SymbolTable';
 import { SymbolTypeFlag } from './SymbolTypeFlag';
 import { createIdentifier, createToken } from './astUtils/creators';
 import { MAX_RELATED_INFOS_COUNT } from './diagnosticUtils';
 import type { BscType } from './types/BscType';
 import { unionTypeFactory } from './types/UnionType';
 import { ArrayType } from './types/ArrayType';
-import { BinaryOperatorReferenceType } from './types/ReferenceType';
+import { BinaryOperatorReferenceType, TypePropertyReferenceType } from './types/ReferenceType';
 import { AssociativeArrayType } from './types/AssociativeArrayType';
 import { ComponentType } from './types/ComponentType';
 import { FunctionType } from './types/FunctionType';
@@ -2184,6 +2185,7 @@ export class Util {
         let errorLocation: Location;
         let containsDynamic = false;
         let continueResolvingAllItems = true;
+        let crossedCallFunc = false;
         for (let i = 0; i < typeChain.length; i++) {
             const chainItem = typeChain[i];
             const dotSep = chainItem.separatorToken?.text ?? '.';
@@ -2229,6 +2231,7 @@ export class Util {
                 itemName = chainItem.name;
                 astNode = chainItem.astNode;
                 containsDynamic = containsDynamic || (isDynamicType(chainItem.type) && !isAnyReferenceType(chainItem.type));
+                crossedCallFunc = crossedCallFunc || chainItem.data?.isFromCallFunc;
                 if (!chainItem.isResolved) {
                     errorLocation = chainItem.location;
                     continueResolvingAllItems = false;
@@ -2244,7 +2247,8 @@ export class Util {
             fullChainName: fullChainName,
             location: errorLocation,
             containsDynamic: containsDynamic,
-            astNode: astNode
+            astNode: astNode,
+            crossedCallFunc: crossedCallFunc
         };
     }
 
@@ -2252,12 +2256,12 @@ export class Util {
     public isInTypeExpression(expression: AstNode): boolean {
         //TODO: this is much faster than node.findAncestor(), but may need to be updated for "complicated" type expressions
         if (isTypeExpression(expression) ||
-            isTypeExpression(expression.parent) ||
+            isTypeExpression(expression?.parent) ||
             isTypedArrayExpression(expression) ||
-            isTypedArrayExpression(expression.parent)) {
+            isTypedArrayExpression(expression?.parent)) {
             return true;
         }
-        if (isBinaryExpression(expression.parent)) {
+        if (isBinaryExpression(expression?.parent)) {
             let currentExpr: AstNode = expression.parent;
             while (isBinaryExpression(currentExpr) && currentExpr.tokens.operator.kind === TokenKind.Or) {
                 currentExpr = currentExpr.parent;
@@ -2267,6 +2271,17 @@ export class Util {
         return false;
     }
 
+    public isGenericNodeType(type: BscType) {
+        if (isComponentType(type)) {
+            const lowerName = type.toString().toLowerCase();
+            if (lowerName === 'rosgnode' || lowerName === 'rosgnodenode') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
     public hasAnyRequiredSymbolChanged(requiredSymbols: UnresolvedSymbol[], changedSymbols: Map<SymbolTypeFlag, Set<string>>) {
         if (!requiredSymbols || !changedSymbols) {
             return false;
@@ -2296,6 +2311,22 @@ export class Util {
         return false;
     }
 
+    public getCustomTypesInSymbolTree(setToFill: Set<BscType>, type: BscType, filter?: (t: BscSymbol) => boolean) {
+        const subSymbols = type.getMemberTable()?.getAllSymbols(SymbolTypeFlag.runtime) ?? [];
+        for (const subSymbol of subSymbols) {
+            if (!subSymbol.type.isBuiltIn && !setToFill.has(subSymbol.type)) {
+                if (filter && !filter(subSymbol)) {
+                    continue;
+                }
+                // if this is a custom type, and we haven't added it to the types to check to see if can add it to the additional types
+                // add the type, and investigate any members
+                setToFill.add(subSymbol.type);
+                this.getCustomTypesInSymbolTree(setToFill, subSymbol.type, filter);
+            }
+
+        }
+    }
+
     public truncate<T>(options: {
         leadingText: string;
         items: T[];
@@ -2386,12 +2417,19 @@ export class Util {
         return false;
     }
 
-    public getSpecialCaseCallExpressionReturnType(callExpr: CallExpression) {
+    public getSpecialCaseCallExpressionReturnType(callExpr: CallExpression, options: GetSymbolTypeOptions) {
         if (isVariableExpression(callExpr.callee) && callExpr.callee.tokens.name.text.toLowerCase() === 'createobject') {
             const componentName = isLiteralString(callExpr.args[0]) ? callExpr.args[0].tokens.value?.text?.replace(/"/g, '') : '';
             const nodeType = componentName.toLowerCase() === 'rosgnode' && isLiteralString(callExpr.args[1]) ? callExpr.args[1].tokens.value?.text?.replace(/"/g, '') : '';
             if (componentName?.toLowerCase().startsWith('ro')) {
-                const fullName = componentName + nodeType;
+                let fullName = componentName + nodeType;
+
+                if (nodeType.includes(':')) {
+                    // This node has a colon in its name, most likely from a component Library
+                    // This componentType is most likely unknown, so return `roSGNode`
+                    fullName = 'roSGNode';
+                }
+
                 const data = {};
                 const symbolTable = callExpr.getSymbolTable();
                 const foundType = symbolTable.getSymbolType(fullName, {
@@ -2404,9 +2442,66 @@ export class Util {
                     return foundType;
                 }
             }
+        } else if (isDottedGetExpression(callExpr.callee) &&
+            callExpr.callee.tokens?.name?.text?.toLowerCase() === 'callfunc' &&
+            isLiteralString(callExpr.args?.[0])) {
+            return this.getCallFuncType(callExpr, callExpr.args?.[0]?.tokens.value, options);
+        } else if (isDottedGetExpression(callExpr.callee) &&
+            callExpr.callee.tokens?.name?.text?.toLowerCase() === 'createchild' &&
+            isComponentType(callExpr.callee.obj?.getType({ flags: SymbolTypeFlag.runtime })) &&
+            isLiteralString(callExpr.args?.[0])) {
+            const fullName = `roSGNode${callExpr.args?.[0].tokens?.value?.text?.replace(/"/g, '')}`;
+            const data = {};
+            const symbolTable = callExpr.getSymbolTable();
+            return symbolTable.getSymbolType(fullName, {
+                flags: SymbolTypeFlag.typetime,
+                data: data,
+                tableProvider: () => callExpr?.getSymbolTable(),
+                fullName: fullName
+            });
         }
     }
 
+    public getCallFuncType(callExpr: CallExpression | CallfuncExpression, methodNameToken: Token | Identifier, options: GetSymbolTypeOptions) {
+        let result: BscType;
+        let methodName = methodNameToken?.text?.replace(/"/g, ''); // remove quotes if it was the first arg of .callFunc()
+
+        // a little hacky here with checking options.ignoreCall because callFuncExpression has the method name
+        // It's nicer for CallExpression, because it's a call on any expression.
+        let calleeType: BscType;
+        if (isCallfuncExpression(callExpr)) {
+            calleeType = callExpr.callee.getType({ ...options, flags: SymbolTypeFlag.runtime, ignoreCall: false });
+        } else if (isCallExpression(callExpr) && isDottedGetExpression(callExpr.callee)) {
+            calleeType = callExpr.callee.obj.getType({ ...options, flags: SymbolTypeFlag.runtime, ignoreCall: false });
+        }
+        if (isComponentType(calleeType) || isReferenceType(calleeType)) {
+            const funcType = (calleeType as ComponentType).getCallFuncType?.(methodName, options);
+            if (funcType) {
+                options.typeChain?.push(new TypeChainEntry({
+                    name: methodName,
+                    type: funcType,
+                    data: options.data,
+                    location: methodNameToken.location,
+                    separatorToken: createToken(TokenKind.Callfunc),
+                    astNode: callExpr
+                }));
+                if (options.ignoreCall) {
+                    result = funcType;
+                } else if (isCallableType(funcType) && (!isReferenceType(funcType.returnType) || funcType.returnType.isResolvable())) {
+                    result = funcType.returnType;
+                } else if (!isReferenceType(funcType) && (funcType as any)?.returnType?.isResolvable()) {
+                    result = (funcType as any).returnType;
+                } else {
+                    result = new TypePropertyReferenceType(funcType, 'returnType');
+                }
+            }
+        }
+        if (options.data && !options.ignoreCall) {
+            options.data.isFromCallFunc = true;
+        }
+        return result;
+    }
+
     public symbolComesFromSameNode(symbolName: string, definingNode: AstNode, symbolTable: SymbolTable) {
         let nsData: ExtraSymbolData = {};
         let foundType = symbolTable?.getSymbolType(symbolName, { flags: SymbolTypeFlag.runtime, data: nsData });