brighterscript 1.0.0-alpha.40 → 1.0.0-alpha.42

package/dist/util.d.ts

@@ -2,7 +2,8 @@ import type { Diagnostic, Position } from 'vscode-languageserver';
 import { Location } from 'vscode-languageserver';
 import { Range } from 'vscode-languageserver';
 import type { BsConfig, FinalizedBsConfig } from './BsConfig';
-import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, TranspileResult, TypeChainEntry, TypeChainProcessResult, GetTypeOptions } from './interfaces';
+import type { CallableContainer, BsDiagnostic, FileReference, CallableContainerMap, CompilerPlugin, ExpressionInfo, TranspileResult, TypeChainProcessResult, GetTypeOptions } from './interfaces';
+import { TypeChainEntry } from './interfaces';
 import { BooleanType } from './types/BooleanType';
 import { DoubleType } from './types/DoubleType';
 import { DynamicType } from './types/DynamicType';
@@ -13,19 +14,20 @@ import { ObjectType } from './types/ObjectType';
 import { StringType } from './types/StringType';
 import { VoidType } from './types/VoidType';
 import { ParseMode } from './parser/Parser';
-import type { CallExpression, DottedGetExpression, VariableExpression } from './parser/Expression';
+import type { CallExpression, CallfuncExpression, DottedGetExpression, VariableExpression } from './parser/Expression';
 import { type Identifier, type Locatable, type Token } from './lexer/Token';
 import { SourceNode } from 'source-map';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
 import type { AstNode, Expression, Statement } 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 type { BscType } from './types/BscType';
 import { FunctionType } from './types/FunctionType';
 import type { NamespaceStatement } from './parser/Statement';
 import type { BscFile } from './files/BscFile';
+import { InvalidType } from './types/InvalidType';
 export declare class Util {
     clearConsole(): void;
     /**
@@ -347,7 +349,7 @@ export declare class Util {
     /**
      * Convert a token into a BscType
      */
-    tokenToBscType(token: Token): DynamicType | ObjectType | BooleanType | DoubleType | FloatType | FunctionType | IntegerType | LongIntegerType | StringType | VoidType;
+    tokenToBscType(token: Token): DynamicType | ObjectType | VoidType | InvalidType | BooleanType | DoubleType | FloatType | FunctionType | IntegerType | LongIntegerType | StringType;
     /**
      * Deciphers the correct types for fields based on docs
      * https://developer.roku.com/en-ca/docs/references/scenegraph/xml-elements/interface.md
@@ -360,6 +362,7 @@ export declare class Util {
      * Note: compound assignments (eg. +=) internally use a binary expression, so that's why TokenKind.PlusEqual, etc. are here too
      */
     binaryOperatorResultType(leftType: BscType, operator: Token, rightType: BscType): BscType;
+    getHighestPriorityType(types: BscType[], depth?: number): BscType;
     /**
      * Return the type of the result of a binary operator
      */
@@ -458,8 +461,10 @@ export declare class Util {
     findLastIndex<T>(array: T[], matcher: (T: any) => boolean): number;
     processTypeChain(typeChain: TypeChainEntry[]): TypeChainProcessResult;
     isInTypeExpression(expression: AstNode): boolean;
+    isGenericNodeType(type: BscType): boolean;
     hasAnyRequiredSymbolChanged(requiredSymbols: UnresolvedSymbol[], changedSymbols: Map<SymbolTypeFlag, Set<string>>): boolean;
     setContainsUnresolvedSymbol(symbolLowerNameSet: Set<string>, symbol: UnresolvedSymbol): boolean;
+    getCustomTypesInSymbolTree(setToFill: Set<BscType>, type: BscType, filter?: (t: BscSymbol) => boolean): void;
     truncate<T>(options: {
         leadingText: string;
         items: T[];
@@ -473,12 +478,17 @@ export declare class Util {
     getLeadingComments(input: Token | AstNode): Token[];
     isLeadingCommentOnSameLine(line: RangeLike, input: Token | AstNode): boolean;
     isClassUsedAsFunction(potentialClassType: BscType, expression: Expression, options: GetTypeOptions): boolean;
-    getSpecialCaseCallExpressionReturnType(callExpr: CallExpression): BscType;
+    getSpecialCaseCallExpressionReturnType(callExpr: CallExpression, options: GetSymbolTypeOptions): BscType;
+    getCallFuncType(callExpr: CallExpression | CallfuncExpression, methodNameToken: Token | Identifier, options: GetSymbolTypeOptions): BscType;
     symbolComesFromSameNode(symbolName: string, definingNode: AstNode, symbolTable: SymbolTable): boolean;
     isCalleeMemberOfNamespace(symbolName: string, nodeWhereUsed: AstNode, namespace?: NamespaceStatement): boolean;
     isVariableMemberOfNamespace(symbolName: string, nodeWhereUsed: AstNode, namespace?: NamespaceStatement): boolean;
     isVariableShadowingSomething(symbolName: string, nodeWhereUsed: AstNode): boolean;
     chooseTypeFromCodeOrDocComment(codeType: BscType, docType: BscType, options: GetTypeOptions): BscType;
+    /**
+     * Gets the type for a default value (eg. as a function param, class member or typed array)
+     */
+    getDefaultTypeFromValueType(valueType: (BscType | BscType[])): BscType;
 }
 /**
  * A tagged template literal function for standardizing the path. This has to be defined as standalone function since it's a tagged template literal function,

package/dist/util.js

@@ -11,6 +11,7 @@ const vscode_languageserver_2 = require("vscode-languageserver");
 const vscode_uri_1 = require("vscode-uri");
 const xml2js = require("xml2js");
 const DiagnosticMessages_1 = require("./DiagnosticMessages");
+const interfaces_1 = require("./interfaces");
 const BooleanType_1 = require("./types/BooleanType");
 const DoubleType_1 = require("./types/DoubleType");
 const DynamicType_1 = require("./types/DynamicType");
@@ -37,6 +38,8 @@ const ReferenceType_1 = require("./types/ReferenceType");
 const AssociativeArrayType_1 = require("./types/AssociativeArrayType");
 const ComponentType_1 = require("./types/ComponentType");
 const FunctionType_1 = require("./types/FunctionType");
+const helpers_1 = require("./types/helpers");
+const InvalidType_1 = require("./types/InvalidType");
 class Util {
     clearConsole() {
         // process.stdout.write('\x1Bc');
@@ -186,7 +189,7 @@ class Util {
             })) !== null && _a !== void 0 ? _a : {};
             if (parseErrors.length > 0) {
                 let err = parseErrors[0];
-                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.bsConfigJsonHasSyntaxErrors((0, jsonc_parser_1.printParseErrorCode)(parseErrors[0].error))), { location: {
+                let diagnostic = Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.syntaxError(`Syntax errors in bsconfig.json: ${(0, jsonc_parser_1.printParseErrorCode)(parseErrors[0].error)}`)), { location: {
                         uri: this.pathToUri(configFilePath),
                         range: this.getRangeFromOffsetLength(projectFileContents, err.offset, err.length)
                     } });
@@ -1270,7 +1273,7 @@ class Util {
             case TokenKind_1.TokenKind.IntegerLiteral:
                 return IntegerType_1.IntegerType.instance;
             case TokenKind_1.TokenKind.Invalid:
-                return DynamicType_1.DynamicType.instance; // TODO: use InvalidType better new InvalidType(token.text);
+                return new InvalidType_1.InvalidType(token.text);
             case TokenKind_1.TokenKind.LongInteger:
                 return new LongIntegerType_1.LongIntegerType(token.text);
             case TokenKind_1.TokenKind.LongIntegerLiteral:
@@ -1301,7 +1304,7 @@ class Util {
                     case 'integer':
                         return new IntegerType_1.IntegerType(token.text);
                     case 'invalid':
-                        return DynamicType_1.DynamicType.instance; // TODO: use InvalidType better new InvalidType(token.text);
+                        return new InvalidType_1.InvalidType(token.text);
                     case 'longinteger':
                         return new LongIntegerType_1.LongIntegerType(token.text);
                     case 'object':
@@ -1473,20 +1476,50 @@ class Util {
                 return this.binaryOperatorResultType(lhs, op, rhs);
             });
         }
+        // Try to find a common value of union type
+        leftType = (0, helpers_1.getUniqueType)([leftType], UnionType_1.unionTypeFactory);
+        rightType = (0, helpers_1.getUniqueType)([rightType], UnionType_1.unionTypeFactory);
+        if ((0, reflection_1.isUnionType)(leftType)) {
+            leftType = this.getHighestPriorityType(leftType.types);
+        }
+        if ((0, reflection_1.isUnionType)(rightType)) {
+            rightType = this.getHighestPriorityType(rightType.types);
+        }
+        if ((0, reflection_1.isVoidType)(leftType) || (0, reflection_1.isVoidType)(rightType) || (0, reflection_1.isUninitializedType)(leftType) || (0, reflection_1.isUninitializedType)(rightType)) {
+            return undefined;
+        }
         if ((0, reflection_1.isEnumMemberType)(leftType)) {
             leftType = leftType.underlyingType;
         }
         if ((0, reflection_1.isEnumMemberType)(rightType)) {
             rightType = rightType.underlyingType;
         }
+        // treat object type like dynamic
+        if ((0, reflection_1.isObjectType)(leftType)) {
+            leftType = DynamicType_1.DynamicType.instance;
+        }
+        if ((0, reflection_1.isObjectType)(rightType)) {
+            rightType = DynamicType_1.DynamicType.instance;
+        }
         let hasDouble = (0, reflection_1.isDoubleType)(leftType) || (0, reflection_1.isDoubleType)(rightType);
         let hasFloat = (0, reflection_1.isFloatType)(leftType) || (0, reflection_1.isFloatType)(rightType);
         let hasLongInteger = (0, reflection_1.isLongIntegerType)(leftType) || (0, reflection_1.isLongIntegerType)(rightType);
         let hasInvalid = (0, reflection_1.isInvalidType)(leftType) || (0, reflection_1.isInvalidType)(rightType);
         let hasDynamic = (0, reflection_1.isDynamicType)(leftType) || (0, reflection_1.isDynamicType)(rightType);
+        let bothDynamic = (0, reflection_1.isDynamicType)(leftType) && (0, reflection_1.isDynamicType)(rightType);
         let bothNumbers = (0, reflection_1.isNumberType)(leftType) && (0, reflection_1.isNumberType)(rightType);
+        let hasNumber = (0, reflection_1.isNumberType)(leftType) || (0, reflection_1.isNumberType)(rightType);
         let bothStrings = (0, reflection_1.isStringType)(leftType) && (0, reflection_1.isStringType)(rightType);
+        let hasString = (0, reflection_1.isStringType)(leftType) || (0, reflection_1.isStringType)(rightType);
+        let hasBoolean = (0, reflection_1.isBooleanType)(leftType) || (0, reflection_1.isBooleanType)(rightType);
         let eitherBooleanOrNum = ((0, reflection_1.isNumberType)(leftType) || (0, reflection_1.isBooleanType)(leftType)) && ((0, reflection_1.isNumberType)(rightType) || (0, reflection_1.isBooleanType)(rightType));
+        let leftIsPrimitive = (0, reflection_1.isPrimitiveType)(leftType);
+        let rightIsPrimitive = (0, reflection_1.isPrimitiveType)(rightType);
+        let hasPrimitive = leftIsPrimitive || rightIsPrimitive;
+        let nonDynamicType;
+        if (hasPrimitive) {
+            nonDynamicType = leftIsPrimitive ? leftType : rightType;
+        }
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (operator.kind) {
             // Math operators
@@ -1496,6 +1529,10 @@ class Util {
                     // "string" + "string" is the only binary expression allowed with strings
                     return StringType_1.StringType.instance;
                 }
+                else if (hasString && hasDynamic) {
+                    // assume dynamicValue is a string
+                    return StringType_1.StringType.instance;
+                }
             // eslint-disable-next-line no-fallthrough
             case TokenKind_1.TokenKind.Minus:
             case TokenKind_1.TokenKind.MinusEqual:
@@ -1514,6 +1551,10 @@ class Util {
                     }
                     return IntegerType_1.IntegerType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return nonDynamicType;
+                }
                 break;
             case TokenKind_1.TokenKind.Forwardslash:
             case TokenKind_1.TokenKind.ForwardslashEqual:
@@ -1529,6 +1570,10 @@ class Util {
                     }
                     return FloatType_1.FloatType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return nonDynamicType;
+                }
                 break;
             case TokenKind_1.TokenKind.Backslash:
             case TokenKind_1.TokenKind.BackslashEqual:
@@ -1538,6 +1583,10 @@ class Util {
                     }
                     return IntegerType_1.IntegerType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return IntegerType_1.IntegerType.instance;
+                }
                 break;
             case TokenKind_1.TokenKind.Caret:
                 if (bothNumbers) {
@@ -1549,6 +1598,10 @@ class Util {
                     }
                     return IntegerType_1.IntegerType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return IntegerType_1.IntegerType.instance;
+                }
                 break;
             // Bitshift operators
             case TokenKind_1.TokenKind.LeftShift:
@@ -1563,6 +1616,10 @@ class Util {
                     // but will always truncate to ints
                     return IntegerType_1.IntegerType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a number
+                    return IntegerType_1.IntegerType.instance;
+                }
                 break;
             // Comparison operators
             // All comparison operators result in boolean
@@ -1580,6 +1637,10 @@ class Util {
                 if (bothStrings || bothNumbers) {
                     return BooleanType_1.BooleanType.instance;
                 }
+                else if ((hasNumber || hasString) && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return BooleanType_1.BooleanType.instance;
+                }
                 break;
             // Logical or bitwise operators
             case TokenKind_1.TokenKind.Or:
@@ -1596,17 +1657,81 @@ class Util {
                     // "and"/"or" represent logical operators
                     return BooleanType_1.BooleanType.instance;
                 }
+                else if (hasNumber && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return IntegerType_1.IntegerType.instance;
+                }
+                else if (hasBoolean && hasDynamic) {
+                    // assume dynamic is a valid type
+                    return BooleanType_1.BooleanType.instance;
+                }
                 break;
         }
-        return DynamicType_1.DynamicType.instance;
+        if (bothDynamic) {
+            return DynamicType_1.DynamicType.instance;
+        }
+        return undefined;
+    }
+    getHighestPriorityType(types, depth = 0) {
+        let result;
+        if (depth > 4) {
+            // shortcut for very complicated types, or self-referencing union types
+            return DynamicType_1.DynamicType.instance;
+        }
+        for (let type of types) {
+            if ((0, reflection_1.isUnionType)(type)) {
+                type = (0, helpers_1.getUniqueType)([type], UnionType_1.unionTypeFactory);
+                if ((0, reflection_1.isUnionType)(type)) {
+                    type = this.getHighestPriorityType(type.types, depth + 1);
+                }
+            }
+            if (!result) {
+                result = type;
+            }
+            else {
+                if (type.binaryOpPriorityLevel < result.binaryOpPriorityLevel) {
+                    result = type;
+                }
+                else if (type.binaryOpPriorityLevel === result.binaryOpPriorityLevel && !result.isEqual(type)) {
+                    // equal priority types, but not equal types, like Boolean and String... just be dynamic at this point
+                    result = DynamicType_1.DynamicType.instance;
+                }
+            }
+            if ((0, reflection_1.isUninitializedType)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isVoidType)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isInvalidType)(type)) {
+                return type;
+            }
+            if ((0, reflection_1.isObjectType)(type) && !(0, reflection_1.isDynamicType)(type)) {
+                result = type;
+            }
+            if ((0, reflection_1.isDynamicType)(type)) {
+                result = type;
+            }
+        }
+        return result !== null && result !== void 0 ? result : DynamicType_1.DynamicType.instance;
     }
     /**
      * Return the type of the result of a binary operator
      */
     unaryOperatorResultType(operator, exprType) {
+        if ((0, reflection_1.isUnionType)(exprType)) {
+            exprType = this.getHighestPriorityType(exprType.types);
+        }
+        if ((0, reflection_1.isVoidType)(exprType) || (0, reflection_1.isInvalidType)(exprType) || (0, reflection_1.isUninitializedType)(exprType)) {
+            return undefined;
+        }
+        if ((0, reflection_1.isDynamicType)(exprType) || (0, reflection_1.isObjectType)(exprType)) {
+            return exprType;
+        }
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (operator.kind) {
             // Math operators
+            case TokenKind_1.TokenKind.Plus: // (`num = +num` is valid syntax)
             case TokenKind_1.TokenKind.Minus:
                 if ((0, reflection_1.isNumberType)(exprType)) {
                     // a negative number will be the same type, eg, double->double, int->int, etc.
@@ -1627,7 +1752,7 @@ class Util {
                 }
                 break;
         }
-        return DynamicType_1.DynamicType.instance;
+        return undefined;
     }
     /**
      * Get the extension for the given file path. Basically the part after the final dot, except for
@@ -1781,7 +1906,7 @@ class Util {
                 return clone;
                 //filter out null relatedInformation items
             }).filter((x) => Boolean(x)),
-            code: diagnostic.code,
+            code: diagnostic.code ? diagnostic.code : diagnostic.legacyCode,
             source: 'brs'
         };
         if (((_d = diagnostic === null || diagnostic === void 0 ? void 0 : diagnostic.tags) === null || _d === void 0 ? void 0 : _d.length) > 0) {
@@ -2058,7 +2183,7 @@ class Util {
         }
     }
     processTypeChain(typeChain) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         let fullChainName = '';
         let fullErrorName = '';
         let itemName = '';
@@ -2070,6 +2195,7 @@ class Util {
         let errorLocation;
         let containsDynamic = false;
         let continueResolvingAllItems = true;
+        let crossedCallFunc = false;
         for (let i = 0; i < typeChain.length; i++) {
             const chainItem = typeChain[i];
             const dotSep = (_b = (_a = chainItem.separatorToken) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '.';
@@ -2117,6 +2243,7 @@ class Util {
                 itemName = chainItem.name;
                 astNode = chainItem.astNode;
                 containsDynamic = containsDynamic || ((0, reflection_1.isDynamicType)(chainItem.type) && !(0, reflection_1.isAnyReferenceType)(chainItem.type));
+                crossedCallFunc = crossedCallFunc || ((_e = chainItem.data) === null || _e === void 0 ? void 0 : _e.isFromCallFunc);
                 if (!chainItem.isResolved) {
                     errorLocation = chainItem.location;
                     continueResolvingAllItems = false;
@@ -2132,18 +2259,19 @@ class Util {
             fullChainName: fullChainName,
             location: errorLocation,
             containsDynamic: containsDynamic,
-            astNode: astNode
+            astNode: astNode,
+            crossedCallFunc: crossedCallFunc
         };
     }
     isInTypeExpression(expression) {
         //TODO: this is much faster than node.findAncestor(), but may need to be updated for "complicated" type expressions
         if ((0, reflection_1.isTypeExpression)(expression) ||
-            (0, reflection_1.isTypeExpression)(expression.parent) ||
+            (0, reflection_1.isTypeExpression)(expression === null || expression === void 0 ? void 0 : expression.parent) ||
             (0, reflection_1.isTypedArrayExpression)(expression) ||
-            (0, reflection_1.isTypedArrayExpression)(expression.parent)) {
+            (0, reflection_1.isTypedArrayExpression)(expression === null || expression === void 0 ? void 0 : expression.parent)) {
             return true;
         }
-        if ((0, reflection_1.isBinaryExpression)(expression.parent)) {
+        if ((0, reflection_1.isBinaryExpression)(expression === null || expression === void 0 ? void 0 : expression.parent)) {
             let currentExpr = expression.parent;
             while ((0, reflection_1.isBinaryExpression)(currentExpr) && currentExpr.tokens.operator.kind === TokenKind_1.TokenKind.Or) {
                 currentExpr = currentExpr.parent;
@@ -2152,6 +2280,15 @@ class Util {
         }
         return false;
     }
+    isGenericNodeType(type) {
+        if ((0, reflection_1.isComponentType)(type)) {
+            const lowerName = type.toString().toLowerCase();
+            if (lowerName === 'rosgnode' || lowerName === 'rosgnodenode') {
+                return true;
+            }
+        }
+        return false;
+    }
     hasAnyRequiredSymbolChanged(requiredSymbols, changedSymbols) {
         if (!requiredSymbols || !changedSymbols) {
             return false;
@@ -2176,6 +2313,21 @@ class Util {
         }
         return false;
     }
+    getCustomTypesInSymbolTree(setToFill, type, filter) {
+        var _a, _b, _c;
+        const subSymbols = (_b = (_a = type.getMemberTable()) === null || _a === void 0 ? void 0 : _a.getAllSymbols(1 /* SymbolTypeFlag.runtime */)) !== null && _b !== void 0 ? _b : [];
+        for (const subSymbol of subSymbols) {
+            if (!((_c = subSymbol.type) === null || _c === void 0 ? void 0 : _c.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);
+            }
+        }
+    }
     truncate(options) {
         var _a, _b, _c, _d, _e, _f, _g;
         let leadingText = options.leadingText;
@@ -2256,13 +2408,18 @@ class Util {
         }
         return false;
     }
-    getSpecialCaseCallExpressionReturnType(callExpr) {
-        var _a, _b, _c, _d;
+    getSpecialCaseCallExpressionReturnType(callExpr, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
         if ((0, reflection_1.isVariableExpression)(callExpr.callee) && callExpr.callee.tokens.name.text.toLowerCase() === 'createobject') {
             const componentName = (0, reflection_1.isLiteralString)(callExpr.args[0]) ? (_b = (_a = callExpr.args[0].tokens.value) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.replace(/"/g, '') : '';
             const nodeType = componentName.toLowerCase() === 'rosgnode' && (0, reflection_1.isLiteralString)(callExpr.args[1]) ? (_d = (_c = callExpr.args[1].tokens.value) === null || _c === void 0 ? void 0 : _c.text) === null || _d === void 0 ? void 0 : _d.replace(/"/g, '') : '';
             if (componentName === null || componentName === void 0 ? void 0 : 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, {
@@ -2276,6 +2433,72 @@ class Util {
                 }
             }
         }
+        else if ((0, reflection_1.isDottedGetExpression)(callExpr.callee) &&
+            ((_g = (_f = (_e = callExpr.callee.tokens) === null || _e === void 0 ? void 0 : _e.name) === null || _f === void 0 ? void 0 : _f.text) === null || _g === void 0 ? void 0 : _g.toLowerCase()) === 'callfunc' &&
+            (0, reflection_1.isLiteralString)((_h = callExpr.args) === null || _h === void 0 ? void 0 : _h[0])) {
+            return this.getCallFuncType(callExpr, (_k = (_j = callExpr.args) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.tokens.value, options);
+        }
+        else if ((0, reflection_1.isDottedGetExpression)(callExpr.callee) &&
+            ((_o = (_m = (_l = callExpr.callee.tokens) === null || _l === void 0 ? void 0 : _l.name) === null || _m === void 0 ? void 0 : _m.text) === null || _o === void 0 ? void 0 : _o.toLowerCase()) === 'createchild' &&
+            (0, reflection_1.isComponentType)((_p = callExpr.callee.obj) === null || _p === void 0 ? void 0 : _p.getType({ flags: 1 /* SymbolTypeFlag.runtime */ })) &&
+            (0, reflection_1.isLiteralString)((_q = callExpr.args) === null || _q === void 0 ? void 0 : _q[0])) {
+            const fullName = `roSGNode${(_u = (_t = (_s = (_r = callExpr.args) === null || _r === void 0 ? void 0 : _r[0].tokens) === null || _s === void 0 ? void 0 : _s.value) === null || _t === void 0 ? void 0 : _t.text) === null || _u === void 0 ? void 0 : _u.replace(/"/g, '')}`;
+            const data = {};
+            const symbolTable = callExpr.getSymbolTable();
+            return symbolTable.getSymbolType(fullName, {
+                flags: 2 /* SymbolTypeFlag.typetime */,
+                data: data,
+                tableProvider: () => callExpr === null || callExpr === void 0 ? void 0 : callExpr.getSymbolTable(),
+                fullName: fullName
+            });
+        }
+    }
+    getCallFuncType(callExpr, methodNameToken, options) {
+        var _a, _b, _c, _d, _e;
+        let result;
+        let methodName = (_a = methodNameToken === null || methodNameToken === void 0 ? void 0 : methodNameToken.text) === null || _a === void 0 ? void 0 : _a.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;
+        if ((0, reflection_1.isCallfuncExpression)(callExpr)) {
+            calleeType = callExpr.callee.getType(Object.assign(Object.assign({}, options), { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: false }));
+        }
+        else if ((0, reflection_1.isCallExpression)(callExpr) && (0, reflection_1.isDottedGetExpression)(callExpr.callee)) {
+            calleeType = callExpr.callee.obj.getType(Object.assign(Object.assign({}, options), { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: false }));
+        }
+        if ((0, reflection_1.isComponentType)(calleeType) || (0, reflection_1.isReferenceType)(calleeType)) {
+            const funcType = (_c = (_b = calleeType).getCallFuncType) === null || _c === void 0 ? void 0 : _c.call(_b, methodName, options);
+            if (funcType) {
+                (_d = options.typeChain) === null || _d === void 0 ? void 0 : _d.push(new interfaces_1.TypeChainEntry({
+                    name: methodName,
+                    type: funcType,
+                    data: options.data,
+                    location: methodNameToken.location,
+                    separatorToken: (0, creators_1.createToken)(TokenKind_1.TokenKind.Callfunc),
+                    astNode: callExpr
+                }));
+                if (options.ignoreCall) {
+                    result = funcType;
+                }
+                else if ((0, reflection_1.isCallableType)(funcType) && (!(0, reflection_1.isReferenceType)(funcType.returnType) || funcType.returnType.isResolvable())) {
+                    result = funcType.returnType;
+                }
+                else if (!(0, reflection_1.isReferenceType)(funcType) && ((_e = funcType === null || funcType === void 0 ? void 0 : funcType.returnType) === null || _e === void 0 ? void 0 : _e.isResolvable())) {
+                    result = funcType.returnType;
+                }
+                else {
+                    result = new ReferenceType_1.TypePropertyReferenceType(funcType, 'returnType');
+                }
+            }
+        }
+        if ((0, reflection_1.isVoidType)(result)) {
+            // CallFunc will always return invalid, even if function called is `as void`
+            result = DynamicType_1.DynamicType.instance;
+        }
+        if (options.data && !options.ignoreCall) {
+            options.data.isFromCallFunc = true;
+        }
+        return result;
     }
     symbolComesFromSameNode(symbolName, definingNode, symbolTable) {
         let nsData = {};
@@ -2358,6 +2581,50 @@ class Util {
         }
         return returnType;
     }
+    /**
+     * Gets the type for a default value (eg. as a function param, class member or typed array)
+     */
+    getDefaultTypeFromValueType(valueType) {
+        var _a;
+        if (!valueType) {
+            return undefined;
+        }
+        let resultType = DynamicType_1.DynamicType.instance;
+        if (Array.isArray(valueType)) {
+            // passed an array opf types, potential from ArrayType.innerTypes
+            if (valueType.length > 0) {
+                //at least one, use it
+                resultType = valueType[0];
+                if ((valueType === null || valueType === void 0 ? void 0 : valueType.length) > 1) {
+                    // more than 1, find union
+                    resultType = (0, helpers_1.getUniqueType)(valueType, UnionType_1.unionTypeFactory);
+                }
+            }
+        }
+        else {
+            resultType = valueType;
+        }
+        if (!resultType.isResolvable()) {
+            resultType = new ReferenceType_1.ParamTypeFromValueReferenceType(resultType);
+        }
+        else if ((0, reflection_1.isEnumMemberType)(resultType)) {
+            // the type was an enum member... Try to get the parent enum type
+            resultType = (_a = resultType.parentEnumType) !== null && _a !== void 0 ? _a : resultType;
+        }
+        else if ((0, reflection_1.isUnionType)(resultType)) {
+            // it was a union -- I wonder if they're resolvable now?
+            const moddedTypes = resultType.types.map(t => {
+                var _a;
+                if ((0, reflection_1.isEnumMemberType)(t)) {
+                    // the type was an enum member... Try to get the parent enum type
+                    return (_a = t.parentEnumType) !== null && _a !== void 0 ? _a : resultType;
+                }
+                return t;
+            });
+            resultType = (0, helpers_1.getUniqueType)(moddedTypes, UnionType_1.unionTypeFactory);
+        }
+        return resultType;
+    }
 }
 exports.Util = Util;
 /**