brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/parser/Parser.d.ts

@@ -1,13 +1,10 @@
-import type { Token, Identifier } from '../lexer/Token';
-import { TokenKind } from '../lexer/TokenKind';
-import type { Statement } from './Statement';
-import { AssignmentStatement, Body, ClassStatement, ConstStatement, DottedSetStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement } from './Statement';
-import type { Expression } from './Expression';
-import { AALiteralExpression, AnnotationExpression, FunctionExpression, NewExpression } from './Expression';
-import type { Diagnostic, Position } from 'vscode-languageserver';
+import type { Token } from '../lexer/Token';
+import { Body } from './Statement';
+import { AnnotationExpression } from './Expression';
+import type { Diagnostic } from 'vscode-languageserver';
 import { Logger } from '../Logger';
+import type { Statement } from './AstNode';
 import { SymbolTable } from '../SymbolTable';
-import type { BscType } from '../types/BscType';
 export declare class Parser {
     /**
      * The array of tokens passed to `parse()`
@@ -23,23 +20,9 @@ export declare class Parser {
     ast: Body;
     get statements(): Statement[];
     /**
-     * The top-level symbol table for this file. Things like top-level namespaces, non-namespaced classes, enums, interfaces, and functions beling here.
+     * The top-level symbol table for the body of this file.
      */
-    symbolTable: SymbolTable;
-    private get currentSymbolTable();
-    /**
-     * References for significant statements/expressions in the parser.
-     * These are initially extracted during parse-time to improve performance, but will also be dynamically regenerated if need be.
-     *
-     * If a plugin modifies the AST, then the plugin should call Parser#invalidateReferences() to force this object to refresh
-     */
-    get references(): References;
-    private _references;
-    /**
-     * Invalidates (clears) the references collection. This should be called anytime the AST has been manipulated.
-     */
-    invalidateReferences(): void;
-    private addPropertyHints;
+    get symbolTable(): SymbolTable;
     /**
      * The list of diagnostics found during the parse process
      */
@@ -53,18 +36,6 @@ export declare class Parser {
      */
     options: ParseOptions;
     private globalTerminators;
-    /**
-     * When a namespace has been started, this gets set. When it's done, this gets unset.
-     * It is useful for passing the namespace into certain statements that need it
-     */
-    private currentNamespace;
-    private get currentNamespaceName();
-    /**
-     * When a FunctionExpression has been started, this gets set. When it's done, this gets unset.
-     * It's useful for passing the function into statements and expressions that need to be located
-     * by function later on.
-     */
-    private currentFunctionExpression;
     /**
      * A list of identifiers that are permitted to be used as local variables. We store this in a property because we augment the list in the constructor
      * based on the parse mode
@@ -111,9 +82,14 @@ export declare class Parser {
     private identifier;
     private enumMemberStatement;
     /**
-     * Create a new InterfaceFieldStatement. This should only be called from within `interfaceDeclaration`
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
      */
     private interfaceFieldStatement;
+    private consumeAsTokenAndTypeExpression;
+    /**
+     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
+     */
+    private interfaceMethodStatement;
     private interfaceDeclaration;
     private enumDeclaration;
     /**
@@ -125,7 +101,6 @@ export declare class Parser {
      * An array of CallExpression for the current function body
      */
     private callExpressions;
-    private functionStatement;
     private functionDeclaration;
     private functionParameter;
     private assignment;
@@ -141,15 +116,15 @@ export declare class Parser {
     /**
      * Get an expression with identifiers separated by periods. Useful for namespaces and class extends
      */
-    private getNamespacedVariableNameExpression;
+    private identifyingExpression;
     /**
      * Add an 'unexpected token' diagnostic for any token found between current and the first stopToken found.
      */
     private flagUntil;
     /**
      * Consume tokens until one of the `stopTokenKinds` is encountered
-     * @param tokenKinds
-     * @return - the list of tokens consumed, EXCLUDING the `stopTokenKind` (you can use `this.peek()` to see which one it was)
+     * @param stopTokenKinds a list of tokenKinds where any tokenKind in this list will result in a match
+     * @returns - the list of tokens consumed, EXCLUDING the `stopTokenKind` (you can use `this.peek()` to see which one it was)
      */
     private consumeUntil;
     private constDeclaration;
@@ -181,6 +156,10 @@ export declare class Parser {
      * @returns an AST representation of an `label` statement.
      */
     private labelStatement;
+    /**
+     * Parses a `continue` statement
+     */
+    private continueStatement;
     /**
      * Parses a `goto` statement
      * @returns an AST representation of an `goto` statement.
@@ -214,7 +193,6 @@ export declare class Parser {
     private anonymousFunction;
     private boolean;
     private relational;
-    private addExpressionsToReferences;
     private additive;
     private multiplicative;
     private exponential;
@@ -228,11 +206,17 @@ export declare class Parser {
     private call;
     private finishCall;
     /**
-     * Tries to get the next token as a type
-     * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
-     * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
+     * Creates a TypeExpression, which wraps standard ASTNodes that represent a BscType
      */
     private typeExpression;
+    /**
+     * Gets a single "part" of a type of a potential Union type
+     * Note: this does not NEED to be part of a union type, but the logic is the same
+     *
+     * @param changedTokens an array that is modified with any tokens that have been changed from their default kind to identifiers - eg. when a keyword is used as type
+     * @returns an expression that was successfully parsed
+     */
+    private getTypeExpressionPart;
     private primary;
     private arrayLiteral;
     private aaLiteral;
@@ -242,18 +226,22 @@ export declare class Parser {
     private match;
     /**
      * Pop token if we encounter a token in the specified list
-     * @param tokenKinds
+     * @param tokenKinds a list of tokenKinds where any tokenKind in this list will result in a match
      */
     private matchAny;
     /**
      * If the next series of tokens matches the given set of tokens, pop them all
-     * @param tokenKinds
+     * @param tokenKinds a list of tokenKinds used to match the next set of tokens
      */
     private matchSequence;
     /**
      * Get next token matching a specified list, or fail with an error
      */
     private consume;
+    /**
+     * Consume next token IF it matches the specified kind. Otherwise, do nothing and return undefined
+     */
+    private consumeTokenIf;
     private consumeToken;
     /**
      * Consume, or add a message if not found. But then continue and return undefined
@@ -264,6 +252,11 @@ export declare class Parser {
     private advance;
     private checkEndOfStatement;
     private checkPrevious;
+    /**
+     * Check that the next token kind is the expected kind
+     * @param tokenKind the expected next kind
+     * @returns true if the next tokenKind is the expected value
+     */
     private check;
     private checkAny;
     private checkNext;
@@ -272,6 +265,14 @@ export declare class Parser {
     private peekNext;
     private peek;
     private previous;
+    /**
+     * Sometimes we catch an error that is a diagnostic.
+     * If that's the case, we want to continue parsing.
+     * Otherwise, re-throw the error
+     *
+     * @param error error caught in a try/catch
+     */
+    private rethrowNonDiagnosticError;
     /**
      * Get the token that is {offset} indexes away from {this.current}
      * @param offset the number of index steps away from current index to fetch
@@ -283,52 +284,6 @@ export declare class Parser {
      */
     private getMatchingTokenAtOffset;
     private synchronize;
-    /**
-     * Get the token at the specified position
-     * @param position
-     */
-    getTokenAt(position: Position): Token;
-    /**
-     * Get the token closest to the position. if no token is found, the previous token is returned
-     * @param position
-     * @param tokens
-     */
-    getClosestToken(position: Position): Token;
-    isPositionNextToTokenKind(position: Position, tokenKind: TokenKind): boolean;
-    getTokenBefore(currentToken: Token, tokenKind: TokenKind): Token;
-    tokenFollows(currentToken: Token, tokenKind: TokenKind): boolean;
-    getTokensUntil(currentToken: Token, tokenKind: TokenKind, direction?: -1 | 1): any[];
-    getPreviousToken(token: Token): Token;
-    getPreviousTokenFromIndex(idx: number): TokenWithIndex;
-    getPreviousTokenIgnoreNests(currentTokenIndex: number, leftBracketType: TokenKind, rightBracketType: TokenKind): TokenWithIndex;
-    /**
-     * Finds the previous token in a chain (e.g. 'm.obj.func(someFunc()).value'), skipping over any arguments of function calls
-     * If this function was called with the token at 'value' above, the previous identifier in the chain is 'func'
-     * @param currentTokenIndex token index to start from
-     * @param allowCurrent can the current token be the token that's the identifier?
-     * @returns the previous identifer
-     */
-    getPreviousTokenInChain(currentTokenIndex: number, allowCurrent?: boolean): TokenChainMember;
-    private isAcceptableChainToken;
-    /**
-     * Builds up a chain of tokens, starting with the first in the chain, and ending with currentToken
-     * e.g. m.prop.method().field (with 'field' as currentToken) -> ["m", "prop", "method", "field"], with each element as a token
-     * @param currentToken the token that is the end of the chain
-     * @returns array of tokens
-     */
-    getTokenChain(currentToken: Token): TokenChain;
-    /**
-     * References are found during the initial parse.
-     * However, sometimes plugins can modify the AST, requiring a full walk to re-compute all references.
-     * This does that walk.
-     */
-    private findReferences;
-    getContainingExpression(currentToken: Token): Expression;
-    getContainingClass(currentToken: Token): ClassStatement;
-    getContainingAA(currentToken: Token): AALiteralExpression;
-    getContainingNamespace(currentToken: Token): NamespaceStatement;
-    getContainingFunctionExpression(currentToken: Token): FunctionExpression;
-    getContainingFunctionExpressionByPosition(position: Position): FunctionExpression;
     dispose(): void;
 }
 export declare enum ParseMode {
@@ -345,111 +300,3 @@ export interface ParseOptions {
      */
     logger?: Logger;
 }
-export declare class References {
-    private cache;
-    assignmentStatements: AssignmentStatement[];
-    classStatements: ClassStatement[];
-    dottedSetStatements: DottedSetStatement[];
-    aaLiterals: AALiteralExpression[];
-    get classStatementLookup(): Map<string, ClassStatement>;
-    private _classStatementLookup;
-    functionExpressions: FunctionExpression[];
-    functionStatements: FunctionStatement[];
-    /**
-     * A map of function statements, indexed by fully-namespaced lower function name.
-     */
-    get functionStatementLookup(): Map<string, FunctionStatement>;
-    private _functionStatementLookup;
-    interfaceStatements: InterfaceStatement[];
-    get interfaceStatementLookup(): Map<string, InterfaceStatement>;
-    private _interfaceStatementLookup;
-    enumStatements: EnumStatement[];
-    get enumStatementLookup(): Map<string, EnumStatement>;
-    constStatements: ConstStatement[];
-    get constStatementLookup(): Map<string, ConstStatement>;
-    /**
-     * A collection of full expressions. This excludes intermediary expressions.
-     *
-     * Example 1:
-     * `a.b.c` is composed of `a` (variableExpression)  `.b` (DottedGetExpression) `.c` (DottedGetExpression)
-     * This will only contain the final `.c` DottedGetExpression because `.b` and `a` can both be derived by walking back from the `.c` DottedGetExpression.
-     *
-     * Example 2:
-     * `name.space.doSomething(a.b.c)` will result in 2 entries in this list. the `CallExpression` for `doSomething`, and the `.c` DottedGetExpression.
-     *
-     * Example 3:
-     * `value = SomeEnum.value > 2 or SomeEnum.otherValue < 10` will result in 4 entries. `SomeEnum.value`, `2`, `SomeEnum.otherValue`, `10`
-     */
-    expressions: Set<Expression>;
-    importStatements: ImportStatement[];
-    libraryStatements: LibraryStatement[];
-    namespaceStatements: NamespaceStatement[];
-    newExpressions: NewExpression[];
-    propertyHints: Record<string, string>;
-}
-export interface LocalVarEntry {
-    lowerName: string;
-    nameToken: Identifier;
-    type: BscType;
-}
-export declare enum TokenUsage {
-    Direct = 1,
-    Call = 2,
-    ArrayReference = 3
-}
-/**
- * A member of a token chain - a wrapper around a token, which also gives some context for how it is used, and if the type is knowable
- */
-export interface TokenChainMember {
-    /**
-     * The token
-     */
-    token: Token;
-    /**
-     * Is it impossible to know the the type of this token (for now)
-     */
-    tokenTypeIsNotKnowable?: boolean;
-    /**
-     * How was this token used?
-     */
-    usage: TokenUsage;
-    /**
-     * Index of the token in the parser's token list
-     */
-    index: number;
-}
-/**
- * A token paired with the index it is at in the file
- * Used for when we need to get a token, but may also need the previous or next token
- * This way, we can access the adjacent tokens via their index instead of search
- */
-export interface TokenWithIndex {
-    /**
-     * The token
-     */
-    token: Token;
-    /**
-     * Index of the token in the parser's token list
-     */
-    index: number;
-    /**
-     * Is it impossible to know the the type of this token (for now)
-     */
-    tokenTypeIsNotKnowable?: boolean;
-    /**
-     * does this token have brackets (either parens or square brackets) after it
-     */
-    hasBrackets?: boolean;
-}
-export interface TokenChain {
-    chain: TokenChainMember[];
-    includesUnknowableTokenType?: boolean;
-}
-/**
- * Gets the type of an expression. If it can not be processed, will return DynamicType
- *
- * @param expression the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
- */
-export declare function getBscTypeFromExpression(expression: Expression, functionExpression?: FunctionExpression): BscType;