chore: return all GUCs for pgconf completion

I just realized, that VS Code will perform search and ranking parameters
itself, so we do not need to add extra logic.
Code with binary search, prefix match, etc... is deleted and now we just
return all known GUCs.

Author: ashenBlade

src/pgconf.ts

@@ -2,129 +2,17 @@ import * as vscode from 'vscode';
 
 import * as constants from './constants';
 
-function binarySearchPrefix(parameters: string[], input: string) {
-    let start = 0;
-    let end = parameters.length;
-
-    while (start < end) {
-        const mid = Math.floor((start + end) / 2);
-        const cur = parameters[mid];
-        const cmp =  cur.localeCompare(input);
-        if (cmp < 0) {
-            start = mid + 1;
-        } else if (cmp > 0) {
-            // end = mid - 1;
-            end = mid;
-        } else {
-            /* There are must be no duplicates */
-            return mid;
-        }
-    }
-
-    if (start === parameters.length) {
-        return -1;
-    }
-    
-    /* 
-     * As an input we are searching a prefix and not exact match,
-     * so 'start' can point to any element: 1) with such prefix
-     * or 2) previous element of 1.
-     * i.e. with input 'enabl' binary search can result in 'start'
-     * pointing to either 'effective_io_concurrency' (previous) or
-     * 'enable_async_append' (target), so we should check both cases.
-     */
-    if (parameters[start].startsWith(input)) {
-        return start;
-    }
-
-    if (   start < parameters.length - 1
-        && parameters[start + 1].startsWith(input)) {
-        return start + 1;
-    }
-
-    return -1;
-}
-
-export function getParamsByPrefix(parameters: string[], input: string): [number, number] | number | undefined {
-    const start = binarySearchPrefix(parameters, input);
-
-    if (start === -1) {
-        /* No arguments match */
-        return;
-    }
-
-    /* Last argument is the only */
-    if (start === parameters.length - 1) {
-        return start;
-    }
-
-    /*
-     * Linearly search all prefixes. This is ok, since we know that there
-     * are not so many parameters
-     */
-    let i = start;
-    while (i < parameters.length - 1 && parameters[i + 1].startsWith(input)) {
-        ++i;
-    }
-
-    if (start !== i) {
-        /* Return 'i + 1', so Array.slice can be used by simple array expansion */
-        return [start, i + 1];
-    } else {
-        return start;
-    }
-}
-
 class PgConfCompletionProvider implements vscode.CompletionItemProvider {
+    items?: vscode.CompletionItem[];;
     provideCompletionItems(document: vscode.TextDocument, position: vscode.Position) {
         const range = document.getWordRangeAtPosition(position);
         if (!range) {
+            /* Check this is a word (parameter) */
             return;
         }
 
-        /*
-         * For now use simple prefix match for autocompletion.
-         * In future versions we should add fuzzy string match,
-         * i.e. based on Jaccard or Levenshtein.
-         * 
-         * XXX: When implementing we should keep in mind, that
-         * TS/JS is slow and likes to allocate huge memory, so
-         * prefer simple, but faster algorithms.
-         */
-        const param = document.getText(range);
-        const parameters = this.getGUCs();
-        const prefixRange = getParamsByPrefix(parameters, param);
-        if (prefixRange === undefined) {
-            return;
-        }
-        
-        if (typeof prefixRange === 'number') {
-            return [new vscode.CompletionItem(parameters[prefixRange])];
-        }
-        
-        if (Array.isArray(prefixRange)) {
-            return parameters.slice(...prefixRange).map(p => new vscode.CompletionItem(p));
-        }
-    }
-
-    private getGUCs() {
-        /* 
-         * Use only builtin GUCs, because tracking contribs is hard task.
-         * We of course can traverse 'contrib/' directory and find all *.c
-         * files - that what I did just now.
-         *
-         * But this approach gives another pain - resources consumption, IO,
-         * CPU and memory. When I tested such logic on medium sized contrib dir
-         * I faced high CPU consumption (even fans started making noise) and
-         * memory (extension profiler showed up to 1GB heap size with sawtooth
-         * shaped graph).
-         * 
-         * Another approach is to keep track of all contribs in code, i.e. have
-         * another 'contribGucs' in 'constants.ts' with Map contrib -> it's GUCs,
-         * but it will require to constant monitoring for changes, which is now
-         * doesn't sound appealing yet.
-         */
-        return constants.getWellKnownConfigurationParameters();
+        return this.items ??= constants.getWellKnownConfigurationParameters()
+                                       .map(x => new vscode.CompletionItem(x));
     }
 }
 

src/test/suite/unit.test.ts

@@ -76,75 +76,4 @@ suite('Unit', async function () {
             assert.equal(actual, expected, `${type}: ${count}`);
         }
     });
-
-    test('getParamsByPrefix', function() {
-        type functionResult = [number, number] | number | undefined;
-        type testData = [string[], string, functionResult];
-        const _ = (arr: string[], input: string, idx: functionResult): testData => [arr, input, idx];
-        const data: testData[] = [
-            /* Simple binary search tests */
-            _(['a', 'b', 'c'], 'a', 0),
-            _(['a', 'b', 'c'], 'b', 1),
-            _(['a', 'b', 'c'], 'c', 2),
-            _(['a', 'b', 'c'], 'e', undefined),
-            _(['b', 'c', 'd'], 'a', undefined),
-            _(['a', 'aa', 'aaa'], 'a', [0, 3]),
-
-            /* Prefix search */
-            _(['abc', 'def', 'ghi'], 'ab', 0),
-            _(['abc', 'def', 'ghi'], 'de', 1),
-            _(['abc', 'def', 'ghi'], 'gh', 2),
-            _(['abcd', 'abce', 'abcf'], 'ab', [0, 3]),
-            _(['abcd', 'abce', 'abcf'], 'xx', undefined),
-
-            /* Realistic input */
-            ...[
-                ['enable', undefined],
-                ['jo', 1],
-                ['lc_m', [4, 6]],
-                ['lc_n', 6],
-            ].map(([input, r]) => _([
-                'jit_tuple_deforming',
-                'join_collapse_limit',
-                'krb_caseins_users',
-                'krb_server_keyfile',
-                'lc_messages',
-                'lc_monetary',
-                'lc_numeric',
-            ], input as string, r as functionResult)),
-
-            ...[
-                ['b', [0, 6]],
-                ['bg', [0, 3]],
-                ['bon', [3, 5]],
-                ['bonjour', [3, 5]],
-                ['bonjour_', 4],
-            ].map(([input, r]) => _([
-                'bgwriter_flush_after',
-                'bgwriter_lru_maxpages',
-                'bgwriter_lru_multiplier',
-                'bonjour',
-                'bonjour_name',
-                'bytea_output',
-            ], input as string, r as functionResult)),
-        ];
-        for (const [array, prefix, expected] of data) {
-            const actual = configfile.getParamsByPrefix(array, prefix);
-            assert.deepStrictEqual(actual, expected, `${prefix} - ${array}`);
-        }
-
-        /* Some integration testing */
-        const parameters = constants.getWellKnownConfigurationParameters();
-        const check = (input: string) => {
-            const range = configfile.getParamsByPrefix(parameters, input);
-            assert.ok(Array.isArray(range));
-            /* Use set, so we can add elements anytime */
-            const expected = parameters.filter(p => p.startsWith(input));
-            assert.deepStrictEqual(new Set(parameters.slice(...range)), new Set(expected));
-        };
-
-        check('pg_stat_sta');
-        check('enabl');
-        check('max_paral');
-    });
 });