brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/types/ReferenceType.d.ts

@@ -0,0 +1,123 @@
+import type { TypeCircularReferenceInfo } from '../interfaces';
+import type { SymbolTableProvider, SymbolTypeGetterProvider } from '../SymbolTable';
+import type { SymbolTypeFlag } from '../SymbolTypeFlag';
+import { BscType } from './BscType';
+import { BscTypeKind } from './BscTypeKind';
+import type { Token } from '../lexer/Token';
+export declare type AnyReferenceType = ReferenceType | TypePropertyReferenceType | BinaryOperatorReferenceType | ArrayDefaultTypeReferenceType;
+export declare function referenceTypeFactory(memberKey: string, fullName: any, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider): ReferenceType;
+export declare class ReferenceType extends BscType {
+    memberKey: string;
+    fullName: any;
+    flags: SymbolTypeFlag;
+    tableProvider: SymbolTypeGetterProvider;
+    /**
+     * ReferenceTypes are used when the actual type may be resolved later from a Symbol table
+     * @param memberKey which key do we use to look up this type in the given table?
+     * @param fullName the full/display name for this type
+     * @param flags is this type available at typetime, runtime, etc.
+     * @param tableProvider function that returns a SymbolTable that we use for the lookup.
+     */
+    constructor(memberKey: string, fullName: any, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider);
+    readonly kind = BscTypeKind.ReferenceType;
+    getTarget(): BscType;
+    /**
+     * Resolves the type based on the original name and the table provider
+     */
+    private resolve;
+    get __reflection(): {
+        name: string;
+    };
+    makeMemberFullName(memberName: string): string;
+    getCircularReferenceInfo(stopAtTypes?: ReferenceType[]): TypeCircularReferenceInfo;
+    private circRefCount;
+    private referenceChain;
+    private propertyTypeReference;
+    private memberTypeReferences;
+    private callFuncMemberTypeReferences;
+    private futureMemberTableProvider;
+    private futureCallFuncMemberTableProvider;
+}
+/**
+ * Use this class for when you need to reference a property of a BscType, and that property is also a BscType,
+ * Especially when the instance with the property may not have been instantiated/discovered yet
+ *
+ * For Example, FunctionType.returnType --- if the FunctionExpression has not been walked yet, it will be a ReferenceType
+ * if we just access .returnType on a ReferenceType that doesn't have access to an actual FunctionType yet, .returnType will be undefined
+ * So when we use this class, it maintains that reference to a potential ReferenceType, and this class will change from
+ * returning undefined to the ACTUAL .returnType when the ReferenceType can be resolved.
+ *
+ * This is really cool. It's like programming with time-travel.
+ */
+export declare class TypePropertyReferenceType extends BscType {
+    outerType: BscType;
+    propertyName: string;
+    constructor(outerType: BscType, propertyName: string);
+    getTarget(): BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Use this class for when there is a binary operator and either the left hand side and/or the right hand side
+ * are ReferenceTypes
+ */
+export declare class BinaryOperatorReferenceType extends BscType {
+    leftType: BscType;
+    operator: Token;
+    rightType: BscType;
+    cachedType: BscType;
+    constructor(leftType: BscType, operator: Token, rightType: BscType, binaryOpResolver: (lType: BscType, operator: Token, rType: BscType) => BscType);
+    getTarget: () => BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Use this class for when there is a presumable array type that is a referenceType
+ */
+export declare class ArrayDefaultTypeReferenceType extends BscType {
+    objType: BscType;
+    constructor(objType: BscType);
+    getTarget: () => BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Used for when a Param's initial value is unresolved
+ * Generally, this will be resolved later *except* for Enum
+ * Enum Types will have an initial value of an EnumMemberType, but the param
+ * should be an EnumType
+ */
+export declare class ParamTypeFromValueReferenceType extends BscType {
+    objType: BscType;
+    cachedType: BscType;
+    constructor(objType: BscType);
+}
+/**
+ * Used when an IntersectionType has at least one member that may have default dynamic members.
+ * If the inner type is not resolvable, this type will resolve to the given type instead.
+ * @example
+ * ```brighterscript
+ *   interface HasAge
+ *       age as integer
+ *   end interface
+ *
+ *   type foo = HasAge and roAssociativeArray
+ *
+ *   sub useFoo(f as foo)
+ *       print f.age ' f.age is an integer
+ *       print f.doesExist("key") ' will result in a boolean, from roAssociativeArray
+ *       print f.someKey ' no idea - so this is dynamic, and will not cause a validation error
+ *   end sub
+ * ```
+ */
+export declare class ReferenceTypeWithDefault extends BscType {
+    baseType: BscType;
+    defaultType: BscType;
+    constructor(baseType: BscType, defaultType: BscType);
+    getTarget(): BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Gives an array of all the symbol names that need to be resolved to make the given reference type be resolved
+ */
+export declare function getAllRequiredSymbolNames(refType: BscType, namespaceLower?: string): Array<{
+    name: string;
+    namespacedName?: string;
+}>;