brighterscript 1.0.0-alpha.2 → 1.0.0-alpha.22

package/dist/parser/Parser.d.ts

@@ -1,12 +1,13 @@
-import type { Token, Identifier } from '../lexer';
+import type { Token, Identifier } from '../lexer/Token';
+import { TokenKind } from '../lexer/TokenKind';
 import type { Statement } from './Statement';
-import { AssignmentStatement, Body, ClassStatement, FunctionStatement, ImportStatement, LibraryStatement, NamespaceStatement } from './Statement';
+import { AssignmentStatement, Body, ClassStatement, DottedSetStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement } from './Statement';
 import type { Expression } from './Expression';
-import { CallExpression, FunctionExpression, NewExpression, VariableExpression, AnnotationExpression } from './Expression';
-import type { Diagnostic } from 'vscode-languageserver';
+import { AALiteralExpression, AnnotationExpression, FunctionExpression, NewExpression } from './Expression';
+import type { Diagnostic, Position } from 'vscode-languageserver';
 import { Logger } from '../Logger';
-import type { BscType } from '../types/BscType';
 import { SymbolTable } from '../SymbolTable';
+import type { BscType } from '../types/BscType';
 export declare class Parser {
     /**
      * The array of tokens passed to `parse()`
@@ -77,8 +78,7 @@ export declare class Parser {
     /**
      * Static wrapper around creating a new parser and parsing a list of tokens
      */
-    static parse(source: string, options?: ParseOptions): Parser;
-    static parse(tokens: Token[], options?: ParseOptions): Parser;
+    static parse(toParse: Token[] | string, options?: ParseOptions): Parser;
     /**
      * Parses an array of `Token`s into an abstract syntax tree
      * @param toParse the array of tokens to parse. May not contain any whitespace tokens
@@ -101,17 +101,29 @@ export declare class Parser {
      */
     private lastDiagnosticAsError;
     private declaration;
+    /**
+     * Try to get an identifier. If not found, add diagnostic and return undefined
+     */
+    private tryIdentifier;
+    private identifier;
+    private enumMemberStatement;
+    /**
+     * Create a new InterfaceFieldStatement. This should only be called from within `interfaceDeclaration`
+     */
+    private interfaceFieldStatement;
+    private interfaceDeclaration;
+    private enumDeclaration;
     /**
      * A BrighterScript class declaration
      */
     private classDeclaration;
-    private classFieldDeclaration;
+    private fieldDeclaration;
     /**
      * An array of CallExpression for the current function body
      */
     private callExpressions;
+    private functionStatement;
     private functionDeclaration;
-    private identifier;
     private functionParameter;
     private assignment;
     private checkLibrary;
@@ -142,6 +154,7 @@ export declare class Parser {
     private annotationExpression;
     private ternaryExpression;
     private nullCoalescingExpression;
+    private regexLiteralExpression;
     private templateString;
     private tryCatchStatement;
     private throwStatement;
@@ -212,10 +225,12 @@ export declare class Parser {
     /**
      * 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 always return a token of whatever is next to be parsed
+     * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
      */
-    private typeToken;
+    private typeExpression;
     private primary;
+    private arrayLiteral;
+    private aaLiteral;
     /**
      * Pop token if we encounter specified token
      */
@@ -225,14 +240,21 @@ export declare class Parser {
      * @param tokenKinds
      */
     private matchAny;
+    /**
+     * If the next series of tokens matches the given set of tokens, pop them all
+     * @param tokenKinds
+     */
+    private matchSequence;
     /**
      * Get next token matching a specified list, or fail with an error
      */
     private consume;
+    private consumeToken;
     /**
      * Consume, or add a message if not found. But then continue and return undefined
      */
     private tryConsume;
+    private tryConsumeToken;
     private consumeStatementSeparators;
     private advance;
     private checkEndOfStatement;
@@ -245,13 +267,62 @@ export declare class Parser {
     private peekNext;
     private peek;
     private previous;
+    /**
+     * Get the token that is {offset} indexes away from {this.current}
+     * @param offset the number of index steps away from current index to fetch
+     * @param tokenKinds the desired token must match one of these
+     * @example
+     * getToken(-1); //returns the previous token.
+     * getToken(0);  //returns current token.
+     * getToken(1);  //returns next token
+     */
+    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;
+    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 {
@@ -269,8 +340,11 @@ 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[];
@@ -280,6 +354,22 @@ export declare class References {
      */
     get functionStatementLookup(): Map<string, FunctionStatement>;
     private _functionStatementLookup;
+    interfaceStatements: InterfaceStatement[];
+    get interfaceStatementLookup(): Map<string, InterfaceStatement>;
+    private _interfaceStatementLookup;
+    enumStatements: EnumStatement[];
+    get enumStatementLookup(): Map<string, EnumStatement>;
+    /**
+     * 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.
+     */
+    expressions: Set<Expression>;
     importStatements: ImportStatement[];
     libraryStatements: LibraryStatement[];
     namespaceStatements: NamespaceStatement[];
@@ -291,31 +381,64 @@ export interface LocalVarEntry {
     nameToken: Identifier;
     type: BscType;
 }
+export declare enum TokenUsage {
+    Direct = 1,
+    Call = 2,
+    ArrayReference = 3
+}
 /**
- * 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
+ * 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 declare function getBscTypeFromExpression(expression: Expression, functionExpression: FunctionExpression): BscType;
+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;
+}
 /**
- * Gets the return type of a function, taking into account that the function may not have been declared yet
- * If the callee already exists in symbol table, use that return type
- * otherwise, make a lazy type which will not compute its type until the file is done parsing
- *
- * @param call the Expression to process
- * @param functionExpression the wrapping function expression
- * @return the best guess type of that expression
+ * 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 declare function getTypeFromCallExpression(call: CallExpression, functionExpression: FunctionExpression): BscType;
+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 a variable
- * if it already exists in symbol table, use that type
- * otherwise defer the type until first read, which will allow us to derive types from variables defined after this one (like from a loop perhaps)
+ * Gets the type of an expression. If it can not be processed, will return DynamicType
  *
- * @param variable the Expression to process
+ * @param expression the Expression to process
  * @param functionExpression the wrapping function expression
  * @return the best guess type of that expression
  */
-export declare function getTypeFromVariableExpression(variable: VariableExpression, functionExpression: FunctionExpression): BscType;
+export declare function getBscTypeFromExpression(expression: Expression, functionExpression: FunctionExpression): BscType;