@jpoly1219/context-extractor 0.2.8 → 0.2.10

package/dist/src/ocaml-driver.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OcamlDriver = void 0;
 const fs = __importStar(require("fs"));
@@ -35,230 +45,322 @@ class OcamlDriver {
         this.typeChecker = new ocaml_type_checker_1.OcamlTypeChecker();
     }
     async init(lspClient, sketchPath) {
-        const capabilities = {
-            'textDocument': {
-                'codeAction': { 'dynamicRegistration': true },
-                'codeLens': { 'dynamicRegistration': true },
-                'colorProvider': { 'dynamicRegistration': true },
-                'completion': {
-                    'completionItem': {
-                        'commitCharactersSupport': true,
-                        'documentationFormat': ['markdown', 'plaintext'],
-                        'snippetSupport': true
+        if (lspClient) {
+            const capabilities = {
+                'textDocument': {
+                    'codeAction': { 'dynamicRegistration': true },
+                    'codeLens': { 'dynamicRegistration': true },
+                    'colorProvider': { 'dynamicRegistration': true },
+                    'completion': {
+                        'completionItem': {
+                            'commitCharactersSupport': true,
+                            'documentationFormat': ['markdown', 'plaintext'],
+                            'snippetSupport': true
+                        },
+                        'completionItemKind': {
+                            'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+                        },
+                        'contextSupport': true,
+                        'dynamicRegistration': true
                     },
-                    'completionItemKind': {
-                        'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+                    'definition': { 'dynamicRegistration': true },
+                    'documentHighlight': { 'dynamicRegistration': true },
+                    'documentLink': { 'dynamicRegistration': true },
+                    'documentSymbol': {
+                        'dynamicRegistration': true,
+                        'symbolKind': {
+                            'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
+                        }
                     },
-                    'contextSupport': true,
-                    'dynamicRegistration': true
-                },
-                'definition': { 'dynamicRegistration': true },
-                'documentHighlight': { 'dynamicRegistration': true },
-                'documentLink': { 'dynamicRegistration': true },
-                'documentSymbol': {
-                    'dynamicRegistration': true,
-                    'symbolKind': {
-                        'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
-                    }
-                },
-                'formatting': { 'dynamicRegistration': true },
-                'hover': {
-                    'contentFormat': ['markdown', 'plaintext'],
-                    'dynamicRegistration': true
+                    'formatting': { 'dynamicRegistration': true },
+                    'hover': {
+                        'contentFormat': ['markdown', 'plaintext'],
+                        'dynamicRegistration': true
+                    },
+                    'implementation': { 'dynamicRegistration': true },
+                    // 'inlayhint': { 'dynamicRegistration': true },
+                    'onTypeFormatting': { 'dynamicRegistration': true },
+                    'publishDiagnostics': { 'relatedInformation': true },
+                    'rangeFormatting': { 'dynamicRegistration': true },
+                    'references': { 'dynamicRegistration': true },
+                    'rename': { 'dynamicRegistration': true },
+                    'signatureHelp': {
+                        'dynamicRegistration': true,
+                        'signatureInformation': { 'documentationFormat': ['markdown', 'plaintext'] }
+                    },
+                    'synchronization': {
+                        'didSave': true,
+                        'dynamicRegistration': true,
+                        'willSave': true,
+                        'willSaveWaitUntil': true
+                    },
+                    'typeDefinition': { 'dynamicRegistration': true, 'linkSupport': true },
+                    // 'typeHierarchy': { 'dynamicRegistration': true }
                 },
-                'implementation': { 'dynamicRegistration': true },
-                // 'inlayhint': { 'dynamicRegistration': true },
-                'onTypeFormatting': { 'dynamicRegistration': true },
-                'publishDiagnostics': { 'relatedInformation': true },
-                'rangeFormatting': { 'dynamicRegistration': true },
-                'references': { 'dynamicRegistration': true },
-                'rename': { 'dynamicRegistration': true },
-                'signatureHelp': {
-                    'dynamicRegistration': true,
-                    'signatureInformation': { 'documentationFormat': ['markdown', 'plaintext'] }
+                'workspace': {
+                    'applyEdit': true,
+                    'configuration': true,
+                    'didChangeConfiguration': { 'dynamicRegistration': true },
+                    'didChangeWatchedFiles': { 'dynamicRegistration': true },
+                    'executeCommand': { 'dynamicRegistration': true },
+                    'symbol': {
+                        'dynamicRegistration': true,
+                        'symbolKind': {
+                            'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
+                        }
+                    }, 'workspaceEdit': { 'documentChanges': true },
+                    'workspaceFolders': true
                 },
-                'synchronization': {
-                    'didSave': true,
-                    'dynamicRegistration': true,
-                    'willSave': true,
-                    'willSaveWaitUntil': true
+                'general': {
+                    'positionEncodings': ['utf-8']
                 },
-                'typeDefinition': { 'dynamicRegistration': true, 'linkSupport': true },
-                // 'typeHierarchy': { 'dynamicRegistration': true }
-            },
-            'workspace': {
-                'applyEdit': true,
-                'configuration': true,
-                'didChangeConfiguration': { 'dynamicRegistration': true },
-                'didChangeWatchedFiles': { 'dynamicRegistration': true },
-                'executeCommand': { 'dynamicRegistration': true },
-                'symbol': {
-                    'dynamicRegistration': true,
-                    'symbolKind': {
-                        'valueSet': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
+            };
+            const rootPath = path.dirname(sketchPath);
+            const rootUri = `file://${rootPath}`;
+            const workspaceFolders = [{ 'name': 'context-extractor', 'uri': rootUri }];
+            await lspClient.initialize({
+                processId: process.pid,
+                capabilities: capabilities,
+                trace: 'off',
+                rootUri: null,
+                workspaceFolders: workspaceFolders,
+                initializationOptions: {
+                    preferences: {
+                        includeInlayVariableTypeHints: true
                     }
-                }, 'workspaceEdit': { 'documentChanges': true },
-                'workspaceFolders': true
-            },
-            'general': {
-                'positionEncodings': ['utf-8']
-            },
-        };
-        const rootPath = path.dirname(sketchPath);
-        const rootUri = `file://${rootPath}`;
-        const workspaceFolders = [{ 'name': 'context-extractor', 'uri': rootUri }];
-        await lspClient.initialize({
-            processId: process.pid,
-            capabilities: capabilities,
-            trace: 'off',
-            rootUri: null,
-            workspaceFolders: workspaceFolders,
-            initializationOptions: {
-                preferences: {
-                    includeInlayVariableTypeHints: true
                 }
-            }
-        });
+            });
+        }
+    }
+    injectHole(sketchPath) {
     }
     async getHoleContext(lspClient, sketchFilePath) {
         const sketchDir = path.dirname(sketchFilePath);
         const sketchFileContent = fs.readFileSync(sketchFilePath, "utf8");
-        // Sync client and server by notifying that the client has opened all the files inside the target directory.
-        fs.readdirSync(sketchDir).map(fileName => {
-            if (fs.lstatSync(path.join(sketchDir, fileName)).isFile()) {
-                const langType = (() => {
-                    switch (fileName) {
-                        case "dune":
-                            return "dune";
-                        case "dune-project":
-                            return "dune-project";
-                        case ".ocamlformat":
-                            return ".ocamlformat";
-                        default:
-                            return "ocaml";
-                    }
-                })();
-                lspClient.didOpen({
-                    textDocument: {
-                        uri: `file://${sketchDir}/${fileName}`,
-                        languageId: langType,
-                        text: fs.readFileSync(`${sketchDir}/${fileName}`).toString("ascii"),
-                        version: 1
+        if (lspClient) {
+            // Sync client and server by notifying that the client has opened all the files inside the target directory.
+            fs.readdirSync(sketchDir).map(fileName => {
+                if (fs.lstatSync(path.join(sketchDir, fileName)).isFile()) {
+                    const langType = (() => {
+                        switch (fileName) {
+                            case "dune":
+                                return "dune";
+                            case "dune-project":
+                                return "dune-project";
+                            case ".ocamlformat":
+                                return ".ocamlformat";
+                            default:
+                                return "ocaml";
+                        }
+                    })();
+                    lspClient.didOpen({
+                        textDocument: {
+                            uri: `file://${sketchDir}/${fileName}`,
+                            languageId: langType,
+                            text: fs.readFileSync(`${sketchDir}/${fileName}`).toString("ascii"),
+                            version: 1
+                        }
+                    });
+                }
+            });
+            // Get hole context.
+            const holeCtx = (await lspClient.ocamlMerlinCallCompatible({
+                uri: `file://${sketchFilePath}`,
+                command: "holes",
+                args: [],
+                resultAsSexp: false
+            }));
+            const sketchSymbol = await lspClient.documentSymbol({
+                textDocument: {
+                    uri: `file://${sketchFilePath}`
+                }
+            });
+            return {
+                fullHoverResult: "", //
+                functionName: "_", // _
+                functionTypeSpan: JSON.parse(holeCtx.result).value[0].type, // model * action -> model
+                linePosition: JSON.parse(holeCtx.result).value[0].start.line, // hole's line
+                characterPosition: JSON.parse(holeCtx.result).value[0].start.col, // hole's character
+                holeTypeDefLinePos: 3, // 
+                holeTypeDefCharPos: 0, // "
+                range: sketchSymbol[0].location.range,
+                source: `file://${sketchFilePath}`
+            };
+        }
+        else {
+            // TODO: Do vscode things.
+            return {
+                fullHoverResult: "", //
+                functionName: "_", // _
+                functionTypeSpan: "",
+                linePosition: 0,
+                characterPosition: 0,
+                holeTypeDefLinePos: 0, // 
+                holeTypeDefCharPos: 0, // "
+                range: {
+                    start: {
+                        line: 0,
+                        character: 0
+                    },
+                    end: {
+                        line: 0,
+                        character: 0
                     }
-                });
-            }
-        });
-        // Get hole context.
-        const holeCtx = (await lspClient.ocamlMerlinCallCompatible({
-            uri: `file://${sketchFilePath}`,
-            command: "holes",
-            args: [],
-            resultAsSexp: false
-        }));
-        const sketchSymbol = await lspClient.documentSymbol({
-            textDocument: {
-                uri: `file://${sketchFilePath}`
-            }
-        });
+                },
+                source: ""
+            };
+        }
+    }
+    async getHoleContextWithCompilerAPI(sketchFilePath, logStream) {
         return {
             fullHoverResult: "", //
             functionName: "_", // _
-            functionTypeSpan: JSON.parse(holeCtx.result).value[0].type, // model * action -> model
-            linePosition: JSON.parse(holeCtx.result).value[0].start.line, // hole's line
-            characterPosition: JSON.parse(holeCtx.result).value[0].start.col, // hole's character
-            holeTypeDefLinePos: 3, // 
+            functionTypeSpan: "",
+            linePosition: 0,
+            characterPosition: 0,
+            holeTypeDefLinePos: 0, // 
             holeTypeDefCharPos: 0, // "
-            range: sketchSymbol[0].location.range,
-            source: `file://${sketchFilePath}`
+            range: {
+                start: {
+                    line: 0,
+                    character: 0
+                },
+                end: {
+                    line: 0,
+                    character: 0
+                }
+            },
+            source: ""
+        };
+    }
+    async getHoleContextWithTreesitter(sketchFilePath, cursorPosition, logStream) {
+        return {
+            fullHoverResult: "", //
+            functionName: "_", // _
+            functionTypeSpan: "",
+            linePosition: 0,
+            characterPosition: 0,
+            holeTypeDefLinePos: 0, // 
+            holeTypeDefCharPos: 0, // "
+            range: {
+                start: {
+                    line: 0,
+                    character: 0
+                },
+                end: {
+                    line: 0,
+                    character: 0
+                }
+            },
+            source: ""
         };
     }
     async extractRelevantTypes(lspClient, fullHoverResult, typeName, startLine, foundSoFar, currentFile) {
-        if (!foundSoFar.has(typeName)) {
-            foundSoFar.set(typeName, { typeSpan: fullHoverResult, sourceFile: currentFile.slice(7) });
-            // outputFile.write(`${fullHoverResult};\n`);
-            const content = fs.readFileSync(currentFile.slice(7), "utf8");
-            for (let linePos = startLine; linePos <= fullHoverResult.length; ++linePos) {
-                const numOfCharsInLine = parseInt((0, child_process_1.execSync)(`wc -m <<< "${content.split("\n")[linePos]}"`, { shell: "/bin/bash" }).toString());
-                for (let charPos = 0; charPos < numOfCharsInLine; ++charPos) {
-                    try {
-                        const typeDefinitionResult = await lspClient.typeDefinition({
-                            textDocument: {
-                                uri: currentFile
-                            },
-                            position: {
-                                character: charPos,
-                                line: linePos
-                            }
-                        });
-                        if (typeDefinitionResult && typeDefinitionResult instanceof Array && typeDefinitionResult.length != 0) {
-                            // Use documentSymbol instead of hover.
-                            // This prevents type alias "squashing" done by tsserver.
-                            // This also allows for grabbing the entire definition range and not just the symbol range.
-                            // PERF: feels like this could be memoized to improve performance.
-                            const documentSymbolResult = await lspClient.documentSymbol({
+        if (lspClient) {
+            if (!foundSoFar.has(typeName)) {
+                foundSoFar.set(typeName, { typeSpan: fullHoverResult, sourceFile: currentFile.slice(7) });
+                // outputFile.write(`${fullHoverResult};\n`);
+                const content = fs.readFileSync(currentFile.slice(7), "utf8");
+                for (let linePos = startLine; linePos <= fullHoverResult.length; ++linePos) {
+                    const numOfCharsInLine = parseInt((0, child_process_1.execSync)(`wc -m <<< "${content.split("\n")[linePos]}"`, { shell: "/bin/bash" }).toString());
+                    for (let charPos = 0; charPos < numOfCharsInLine; ++charPos) {
+                        try {
+                            const typeDefinitionResult = await lspClient.typeDefinition({
                                 textDocument: {
-                                    uri: typeDefinitionResult[0].uri
+                                    uri: currentFile
+                                },
+                                position: {
+                                    character: charPos,
+                                    line: linePos
                                 }
                             });
-                            // grab if the line number of typeDefinitionResult and documentSymbolResult matches
-                            // FIX: This overwrites older definitions if the lines are the same. Especially for type constructors, such as playlist_state.
-                            // Generally the one that comes first is the largest, but this could be dependent on the source code.
-                            const dsMap = documentSymbolResult.reduce((m, obj) => {
-                                const newSymbol = obj;
-                                const existing = m.get(newSymbol.location.range.start.line);
-                                if (existing) {
-                                    // Compare range between existing doucment symbol and the current symbol.
-                                    if (existing.end.line - existing.start.line >= newSymbol.location.range.end.line - newSymbol.location.range.start.line) {
-                                        return m;
+                            if (typeDefinitionResult && typeDefinitionResult instanceof Array && typeDefinitionResult.length != 0) {
+                                // Use documentSymbol instead of hover.
+                                // This prevents type alias "squashing" done by tsserver.
+                                // This also allows for grabbing the entire definition range and not just the symbol range.
+                                // PERF: feels like this could be memoized to improve performance.
+                                const documentSymbolResult = await lspClient.documentSymbol({
+                                    textDocument: {
+                                        uri: typeDefinitionResult[0].uri
                                     }
-                                    else if (existing.end.character - existing.start.character >= newSymbol.location.range.end.character - newSymbol.location.range.start.character) {
-                                        return m;
+                                });
+                                // grab if the line number of typeDefinitionResult and documentSymbolResult matches
+                                // FIX: This overwrites older definitions if the lines are the same. Especially for type constructors, such as playlist_state.
+                                // Generally the one that comes first is the largest, but this could be dependent on the source code.
+                                const dsMap = documentSymbolResult.reduce((m, obj) => {
+                                    const newSymbol = obj;
+                                    const existing = m.get(newSymbol.location.range.start.line);
+                                    if (existing) {
+                                        // Compare range between existing doucment symbol and the current symbol.
+                                        if (existing.end.line - existing.start.line >= newSymbol.location.range.end.line - newSymbol.location.range.start.line) {
+                                            return m;
+                                        }
+                                        else if (existing.end.character - existing.start.character >= newSymbol.location.range.end.character - newSymbol.location.range.start.character) {
+                                            return m;
+                                        }
                                     }
+                                    m.set(obj.location.range.start.line, obj.location.range);
+                                    return m;
+                                }, new Map());
+                                const matchingSymbolRange = dsMap.get(typeDefinitionResult[0].range.start.line);
+                                if (matchingSymbolRange) {
+                                    const snippetInRange = (0, utils_1.extractSnippet)(fs.readFileSync(typeDefinitionResult[0].uri.slice(7)).toString("utf8"), matchingSymbolRange.start, matchingSymbolRange.end);
+                                    // TODO: this can potentially be its own method. the driver would require some way to get type context.
+                                    // potentially, this type checker can be its own class.
+                                    const identifier = this.typeChecker.getIdentifierFromDecl(snippetInRange);
+                                    await this.extractRelevantTypes(lspClient, snippetInRange, identifier, matchingSymbolRange.start.line, foundSoFar, typeDefinitionResult[0].uri);
                                 }
-                                m.set(obj.location.range.start.line, obj.location.range);
-                                return m;
-                            }, new Map());
-                            const matchingSymbolRange = dsMap.get(typeDefinitionResult[0].range.start.line);
-                            if (matchingSymbolRange) {
-                                const snippetInRange = (0, utils_1.extractSnippet)(fs.readFileSync(typeDefinitionResult[0].uri.slice(7)).toString("utf8"), matchingSymbolRange.start, matchingSymbolRange.end);
-                                // TODO: this can potentially be its own method. the driver would require some way to get type context.
-                                // potentially, this type checker can be its own class.
-                                const identifier = this.typeChecker.getIdentifierFromDecl(snippetInRange);
-                                await this.extractRelevantTypes(lspClient, snippetInRange, identifier, matchingSymbolRange.start.line, foundSoFar, typeDefinitionResult[0].uri);
                             }
                         }
-                    }
-                    catch (err) {
-                        console.log(`${err}`);
+                        catch (err) {
+                            console.log(`${err}`);
+                        }
                     }
                 }
             }
+            return foundSoFar;
+        }
+        else {
+            // TODO: Do vscode things.
+            return foundSoFar;
         }
+    }
+    async extractRelevantTypesWithCompilerAPI(fullHoverResult, typeName, linePosition, characterPosition, foundSoFar, currentFile) {
+        return foundSoFar;
+    }
+    async extractRelevantTypesWithTreesitter(lspClient, fullHoverResult, typeName, startLine, foundSoFar, // identifier -> [full hover result, source]
+    currentFile, foundContents, // uri -> contents
+    logStream) {
         return foundSoFar;
     }
     async extractRelevantHeaders(lspClient, 
     // preludeFilePath: string,
     sources, relevantTypes, holeType) {
         const relevantContext = new Set();
-        for (const source of sources) {
-            const headerTypeSpans = await this.extractHeaderTypeSpans(lspClient, source);
-            const targetTypes = this.generateTargetTypes(holeType, relevantTypes, source);
-            try {
-                for (const hts of headerTypeSpans) {
-                    const recursiveChildTypes = ocamlParser.parse(hts.typeSpan);
-                    if (recursiveChildTypes.some((rct) => targetTypes.has(rct))) {
-                        relevantContext.add({ typeSpan: (hts.identifier + " : " + hts.typeSpan), sourceFile: source });
-                        continue;
+        if (lspClient) {
+            for (const source of sources) {
+                const headerTypeSpans = await this.extractHeaderTypeSpans(lspClient, source);
+                const targetTypes = this.generateTargetTypes(holeType, relevantTypes, source);
+                try {
+                    for (const hts of headerTypeSpans) {
+                        const recursiveChildTypes = ocamlParser.parse(hts.typeSpan);
+                        if (recursiveChildTypes.some((rct) => targetTypes.has(rct))) {
+                            relevantContext.add({ typeSpan: (hts.identifier + " : " + hts.typeSpan), sourceFile: source });
+                            continue;
+                        }
+                        this.extractRelevantHeadersHelper(hts.typeSpan, targetTypes, relevantTypes, relevantContext, hts.snippet, source);
                     }
-                    this.extractRelevantHeadersHelper(hts.typeSpan, targetTypes, relevantTypes, relevantContext, hts.snippet, source);
+                }
+                catch (err) {
+                    return new Set();
+                    console.log(err);
                 }
             }
-            catch (err) {
-                return new Set();
-                console.log(err);
-            }
+            return relevantContext;
+        }
+        else {
+            return relevantContext;
         }
-        return relevantContext;
     }
     async extractHeaderTypeSpans(lspClient, preludeFilePath) {
         const docSymbols = await lspClient.documentSymbol({
@@ -390,5 +492,8 @@ class OcamlDriver {
             return typeSpan;
         }
     }
+    async extractRelevantHeadersWithTreesitter(lspClient, sources, relevantTypes, holeType, holeIdentifier, projectRoot) {
+        return new Set();
+    }
 }
 exports.OcamlDriver = OcamlDriver;