@ibm/ibmi-mcp-server 0.1.2 → 0.3.0

package/dist/ibmi-mcp-server/utils/language/statement.js

@@ -0,0 +1,796 @@
+/* eslint-disable */
+// @ts-nocheck
+// Vendored from vscode-db2i - TypeScript strict mode and ESLint disabled
+import SQLTokeniser, { NameTypes } from "./tokens.js";
+import { ClauseType, ClauseTypeWord, StatementType, StatementTypeWord, } from "./types.js";
+export const tokenIs = (token, type, value) => {
+    return (token &&
+        token.type === type &&
+        (value ? token.value?.toUpperCase() === value : true));
+};
+export default class Statement {
+    tokens;
+    range;
+    type = StatementType.Unknown;
+    label;
+    _blockTokens;
+    get blockTokens() {
+        if (!this._blockTokens) {
+            this._blockTokens = SQLTokeniser.createBlocks(this.tokens.slice(0));
+        }
+        return this._blockTokens;
+    }
+    constructor(tokens, range) {
+        this.tokens = tokens;
+        this.range = range;
+        this.tokens = this.tokens.filter((newToken) => newToken.type !== `newline`);
+        let first = this.tokens[0];
+        if (tokenIs(first, `word`, `EXEC`) &&
+            tokenIs(this.tokens[1], `word`, `SQL`)) {
+            first = this.tokens[2];
+        }
+        else if (tokenIs(this.tokens[1], `colon`)) {
+            this.label = first.value;
+            first = this.tokens[2];
+        }
+        const wordValue = first?.value?.toUpperCase();
+        this.type = StatementTypeWord[wordValue] || StatementType.Unknown;
+        switch (this.type) {
+            case StatementType.Create:
+                // No scalar transformation here..
+                break;
+            default:
+                this.tokens = SQLTokeniser.findScalars(this.tokens);
+                break;
+        }
+    }
+    getLabel() {
+        return this.label;
+    }
+    isCompoundStart() {
+        if (this.tokens.length === 1 &&
+            tokenIs(this.tokens[0], `keyword`, `BEGIN`)) {
+            return true;
+        }
+        // These statements can end with BEGIN, which signifies a block starter
+        if ([StatementType.Create, StatementType.Declare].includes(this.type)) {
+            const last = this.tokens[this.tokens.length - 1];
+            if (tokenIs(last, `keyword`, `BEGIN`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static typeIsConditional(type) {
+        return [
+            StatementType.If,
+            StatementType.While,
+            StatementType.Loop,
+            StatementType.For,
+        ].includes(type);
+    }
+    isConditionStart() {
+        return Statement.typeIsConditional(this.type);
+    }
+    isConditionEnd() {
+        return this.type === StatementType.End && this.tokens.length > 1;
+    }
+    isCompoundEnd() {
+        return this.type === StatementType.End && this.tokens.length === 1;
+    }
+    getTokenByOffset(offset) {
+        const blockSearch = (tokens) => {
+            const token = tokens.find((token) => offset >= token.range.start && offset <= token.range.end);
+            if (token?.type === `block` && token.block) {
+                return blockSearch(token.block);
+            }
+            return token;
+        };
+        return blockSearch(this.tokens);
+    }
+    getClauseForOffset(offset) {
+        let currentClause = ClauseType.Unknown;
+        for (let i = 0; i < this.tokens.length; i++) {
+            if (offset < this.tokens[i].range.start) {
+                break;
+            }
+            if (tokenIs(this.tokens[i], `clause`)) {
+                currentClause = ClauseTypeWord[this.tokens[i].value.toUpperCase()];
+            }
+        }
+        return currentClause;
+    }
+    getBlockRangeAt(offset) {
+        const blockContainsOffset = (cOffset, block) => {
+            const tokenInOffset = block.find((token) => cOffset >= token.range.start && cOffset <= token.range.end);
+            if (tokenInOffset) {
+                if (tokenInOffset.type === `block`) {
+                    if (tokenInOffset.block.length > 0) {
+                        let blockRange = blockContainsOffset(cOffset, tokenInOffset.block);
+                        if (!blockRange) {
+                            blockRange = {
+                                start: this.tokens.findIndex((token) => token.range.start === tokenInOffset.range.start) + 1,
+                                end: this.tokens.findIndex((token) => token.range.end === tokenInOffset.range.end),
+                            };
+                        }
+                        return blockRange;
+                    }
+                    else {
+                        const rawEnd = this.tokens.findIndex((token) => token.range.end === tokenInOffset.range.end);
+                        return {
+                            start: rawEnd,
+                            end: rawEnd,
+                        };
+                    }
+                }
+                else {
+                    const rawStart = this.tokens.findIndex((token) => token.range.start === block[0].range.start);
+                    const rawEnd = this.tokens.findIndex((token) => token.range.end === block[block.length - 1].range.end);
+                    return {
+                        start: rawStart,
+                        end: rawEnd + 1,
+                    };
+                }
+            }
+            return undefined;
+        };
+        return blockContainsOffset(offset, this.blockTokens);
+    }
+    getCallableDetail(offset, withBlocks = false) {
+        const range = this.getBlockRangeAt(offset);
+        if (range) {
+            const hasDot = (tokenIs(this.tokens[range.start - 4], `word`) ||
+                tokenIs(this.tokens[range.start - 4], `sqlName`)) &&
+                tokenIs(this.tokens[range.start - 3], `dot`);
+            const parentRef = hasDot
+                ? this.getRefAtToken(range.start - 4)
+                : this.getRefAtToken(range.start - 2);
+            if (parentRef) {
+                return {
+                    tokens: withBlocks
+                        ? SQLTokeniser.createBlocks(this.tokens.slice(range.start, range.end))
+                        : this.tokens.slice(range.start, range.end),
+                    parentRef,
+                };
+            }
+        }
+    }
+    getBlockAt(offset) {
+        const expandBlock = (tokens) => {
+            const block = tokens.filter((token) => token.type === `block`);
+            if (block.length > 0) {
+                return block.reduce((acc, token) => acc.concat(expandBlock(token.block)), tokens);
+            }
+            return tokens;
+        };
+        let blockRange = this.getBlockRangeAt(offset);
+        if (blockRange) {
+            return expandBlock(this.tokens.slice(blockRange.start, blockRange.end));
+        }
+        return [];
+    }
+    getReferenceByOffset(offset) {
+        let i = this.tokens.findIndex((token) => offset >= token.range.start && offset <= token.range.end);
+        let currentType;
+        let prevMustBe;
+        // Reset to end
+        if (i >= 0) {
+            currentType = this.tokens[i].type;
+            if (currentType === `dot` || currentType === `forwardslash`)
+                prevMustBe = `name`;
+            else if (NameTypes.includes(currentType))
+                prevMustBe = `dot`;
+        }
+        else {
+            i = this.tokens.length - 1;
+            prevMustBe = `name`;
+        }
+        while (i >= 0 && this.tokens[i - 1]) {
+            i--;
+            currentType = this.tokens[i].type;
+            switch (prevMustBe) {
+                case `dot`:
+                    if (currentType === `dot`) {
+                        prevMustBe = `name`;
+                    }
+                    else {
+                        return this.getRefAtToken(i + 1);
+                    }
+                    break;
+                case `name`:
+                    if (NameTypes.includes(currentType)) {
+                        prevMustBe = `dot`;
+                    }
+                    else {
+                        return this.getRefAtToken(i + 1);
+                    }
+                    break;
+            }
+        }
+    }
+    getCTEReferences() {
+        if (this.type !== StatementType.With)
+            return [];
+        const withBlocks = this.blockTokens;
+        let cteList = [];
+        for (let i = 0; i < withBlocks.length; i++) {
+            if (tokenIs(withBlocks[i], `word`) ||
+                tokenIs(withBlocks[i], `function`)) {
+                let cteName = withBlocks[i].value;
+                let parameters = [];
+                let statementBlockI = i + 1;
+                if (tokenIs(withBlocks[i + 1], `block`) &&
+                    tokenIs(withBlocks[i + 2], `keyword`, `AS`)) {
+                    parameters = withBlocks[i + 1]
+                        .block.filter((blockToken) => blockToken.type === `word`)
+                        .map((blockToken) => blockToken.value);
+                    statementBlockI = i + 3;
+                }
+                else if (tokenIs(withBlocks[i + 1], `keyword`, `AS`)) {
+                    statementBlockI = i + 2;
+                }
+                const statementBlock = withBlocks[statementBlockI];
+                if (tokenIs(statementBlock, `block`)) {
+                    cteList.push({
+                        name: cteName,
+                        columns: parameters,
+                        statement: new Statement(Statement.trimTokens(statementBlock.block), statementBlock.range),
+                    });
+                }
+                i = statementBlockI;
+            }
+            if (tokenIs(withBlocks[i], `statementType`, `SELECT`)) {
+                break;
+            }
+        }
+        return cteList;
+    }
+    getRoutineParameters() {
+        const list = [];
+        if (this.type !== StatementType.Create) {
+            return [];
+        }
+        function splitTokens(inTokens, type) {
+            const chunks = [];
+            let currentChunk = [];
+            for (const token of inTokens) {
+                if (tokenIs(token, type)) {
+                    if (currentChunk.length > 0) {
+                        chunks.push(currentChunk);
+                        currentChunk = [];
+                    }
+                }
+                else {
+                    currentChunk.push(token);
+                }
+            }
+            if (currentChunk.length > 0) {
+                chunks.push(currentChunk);
+            }
+            return chunks;
+        }
+        const withBlocks = SQLTokeniser.createBlocks(this.tokens.slice(0));
+        const firstBlock = withBlocks.find((token) => token.type === `block`);
+        if (firstBlock && firstBlock.block) {
+            const parameters = splitTokens(firstBlock.block, `comma`);
+            for (const parameter of parameters) {
+                // If the first token is the parm type, then the name follows
+                if (tokenIs(parameter[0], `keyword`))
+                    continue;
+                let nameIndex = tokenIs(parameter[0], `parmType`) ? 1 : 0;
+                const name = parameter[nameIndex].value;
+                // Include parmType if it is provided
+                const definitionTokens = (nameIndex === 1 ? [parameter[0]] : []).concat(parameter.slice(nameIndex + 1));
+                list.push({
+                    tokens: parameter,
+                    createType: Statement.formatSimpleTokens(definitionTokens),
+                    alias: name,
+                    object: {
+                        name,
+                    },
+                });
+            }
+        }
+        return list;
+    }
+    static BANNED_NAMES = [`VALUES`];
+    getObjectReferences() {
+        let list = [];
+        const doAdd = (ref) => {
+            if (ref) {
+                if (ref.object.name &&
+                    !Statement.BANNED_NAMES.includes(ref.object.name.toUpperCase())) {
+                    list.push(ref);
+                }
+            }
+        };
+        const basicQueryFinder = (startIndex) => {
+            let currentClause;
+            for (let i = startIndex; i < this.tokens.length; i++) {
+                if (tokenIs(this.tokens[i], `clause`, `FROM`)) {
+                    currentClause = `from`;
+                }
+                else if (tokenIs(this.tokens[i], `statementType`, `SELECT`)) {
+                    currentClause = `select`;
+                }
+                else if ((currentClause === `from` && tokenIs(this.tokens[i], `clause`)) ||
+                    tokenIs(this.tokens[i], `join`) ||
+                    tokenIs(this.tokens[i], `closebracket`)) {
+                    currentClause = undefined;
+                }
+                if (tokenIs(this.tokens[i], `clause`, `FROM`) ||
+                    (this.type !== StatementType.Select &&
+                        tokenIs(this.tokens[i], `clause`, `INTO`)) ||
+                    tokenIs(this.tokens[i], `join`) ||
+                    (currentClause === `from` && tokenIs(this.tokens[i], `comma`))) {
+                    const sqlObj = this.getRefAtToken(i + 1);
+                    if (sqlObj) {
+                        doAdd(sqlObj);
+                        i += sqlObj.tokens.length;
+                        if (sqlObj.isUDTF || sqlObj.fromLateral) {
+                            i += 3; //For the brackets
+                        }
+                    }
+                }
+                else if (currentClause === `select` &&
+                    tokenIs(this.tokens[i], `function`)) {
+                    const sqlObj = this.getRefAtToken(i);
+                    if (sqlObj) {
+                        doAdd(sqlObj);
+                        i += sqlObj.tokens.length;
+                        if (sqlObj.isUDTF || sqlObj.fromLateral) {
+                            i += 3; //For the brackets
+                        }
+                    }
+                }
+                else if (currentClause === `from` &&
+                    tokenIs(this.tokens[i], `function`)) {
+                    const sqlObj = this.getRefAtToken(i, { includeParameters: true });
+                    if (sqlObj) {
+                        i += sqlObj.tokens.length;
+                        if (sqlObj.isUDTF || sqlObj.fromLateral) {
+                            i += 3; //For the brackets
+                        }
+                    }
+                }
+            }
+        };
+        let inFromClause = false;
+        switch (this.type) {
+            case StatementType.Call:
+                // CALL X()
+                doAdd(this.getRefAtToken(1, { includeParameters: true }));
+                break;
+            case StatementType.Alter:
+                if (this.tokens.length >= 3) {
+                    let object = this.getRefAtToken(2, { withSystemName: true });
+                    if (object) {
+                        object.createType = this.tokens[1].value;
+                        doAdd(object);
+                        for (let i = object.tokens.length + 2; i < this.tokens.length; i++) {
+                            if (tokenIs(this.tokens[i], `keyword`, `REFERENCES`)) {
+                                doAdd(this.getRefAtToken(i + 1, { withSystemName: true }));
+                            }
+                        }
+                    }
+                }
+                break;
+            case StatementType.With:
+                basicQueryFinder(0);
+                break;
+            case StatementType.Insert:
+            case StatementType.Select:
+            case StatementType.Delete:
+                basicQueryFinder(0);
+                break;
+            case StatementType.Create:
+                let object;
+                let postName;
+                if (tokenIs(this.tokens[1], `keyword`, `OR`) &&
+                    tokenIs(this.tokens[2], `keyword`, `REPLACE`)) {
+                    object = this.getRefAtToken(4, { withSystemName: true });
+                    if (object) {
+                        postName = object.tokens.length + 4;
+                        object.createType = this.tokens[3].value;
+                    }
+                }
+                else if (tokenIs(this.tokens[1], `keyword`, `UNIQUE`)) {
+                    object = this.getRefAtToken(3, { withSystemName: true });
+                    if (object) {
+                        postName = object.tokens.length + 3;
+                        object.createType = this.tokens[2].value;
+                    }
+                }
+                else {
+                    object = this.getRefAtToken(2, { withSystemName: true });
+                    if (object) {
+                        postName = object.tokens.length + 2;
+                        object.createType = this.tokens[1].value;
+                    }
+                }
+                doAdd(object);
+                if (object && postName) {
+                    switch (object.createType?.toUpperCase()) {
+                        case `FUNCTION`:
+                        case `PROCEDURE`:
+                            // For functions, perhaps we can use the SPECIFIC keyword for the system name
+                            for (let i = postName; i < this.tokens.length; i++) {
+                                if (tokenIs(this.tokens[i], `keyword`, `SPECIFIC`) &&
+                                    this.tokens[i + 1]) {
+                                    object.object.system = this.tokens[i + 1].value;
+                                    i++;
+                                }
+                                // Support for external name
+                                if (tokenIs(this.tokens[i], `keyword`, `EXTERNAL`) &&
+                                    tokenIs(this.tokens[i + 1], `word`, `NAME`) &&
+                                    this.tokens[i + 2]) {
+                                    const externalRef = this.getRefAtToken(i + 2);
+                                    if (externalRef) {
+                                        externalRef.createType = `external`;
+                                        externalRef.alias = undefined;
+                                        externalRef.object.system = externalRef.object.name;
+                                        i += externalRef.tokens.length + 2;
+                                        doAdd(externalRef);
+                                    }
+                                }
+                            }
+                            break;
+                        case `INDEX`:
+                            // If the type is `INDEX`, the next reference is the `ON` keyword
+                            for (let i = postName; i < this.tokens.length; i++) {
+                                if (tokenIs(this.tokens[i], `keyword`, `ON`)) {
+                                    doAdd(this.getRefAtToken(i + 1));
+                                    break;
+                                }
+                            }
+                            break;
+                        case `VARIABLE`:
+                            if (postName) {
+                                object.createType = Statement.formatSimpleTokens(this.tokens.slice(postName));
+                            }
+                            break;
+                        case `VIEW`:
+                        case `TABLE`:
+                            const asKeyword = this.tokens.findIndex((token) => tokenIs(token, `keyword`, `AS`));
+                            if (asKeyword > 0) {
+                                basicQueryFinder(asKeyword);
+                            }
+                            break;
+                    }
+                }
+                break;
+            case StatementType.Declare:
+                if (tokenIs(this.tokens[2], `keyword`, `HANDLER`)) {
+                    // DECLARE XX HANDLER FOR....
+                    let def = {
+                        object: { name: this.tokens[1].value },
+                        tokens: this.tokens.slice(1, 3),
+                    };
+                    def.createType = `Handler`;
+                    doAdd(def);
+                }
+                else if (tokenIs(this.tokens[2], `word`, `PROCEDURE`)) {
+                    // DECLARE XX PROCEDURE..
+                }
+                else if ((tokenIs(this.tokens[1], `word`, `GLOBAL`) &&
+                    tokenIs(this.tokens[2], `word`, `TEMPORARY`),
+                    tokenIs(this.tokens[3], `word`, `TABLE`))) {
+                    // Handle DECLARE GLOBAL TEMP TABLE x.x ()...
+                    let def = this.getRefAtToken(4);
+                    def.createType = `Temporary Table`;
+                    doAdd(def);
+                }
+                else if (tokenIs(this.tokens[1], `word`)) {
+                    // DECLARE XX TYPE DEFAULT ..
+                    let def = {
+                        object: { name: this.tokens[1].value },
+                        tokens: this.tokens.slice(1),
+                    };
+                    if (tokenIs(this.tokens[2], `keyword`, `CURSOR`)) {
+                        def.createType = `Cursor`;
+                    }
+                    else {
+                        let defaultIndex = this.tokens.findIndex((t) => tokenIs(t, `keyword`, `DEFAULT`));
+                        const valueTokens = this.tokens.slice(2, defaultIndex >= 0 ? defaultIndex : undefined);
+                        def.createType = Statement.formatSimpleTokens(valueTokens);
+                    }
+                    doAdd(def);
+                }
+                break;
+        }
+        return list;
+    }
+    getRefAtToken(i, options = {}) {
+        let sqlObj;
+        let nextIndex = i;
+        let nextToken = this.tokens[i];
+        let endIndex = i;
+        const isSubSelect = tokenIs(nextToken, `function`, `TABLE`) ||
+            tokenIs(nextToken, `function`, `LATERAL`) ||
+            (options.includeParameters &&
+                tokenIs(nextToken, `function`) &&
+                this.type !== StatementType.Call);
+        if (isSubSelect) {
+            sqlObj = this.getRefAtToken(i + 2);
+            if (sqlObj) {
+                sqlObj.isUDTF = true;
+                const blockTokens = this.getBlockAt(sqlObj.tokens[0].range.end);
+                sqlObj.tokens = blockTokens;
+                nextIndex = i + 2 + blockTokens.length;
+                nextToken = this.tokens[nextIndex];
+            }
+            else {
+                nextIndex = -1;
+                nextToken = undefined;
+            }
+        }
+        else {
+            if (nextToken && NameTypes.includes(nextToken.type)) {
+                nextIndex = i;
+                endIndex = i;
+                sqlObj = {
+                    tokens: [],
+                    object: {
+                        name: nextToken.value,
+                    },
+                };
+                if (tokenIs(this.tokens[i + 1], `dot`) ||
+                    tokenIs(this.tokens[i + 1], `forwardslash`)) {
+                    nextIndex = i + 2;
+                    nextToken = this.tokens[nextIndex];
+                    endIndex = nextToken ? nextIndex : i + 1;
+                    sqlObj = {
+                        tokens: [],
+                        object: {
+                            schema: this.tokens[i].value,
+                            name: nextToken && NameTypes.includes(nextToken.type)
+                                ? nextToken.value
+                                : undefined,
+                        },
+                    };
+                }
+            }
+        }
+        if (sqlObj) {
+            if (options.withSystemName !== true) {
+                // If the next token is not a clause.. we might have the alias
+                if (nextToken && this.tokens[nextIndex + 1]) {
+                    if (tokenIs(this.tokens[nextIndex + 1], `keyword`, `AS`) &&
+                        tokenIs(this.tokens[nextIndex + 2], `word`)) {
+                        endIndex = nextIndex + 2;
+                        sqlObj.alias = this.tokens[nextIndex + 2].value;
+                    }
+                    else if (tokenIs(this.tokens[nextIndex + 1], `word`)) {
+                        endIndex = nextIndex + 1;
+                        sqlObj.alias = this.tokens[nextIndex + 1].value;
+                    }
+                }
+            }
+            if (!isSubSelect && !sqlObj.isUDTF) {
+                sqlObj.tokens = this.tokens.slice(i, endIndex + 1);
+                if (options.includeParameters &&
+                    tokenIs(this.tokens[endIndex + 1], `openbracket`)) {
+                    const blockTokens = this.getBlockAt(this.tokens[endIndex + 1].range.end + 1);
+                    if (blockTokens.length > 0) {
+                        sqlObj.tokens = sqlObj.tokens.concat([
+                            {
+                                type: `openbracket`,
+                                value: `(`,
+                                range: {
+                                    start: this.tokens[endIndex + 1].range.start,
+                                    end: this.tokens[endIndex + 1].range.end,
+                                },
+                            },
+                            ...blockTokens,
+                            {
+                                type: `closebracket`,
+                                value: `)`,
+                                range: {
+                                    start: blockTokens[blockTokens.length - 1].range.end,
+                                    end: blockTokens[blockTokens.length - 1].range.end,
+                                },
+                            },
+                        ]);
+                    }
+                }
+            }
+            if (options.withSystemName) {
+                if (tokenIs(this.tokens[endIndex + 1], `statementType`, `FOR`) &&
+                    tokenIs(this.tokens[endIndex + 2], `word`, `SYSTEM`) &&
+                    tokenIs(this.tokens[endIndex + 3], `word`, `NAME`)) {
+                    if (this.tokens[endIndex + 4] &&
+                        NameTypes.includes(this.tokens[endIndex + 4].type)) {
+                        sqlObj.object.system = this.tokens[endIndex + 4].value;
+                    }
+                }
+            }
+        }
+        return sqlObj;
+    }
+    /**
+     * Gets areas of statement that are likely from embedded statements
+     * EXEC SQL
+     * INTO area
+     * Host variables
+     * DECLARE .. CURSOR FOR
+     */
+    getEmbeddedStatementAreas() {
+        // Only these statements support the INTO clause in embedded SQL really
+        const validIntoStatements = [
+            StatementType.Unknown,
+            StatementType.With,
+            StatementType.Select,
+        ];
+        let ranges = [];
+        let intoClause;
+        let declareStmt;
+        let lastTokenWasMarker = false;
+        for (let i = 0; i < this.tokens.length; i++) {
+            const prevToken = this.tokens[i - 1];
+            const currentToken = this.tokens[i];
+            if (!tokenIs(currentToken, `colon`)) {
+                lastTokenWasMarker = false;
+            }
+            switch (currentToken.type) {
+                case `statementType`:
+                    const currentValue = currentToken.value.toLowerCase();
+                    if (declareStmt) {
+                        if (currentValue === `for`) {
+                            ranges.push({
+                                type: `remove`,
+                                range: {
+                                    start: declareStmt.range.start,
+                                    end: currentToken.range.end,
+                                },
+                            });
+                            declareStmt = undefined;
+                        }
+                        continue;
+                    }
+                    // If we're in a DECLARE, it's likely a cursor definition
+                    if (currentValue === `declare`) {
+                        declareStmt = currentToken;
+                    }
+                    break;
+                case `clause`:
+                    if (!validIntoStatements.includes(this.type))
+                        continue;
+                    if (declareStmt)
+                        continue;
+                    // We need to remove the INTO clause completely.
+                    if (currentToken.value.toLowerCase() === `into`) {
+                        intoClause = currentToken;
+                    }
+                    else if (intoClause) {
+                        const endToken = this.tokens[i - 1];
+                        ranges.push({
+                            type: `remove`,
+                            range: {
+                                start: intoClause.range.start,
+                                end: endToken.range.end,
+                            },
+                        });
+                        intoClause = undefined;
+                    }
+                    break;
+                case `questionmark`:
+                    if (intoClause)
+                        continue;
+                    if (declareStmt)
+                        continue;
+                    ranges.push({
+                        type: `marker`,
+                        range: currentToken.range,
+                    });
+                    break;
+                case `colon`:
+                    if (intoClause)
+                        continue;
+                    if (declareStmt)
+                        continue;
+                    if (prevToken && prevToken.type === `string`)
+                        continue;
+                    let nextMustBe = `word`;
+                    let followingTokenI = i + 1;
+                    let endToken;
+                    // Handles when we have a host variable
+                    // This logic supports qualified host variables
+                    // i.e. :myvar or :mystruct.subf
+                    let followingToken = this.tokens[followingTokenI];
+                    while (followingToken && followingToken.type === nextMustBe) {
+                        switch (followingToken.type) {
+                            case `word`:
+                                nextMustBe = `dot`;
+                                break;
+                            case `dot`:
+                                nextMustBe = `word`;
+                                break;
+                        }
+                        endToken = followingToken;
+                        followingTokenI++;
+                        followingToken = this.tokens[followingTokenI];
+                    }
+                    if (endToken) {
+                        ranges.push({
+                            type: lastTokenWasMarker ? `remove` : `marker`,
+                            range: {
+                                start: currentToken.range.start,
+                                end: endToken.range.end,
+                            },
+                            named: endToken.value,
+                        });
+                        lastTokenWasMarker = true;
+                        i = followingTokenI - 1;
+                    }
+                    break;
+                default:
+                    if (i === 0 && tokenIs(currentToken, `word`, `EXEC`)) {
+                        // We check and remove the starting `EXEC SQL`
+                        if (tokenIs(this.tokens[i + 1], `word`, `SQL`)) {
+                            ranges.push({
+                                type: `remove`,
+                                range: {
+                                    start: currentToken.range.start,
+                                    end: this.tokens[i + 1].range.end,
+                                },
+                            });
+                        }
+                    }
+                    break;
+            }
+        }
+        return ranges;
+    }
+    static trimTokens(tokens) {
+        if (tokens.length > 0) {
+            let realFirstToken = tokens.findIndex((t) => t.type !== `newline`);
+            if (realFirstToken < 0)
+                realFirstToken = 0;
+            let realLastToken = 0;
+            for (let i = tokens.length - 1; i >= 0; i--) {
+                if (tokens[i].type !== `newline`) {
+                    realLastToken = i + 1;
+                    break;
+                }
+            }
+            tokens = tokens.slice(realFirstToken, realLastToken);
+        }
+        return tokens;
+    }
+    static formatSimpleTokens(tokens) {
+        let outString = ``;
+        for (let i = 0; i < tokens.length; i++) {
+            const cT = tokens[i];
+            const nT = tokens[i + 1];
+            const pT = tokens[i - 1];
+            switch (cT.type) {
+                case `block`:
+                    outString += `(${Statement.formatSimpleTokens(cT.block)})`;
+                    if (nT && nT.type !== `closebracket`) {
+                        outString += ` `;
+                    }
+                    break;
+                case `openbracket`:
+                    outString += cT.value;
+                    break;
+                case `closebracket`:
+                    outString += cT.value;
+                    if (nT && nT.type !== cT.type) {
+                        outString += ` `;
+                    }
+                    break;
+                default:
+                    if (nT &&
+                        ![`closebracket`, `openbracket`, `comma`, `block`].includes(nT.type)) {
+                        outString += `${cT.value} `;
+                    }
+                    else {
+                        outString += cT.value;
+                    }
+                    break;
+            }
+        }
+        return outString.trimEnd();
+    }
+}
+//# sourceMappingURL=statement.js.map