brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.28

package/dist/interfaces.d.ts

@@ -3,13 +3,12 @@ import type { Range, Diagnostic, CodeAction, SemanticTokenTypes, SemanticTokenMo
 import type { Scope } from './Scope';
 import type { BrsFile } from './files/BrsFile';
 import type { XmlFile } from './files/XmlFile';
-import type { FunctionScope } from './FunctionScope';
 import type { TypedFunctionType } from './types/TypedFunctionType';
 import type { ParseMode } from './parser/Parser';
 import type { Program } from './Program';
 import type { ProgramBuilder } from './ProgramBuilder';
 import type { ClassStatement, ConstStatement, EnumStatement, FunctionStatement, NamespaceStatement } from './parser/Statement';
-import type { AstNode, Expression, Statement } from './parser/AstNode';
+import type { AstNode, AstNodeKind, Expression, Statement } from './parser/AstNode';
 import type { TranspileState } from './parser/TranspileState';
 import type { SourceNode } from 'source-map';
 import type { BscType } from './types/BscType';
@@ -18,8 +17,8 @@ import type { Identifier, Token } from './lexer/Token';
 import type { BscFile } from './files/BscFile';
 import type { FileFactory } from './files/Factory';
 import type { LazyFileData } from './files/LazyFileData';
-import type { SymbolTable, SymbolTypeFlag } from './SymbolTable';
-import type { CallExpression } from './parser/Expression';
+import type { SymbolTable } from './SymbolTable';
+import type { SymbolTypeFlag } from './SymbolTypeFlag';
 export interface BsDiagnostic extends Diagnostic {
     file: BscFile;
     /**
@@ -73,28 +72,6 @@ export interface Callable {
      */
     functionStatement: FunctionStatement;
 }
-export interface FunctionCall {
-    /**
-     * The full range of this function call (from the start of the function name to its closing paren)
-     */
-    range: Range;
-    expression: CallExpression;
-    functionScope: FunctionScope;
-    file: BscFile;
-    name: string;
-    args: CallableArg[];
-    nameRange: Range;
-}
-/**
- * An argument for an expression call.
- */
-export interface CallableArg {
-    text: string;
-    type: BscType;
-    typeToken: Token;
-    range: Range;
-    expression: Expression;
-}
 export interface CallableParam {
     name: string;
     type: BscType;
@@ -182,71 +159,71 @@ export interface CompilerPlugin {
     /**
      * Called before a new program is created
      */
-    beforeProgramCreate?: PluginHandler<BeforeProgramCreateEvent>;
+    beforeProgramCreate?(event: BeforeProgramCreateEvent): any;
     /**
      * Called after a new program is created
      */
-    afterProgramCreate?: PluginHandler<AfterProgramCreateEvent>;
+    afterProgramCreate?(event: AfterProgramCreateEvent): any;
     /**
      * Called before the program gets prepared for building
      */
-    beforePrepareProgram?: PluginHandler<BeforePrepareProgramEvent>;
+    beforePrepareProgram?(event: BeforePrepareProgramEvent): any;
     /**
      * Called when the program gets prepared for building
      */
-    prepareProgram?: PluginHandler<PrepareProgramEvent>;
+    prepareProgram?(event: PrepareProgramEvent): any;
     /**
      * Called after the program gets prepared for building
      */
-    afterPrepareProgram?: PluginHandler<AfterPrepareProgramEvent>;
+    afterPrepareProgram?(event: AfterPrepareProgramEvent): any;
     /**
      * Called before the entire program is validated
      */
-    beforeProgramValidate?: PluginHandler<BeforeProgramValidateEvent>;
+    beforeProgramValidate?(event: BeforeProgramValidateEvent): any;
     /**
      * Called before the entire program is validated
      */
-    onProgramValidate?: PluginHandler<OnProgramValidateEvent>;
+    onProgramValidate?(event: OnProgramValidateEvent): any;
     /**
      * Called after the program has been validated
      */
-    afterProgramValidate?: PluginHandler<AfterProgramValidateEvent>;
+    afterProgramValidate?(event: AfterProgramValidateEvent): any;
     /**
      * Called right before the program is disposed/destroyed
      */
-    beforeProgramDispose?: PluginHandler<BeforeProgramDisposeEvent>;
+    beforeProgramDispose?(event: BeforeProgramDisposeEvent): any;
     /**
      * Emitted before the program starts collecting completions
      */
-    beforeProvideCompletions?: PluginHandler<BeforeProvideCompletionsEvent>;
+    beforeProvideCompletions?(event: BeforeProvideCompletionsEvent): any;
     /**
      * Use this event to contribute completions
      */
-    provideCompletions?: PluginHandler<ProvideCompletionsEvent>;
+    provideCompletions?(event: ProvideCompletionsEvent): any;
     /**
      * Emitted after the program has finished collecting completions, but before they are sent to the client
      */
-    afterProvideCompletions?: PluginHandler<AfterProvideCompletionsEvent>;
+    afterProvideCompletions?(event: AfterProvideCompletionsEvent): any;
     /**
      * Called before the `provideHover` hook. Use this if you need to prepare any of the in-memory objects before the `provideHover` gets called
      */
-    beforeProvideHover?: PluginHandler<BeforeProvideHoverEvent>;
+    beforeProvideHover?(event: BeforeProvideHoverEvent): any;
     /**
      * Called when bsc looks for hover information. Use this if your plugin wants to contribute hover information.
      */
-    provideHover?: PluginHandler<ProvideHoverEvent>;
+    provideHover?(event: ProvideHoverEvent): any;
     /**
      * Called after the `provideHover` hook. Use this if you want to intercept or sanitize the hover data (even from other plugins) before it gets sent to the client.
      */
-    afterProvideHover?: PluginHandler<AfterProvideHoverEvent>;
+    afterProvideHover?(event: AfterProvideHoverEvent): any;
     /**
      * Called after a scope was created
      */
-    afterScopeCreate?: PluginHandler<AfterScopeCreateEvent>;
-    beforeScopeDispose?: PluginHandler<BeforeScopeDisposeEvent>;
-    onScopeDispose?: PluginHandler<OnScopeDisposeEvent>;
-    afterScopeDispose?: PluginHandler<AfterScopeDisposeEvent>;
-    beforeScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
+    afterScopeCreate?(event: AfterScopeCreateEvent): any;
+    beforeScopeDispose?(event: BeforeScopeDisposeEvent): any;
+    onScopeDispose?(event: OnScopeDisposeEvent): any;
+    afterScopeDispose?(event: AfterScopeDisposeEvent): any;
+    beforeScopeValidate?(event: BeforeScopeValidateEvent): any;
     /**
      * Called before the `provideDefinition` hook
      */
@@ -261,120 +238,133 @@ export interface CompilerPlugin {
      * @param event
      */
     afterProvideDefinition?(event: AfterProvideDefinitionEvent): any;
-    onScopeValidate?: PluginHandler<OnScopeValidateEvent>;
-    afterScopeValidate?: PluginHandler<BeforeScopeValidateEvent>;
-    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
-    onGetSemanticTokens?: PluginHandler<OnGetSemanticTokensEvent>;
+    /**
+     * Called before the `provideReferences` hook
+     */
+    beforeProvideReferences?(event: BeforeProvideReferencesEvent): any;
+    /**
+     * Provide all of the `Location`s where the symbol at the given position is located
+     * @param event
+     */
+    provideReferences?(event: ProvideReferencesEvent): any;
+    /**
+     * Called after `provideReferences`. Use this if you want to intercept or sanitize the references data provided by bsc or other plugins
+     * @param event
+     */
+    afterProvideReferences?(event: AfterProvideReferencesEvent): any;
+    onScopeValidate?(event: OnScopeValidateEvent): any;
+    afterScopeValidate?(event: BeforeScopeValidateEvent): any;
+    onGetCodeActions?(event: OnGetCodeActionsEvent): any;
+    onGetSemanticTokens?(event: OnGetSemanticTokensEvent): any;
     /**
      * Called before plugins are asked to provide files to the program. (excludes virtual files produced by `provideFile` events).
      * Call the `setFileData()` method to override the file contents.
      */
-    beforeProvideFile?: PluginHandler<BeforeProvideFileEvent>;
+    beforeProvideFile?(event: BeforeProvideFileEvent): any;
     /**
      * Give plugins the opportunity to handle processing a file. (excludes virtual files produced by `provideFile` events)
      */
-    provideFile?: PluginHandler<ProvideFileEvent>;
+    provideFile?(event: ProvideFileEvent): any;
     /**
      * Called after a file was added to the program. (excludes virtual files produced by `provideFile` events)
      */
-    afterProvideFile?: PluginHandler<AfterProvideFileEvent>;
+    afterProvideFile?(event: AfterProvideFileEvent): any;
     /**
      * Called before a file is added to the program.
      * Includes physical files as well as any virtual files produced by `provideFile` events
      */
-    beforeFileAdd?: PluginHandler<BeforeFileAddEvent>;
+    beforeFileAdd?(event: BeforeFileAddEvent): any;
     /**
      * Called after a file has been added to the program.
      * Includes physical files as well as any virtual files produced by `provideFile` events
      */
-    afterFileAdd?: PluginHandler<AfterFileAddEvent>;
+    afterFileAdd?(event: AfterFileAddEvent): any;
     /**
      * Called before a file is removed from the program. This includes physical and virtual files
      */
-    beforeFileRemove?: PluginHandler<BeforeFileRemoveEvent>;
+    beforeFileRemove?(event: BeforeFileRemoveEvent): any;
     /**
      * Called after a file has been removed from the program. This includes physical and virtual files
      */
-    afterFileRemove?: PluginHandler<AfterFileRemoveEvent>;
+    afterFileRemove?(event: AfterFileRemoveEvent): any;
     /**
      * Called before each file is validated
      */
-    beforeFileValidate?: PluginHandler<BeforeFileValidateEvent>;
+    beforeFileValidate?(event: BeforeFileValidateEvent): any;
     /**
      * Called during the file validation process. If your plugin contributes file validations, this is a good place to contribute them.
      */
-    onFileValidate?: PluginHandler<OnFileValidateEvent>;
+    onFileValidate?(event: OnFileValidateEvent): any;
     /**
      * Called after each file is validated
      */
-    afterFileValidate?: PluginHandler<AfterFileValidateEvent>;
+    afterFileValidate?(event: AfterFileValidateEvent): any;
     /**
      * Called right before the program builds (i.e. generates the code and puts it in the stagingDir
      */
-    beforeBuildProgram?: PluginHandler<BeforeBuildProgramEvent>;
+    beforeBuildProgram?(event: BeforeBuildProgramEvent): any;
     /**
      * Called right after the program builds (i.e. generates the code and puts it in the stagingDir
      */
-    afterBuildProgram?: PluginHandler<AfterBuildProgramEvent>;
+    afterBuildProgram?(event: AfterBuildProgramEvent): any;
     /**
      * Before preparing the file for building
      */
-    beforePrepareFile?: PluginHandler<BeforePrepareFileEvent>;
+    beforePrepareFile?(event: BeforePrepareFileEvent): any;
     /**
      * Prepare the file for building
      */
-    prepareFile?: PluginHandler<PrepareFileEvent>;
+    prepareFile?(event: PrepareFileEvent): any;
     /**
      * After preparing the file for building
      */
-    afterPrepareFile?: PluginHandler<AfterPrepareFileEvent>;
+    afterPrepareFile?(event: AfterPrepareFileEvent): any;
     /**
      * Before the program turns all file objects into their final buffers
      */
-    beforeSerializeProgram?: PluginHandler<BeforeSerializeProgramEvent>;
+    beforeSerializeProgram?(event: BeforeSerializeProgramEvent): any;
     /**
      * Emitted right at the start of the program turning all file objects into their final buffers
      */
-    onSerializeProgram?: PluginHandler<OnSerializeProgramEvent>;
+    onSerializeProgram?(event: OnSerializeProgramEvent): any;
     /**
      * After the program turns all file objects into their final buffers
      */
-    afterSerializeProgram?: PluginHandler<AfterSerializeProgramEvent>;
+    afterSerializeProgram?(event: AfterSerializeProgramEvent): any;
     /**
      * Before turning the file into its final contents
      */
-    beforeSerializeFile?: PluginHandler<BeforeSerializeFileEvent>;
+    beforeSerializeFile?(event: BeforeSerializeFileEvent): any;
     /**
      * Turn the file into its final contents (i.e. transpile a bs file, compress a jpeg, etc)
      */
-    serializeFile?: PluginHandler<SerializeFileEvent>;
+    serializeFile?(event: SerializeFileEvent): any;
     /**
      * After turning the file into its final contents
      */
-    afterSerializeFile?: PluginHandler<AfterSerializeFileEvent>;
+    afterSerializeFile?(event: AfterSerializeFileEvent): any;
     /**
      * Called before any files are written
      */
-    beforeWriteProgram?: PluginHandler<BeforeWriteProgramEvent>;
+    beforeWriteProgram?(event: BeforeWriteProgramEvent): any;
     /**
      * Called after all files are written
      */
-    afterWriteProgram?: PluginHandler<AfterWriteProgramEvent>;
+    afterWriteProgram?(event: AfterWriteProgramEvent): any;
     /**
      * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
      */
-    beforeWriteFile?: PluginHandler<BeforeWriteFileEvent>;
+    beforeWriteFile?(event: BeforeWriteFileEvent): any;
     /**
      * Called when a file should be persisted (usually writing to storage). These are raw files that contain the final output. One `File` may produce several of these.
      * When a plugin has handled a file, it should be pushed to the `handledFiles` set so future plugins don't write the file multiple times
      */
-    writeFile?: PluginHandler<WriteFileEvent>;
+    writeFile?(event: WriteFileEvent): any;
     /**
      * Before a file is written to disk. These are raw files that contain the final output. One `File` may produce several of these
      */
-    afterWriteFile?: PluginHandler<AfterWriteFileEvent>;
+    afterWriteFile?(event: AfterWriteFileEvent): any;
 }
-export declare type PluginHandler<T, R = void> = (event: T) => R;
 export interface OnGetCodeActionsEvent<TFile extends BscFile = BscFile> {
     program: Program;
     file: TFile;
@@ -486,6 +476,23 @@ export interface ProvideDefinitionEvent<TFile = BscFile> {
 }
 export declare type BeforeProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
 export declare type AfterProvideDefinitionEvent<TFile = BscFile> = ProvideDefinitionEvent<TFile>;
+export interface ProvideReferencesEvent<TFile = BscFile> {
+    program: Program;
+    /**
+     * The file that the getDefinition request was invoked in
+     */
+    file: TFile;
+    /**
+     * The position in the text document where the getDefinition request was invoked
+     */
+    position: Position;
+    /**
+     * The list of locations for where the item at the file and position was defined
+     */
+    references: Location[];
+}
+export declare type BeforeProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
+export declare type AfterProvideReferencesEvent<TFile = BscFile> = ProvideReferencesEvent<TFile>;
 export interface OnGetSemanticTokensEvent<T extends BscFile = BscFile> {
     /**
      * The program this file is from
@@ -696,9 +703,15 @@ export interface SemanticToken {
     tokenModifiers?: SemanticTokenModifiers[];
 }
 export interface TypedefProvider {
-    getTypedef(state: TranspileState): Array<SourceNode | string>;
+    getTypedef(state: TranspileState): TranspileResult;
 }
-export declare type TranspileResult = Array<(string | SourceNode)>;
+export declare type TranspileResult = Array<(string | SourceNode | TranspileResult)>;
+/**
+ * This is the type that the SourceNode class is declared as taking in its constructor.
+ * The actual type that SourceNode accepts is the more permissive TranspileResult, but
+ * we need to use this declared type for some type casts.
+ */
+export declare type FlattenedTranspileResult = Array<string | SourceNode>;
 export declare type FileResolver = (srcPath: string) => string | Buffer | undefined | Thenable<string | Buffer | undefined> | void;
 export interface ExpressionInfo {
     expressions: Expression[];
@@ -724,15 +737,24 @@ export interface GetTypeOptions {
     ignoreCall?: boolean;
     onlyCacheResolvedTypes?: boolean;
     ignoreCacheForRetrieval?: boolean;
+    isExistenceTest?: boolean;
 }
 export declare class TypeChainEntry {
-    name: string;
-    type: BscType;
-    range: Range;
-    separatorToken: Token;
-    data: ExtraSymbolData;
-    constructor(name: string, type: BscType, data: ExtraSymbolData, range: Range, separatorToken?: Token);
+    constructor(options: {
+        name: string;
+        type: BscType;
+        data: ExtraSymbolData;
+        range: Range;
+        separatorToken?: Token;
+        kind?: AstNodeKind;
+    });
     get isResolved(): boolean;
+    readonly name: string;
+    readonly type: BscType;
+    readonly data: ExtraSymbolData;
+    readonly range: Range;
+    readonly separatorToken: Token;
+    kind: AstNodeKind;
 }
 export interface TypeChainProcessResult {
     itemName: string;
@@ -773,3 +795,13 @@ export interface NamespaceContainer {
     namespaces?: Map<string, NamespaceContainer>;
     symbolTable: SymbolTable;
 }
+/**
+ * Use Writable<T> to remove readonly flag from properties in T
+ * Be careful!
+ */
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};

package/dist/interfaces.js

@@ -11,15 +11,15 @@ var DiagnosticOrigin;
     DiagnosticOrigin["ASTSegment"] = "AstSegment";
 })(DiagnosticOrigin = exports.DiagnosticOrigin || (exports.DiagnosticOrigin = {}));
 class TypeChainEntry {
-    constructor(name, type, data, range, separatorToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dot)) {
-        this.name = name;
-        this.type = type;
-        this.range = range;
-        this.separatorToken = separatorToken;
-        if (data) {
-            // make a copy of this data
-            this.data = Object.assign({}, data);
-        }
+    constructor(options) {
+        var _a;
+        this.name = options.name;
+        // make a copy of this data
+        this.data = Object.assign({}, options.data);
+        this.type = options.type;
+        this.range = options.range;
+        this.separatorToken = (_a = options.separatorToken) !== null && _a !== void 0 ? _a : (0, creators_1.createToken)(TokenKind_1.TokenKind.Dot);
+        this.kind = options.kind;
     }
     get isResolved() {
         var _a;

package/dist/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AAqBA,kDAAkD;AAClD,iDAA8C;AAU9C,IAAY,gBAKX;AALD,WAAY,gBAAgB;IACxB,uCAAmB,CAAA;IACnB,mCAAe,CAAA;IACf,iCAAa,CAAA;IACb,6CAAyB,CAAA;AAC7B,CAAC,EALW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAK3B;AAixBD,MAAa,cAAc;IAEvB,YAAmB,IAAY,EAAS,IAAa,EAAE,IAAqB,EAAS,KAAY,EAAS,iBAAwB,IAAA,sBAAW,EAAC,qBAAS,CAAC,GAAG,CAAC;QAAzI,SAAI,GAAJ,IAAI,CAAQ;QAAS,SAAI,GAAJ,IAAI,CAAS;QAAgC,UAAK,GAAL,KAAK,CAAO;QAAS,mBAAc,GAAd,cAAc,CAAoC;QACxJ,IAAI,IAAI,EAAE;YACN,2BAA2B;YAC3B,IAAI,CAAC,IAAI,qBAAQ,IAAI,CAAE,CAAC;SAC3B;IACL,CAAC;IACD,IAAI,UAAU;;QACV,OAAO,MAAA,IAAI,CAAC,IAAI,0CAAE,YAAY,EAAE,CAAC;IACrC,CAAC;CACJ;AAXD,wCAWC"}
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AAoBA,kDAAkD;AAClD,iDAA8C;AAU9C,IAAY,gBAKX;AALD,WAAY,gBAAgB;IACxB,uCAAmB,CAAA;IACnB,mCAAe,CAAA;IACf,iCAAa,CAAA;IACb,6CAAyB,CAAA;AAC7B,CAAC,EALW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAK3B;AAkyBD,MAAa,cAAc;IACvB,YAAY,OAOX;;QACG,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,2BAA2B;QAC3B,IAAI,CAAC,IAAI,qBAAQ,OAAO,CAAC,IAAI,CAAE,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,MAAA,OAAO,CAAC,cAAc,mCAAI,IAAA,sBAAW,EAAC,qBAAS,CAAC,GAAG,CAAC,CAAC;QAC3E,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,IAAI,UAAU;;QACV,OAAO,MAAA,IAAI,CAAC,IAAI,0CAAE,YAAY,EAAE,CAAC;IACrC,CAAC;CAQJ;AA3BD,wCA2BC"}

package/dist/lexer/Lexer.d.ts

@@ -205,14 +205,20 @@ export declare class Lexer {
      */
     private sync;
     /**
-     * Creates a `TokenLocation` at the lexer's current position for the provided `text`.
-     * @returns the range of `text` as a `TokenLocation`
+     * Creates a `Range` at the lexer's current position
+     * @returns the range of `text`
      */
     private rangeOf;
 }
 export interface ScanOptions {
     /**
      * If true, the whitespace tokens are included. If false, they are discarded
+     * @default false
      */
-    includeWhitespace: boolean;
+    includeWhitespace?: boolean;
+    /**
+     * Should locations be tracked. If false, the `range` property will be omitted
+     * @default true
+     */
+    trackLocations?: boolean;
 }

package/dist/lexer/Lexer.js

@@ -56,7 +56,9 @@ class Lexer {
             kind: TokenKind_1.TokenKind.Eof,
             isReserved: false,
             text: '',
-            range: util_1.default.createRange(this.lineBegin, this.columnBegin, this.lineEnd, this.columnEnd + 1),
+            range: this.options.trackLocations
+                ? util_1.default.createRange(this.lineBegin, this.columnBegin, this.lineEnd, this.columnEnd + 1)
+                : undefined,
             leadingWhitespace: this.leadingWhitespace,
             leadingTrivia: this.leadingTrivia
         });
@@ -73,7 +75,11 @@ class Lexer {
      * Fill in missing/invalid options with defaults
      */
     sanitizeOptions(options) {
-        return Object.assign({ includeWhitespace: false }, options);
+        var _a, _b;
+        options !== null && options !== void 0 ? options : (options = {});
+        (_a = options.includeWhitespace) !== null && _a !== void 0 ? _a : (options.includeWhitespace = false);
+        (_b = options.trackLocations) !== null && _b !== void 0 ? _b : (options.trackLocations = true);
+        return options;
     }
     /**
      * Determines whether or not the lexer as reached the end of its input.
@@ -595,12 +601,16 @@ class Lexer {
      */
     preProcessedConditional() {
         this.advance(); // advance past the leading #
+        //consume whitespace
+        while (this.check(' ', '\t')) {
+            this.advance();
+        }
         while ((0, Characters_1.isAlphaNumeric)(this.peek())) {
             this.advance();
         }
         let text = this.source.slice(this.start, this.current).toLowerCase();
-        // some identifiers can be split into two words, so check the "next" word and see what we get
-        if ((text === '#end' || text === '#else') && this.check(' ', '\t')) {
+        // some identifiers can be split into two words (`#end if`, `#else if`), so check the "next" word and see what we get
+        if ((text.endsWith('end') || text.endsWith('else')) && this.check(' ', '\t')) {
             let endOfFirstWord = this.current;
             //skip past whitespace
             while (this.check(' ', '\t')) {
@@ -610,18 +620,18 @@ class Lexer {
                 this.advance();
             } // read the next word
             let twoWords = this.source.slice(this.start, this.current).toLowerCase();
-            switch (twoWords.replace(/[\s\t]+/g, ' ')) {
-                case '#else if':
+            switch (twoWords.replace(/\s+/g, '')) {
+                case '#elseif':
                     this.addToken(TokenKind_1.TokenKind.HashElseIf);
                     return;
-                case '#end if':
+                case '#endif':
                     this.addToken(TokenKind_1.TokenKind.HashEndIf);
                     return;
             }
             // reset if the last word and the current word didn't form a multi-word TokenKind
             this.current = endOfFirstWord;
         }
-        switch (text) {
+        switch (text.replace(/\s+/g, '')) {
             case '#if':
                 this.addToken(TokenKind_1.TokenKind.HashIf);
                 return;
@@ -644,11 +654,15 @@ class Lexer {
                 if (this.check(' ', '\t')) {
                     this.whitespace();
                 }
-                while (!this.isAtEnd() && !this.check('\n')) {
+                let hasErrorMessage = false;
+                while (!this.isAtEnd() && !this.check('\r') && !this.check('\n')) {
+                    hasErrorMessage = true;
                     this.advance();
                 }
-                // grab all text since we found #error as one token
-                this.addToken(TokenKind_1.TokenKind.HashErrorMessage);
+                if (hasErrorMessage) {
+                    // grab all text since we found #error as one token
+                    this.addToken(TokenKind_1.TokenKind.HashErrorMessage);
+                }
                 this.start = this.current;
                 return;
             default:
@@ -737,7 +751,9 @@ class Lexer {
             this.leadingTrivia = [];
         }
         this.leadingWhitespace = '';
-        this.tokens.push(token);
+        if (kind !== TokenKind_1.TokenKind.Comment) {
+            this.tokens.push(token);
+        }
         this.sync();
         return token;
     }
@@ -750,11 +766,16 @@ class Lexer {
         this.columnBegin = this.columnEnd;
     }
     /**
-     * Creates a `TokenLocation` at the lexer's current position for the provided `text`.
-     * @returns the range of `text` as a `TokenLocation`
+     * Creates a `Range` at the lexer's current position
+     * @returns the range of `text`
      */
     rangeOf() {
-        return util_1.default.createRange(this.lineBegin, this.columnBegin, this.lineEnd, this.columnEnd);
+        if (this.options.trackLocations) {
+            return util_1.default.createRange(this.lineBegin, this.columnBegin, this.lineEnd, this.columnEnd);
+        }
+        else {
+            return undefined;
+        }
     }
 }
 exports.Lexer = Lexer;