@jpoly1219/context-extractor 0.2.0 → 0.2.1

package/dist/typescript-type-checker.js

@@ -0,0 +1,512 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : 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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptTypeChecker = void 0;
+const ts = __importStar(require("typescript"));
+const utils_1 = require("./utils");
+class TypeScriptTypeChecker {
+    getIdentifierFromDecl(typeDecl) {
+        const declRe = /(.+ )(.+)( = )(.+)/;
+        const match = typeDecl.match(declRe);
+        if (!match)
+            return "";
+        return match[2];
+    }
+    getTypeContextFromDecl(typeDecl) {
+        if (this.checkHole(typeDecl)) {
+            return this.checkHole(typeDecl);
+        }
+        else if (this.checkParameter(typeDecl)) {
+            return this.checkParameter(typeDecl);
+        }
+        else if (this.checkFunction(typeDecl)) {
+            return this.checkFunction(typeDecl);
+        }
+        else if (this.checkUnion(typeDecl)) {
+            return this.checkUnion(typeDecl);
+        }
+        else if (this.checkObject(typeDecl)) {
+            return this.checkObject(typeDecl);
+        }
+        else if (this.checkImports(typeDecl)) {
+            return this.checkImports(typeDecl);
+        }
+        else if (this.checkModule(typeDecl)) {
+            return this.checkModule(typeDecl);
+        }
+        else {
+            return this.checkPrimitive(typeDecl);
+        }
+    }
+    // pattern matching
+    // attempts to match strings to corresponding types, then returns an object containing the name, type span, and an interesting index
+    // base case - type can no longer be stepped into
+    // boolean, number, string, enum, unknown, any, void, null, undefined, never
+    // ideally this should be checked for before we do the for loop
+    // return typeSpan;
+    // check if hover result is from a primitive type
+    checkPrimitive(typeDecl) {
+        // type _ = boolean
+        const primitivePattern = /(type )(.+)( = )(.+)/;
+        const primitiveMatch = typeDecl.match(primitivePattern);
+        let primitiveInterestingIndex = -1;
+        if (primitiveMatch) {
+            primitiveInterestingIndex = (0, utils_1.indexOfRegexGroup)(primitiveMatch, 4);
+        }
+        if (primitiveInterestingIndex != -1) {
+            const typeName = primitiveMatch[2];
+            const typeSpan = primitiveMatch[4];
+            return { identifier: typeName, span: typeSpan, interestingIndex: primitiveInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from an import
+    checkImports(typeDecl) {
+        // import { _, _ };
+        const importPattern = /(import )(\{.+\})/;
+        const importMatch = typeDecl.match(importPattern);
+        let importInterestingIndex = -1;
+        if (importMatch) {
+            importInterestingIndex = (0, utils_1.indexOfRegexGroup)(importMatch, 2);
+        }
+        // import _;
+        const defaultImportPattern = /(import )(.+)/;
+        const defaultImportMatch = typeDecl.match(defaultImportPattern);
+        let defaultImportInterestingIndex = -1;
+        if (defaultImportMatch) {
+            defaultImportInterestingIndex = (0, utils_1.indexOfRegexGroup)(defaultImportMatch, 2);
+        }
+        if (importInterestingIndex != -1) {
+            const typeName = importMatch[2];
+            const typeSpan = importMatch[2];
+            return { identifier: typeName, span: typeSpan, interestingIndex: importInterestingIndex };
+        }
+        else if (defaultImportInterestingIndex != -1) {
+            const typeName = defaultImportMatch[2];
+            const typeSpan = defaultImportMatch[2];
+            return { identifier: typeName, span: typeSpan, interestingIndex: defaultImportInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from a module
+    checkModule(typeDecl) {
+        // module "path/to/module"
+        const modulePattern = /(module )(.+)/;
+        const moduleMatch = typeDecl.match(modulePattern);
+        let moduleInterestingIndex = -1;
+        if (moduleMatch) {
+            moduleInterestingIndex = (0, utils_1.indexOfRegexGroup)(moduleMatch, 2);
+        }
+        if (moduleInterestingIndex != -1) {
+            const typeName = moduleMatch[2];
+            const typeSpan = moduleMatch[2];
+            return { identifier: typeName, span: typeSpan, interestingIndex: moduleInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from an object
+    checkObject(typeDecl) {
+        // type _ = {
+        //   _: t1;
+        //   _: t2;
+        // }
+        const objectTypeDefPattern = /(type )(.+)( = )(\{.+\})/;
+        const objectTypeDefMatch = typeDecl.match(objectTypeDefPattern);
+        let objectTypeDefInterestingIndex = -1;
+        if (objectTypeDefMatch) {
+            objectTypeDefInterestingIndex = (0, utils_1.indexOfRegexGroup)(objectTypeDefMatch, 4);
+        }
+        if (objectTypeDefInterestingIndex != -1) {
+            const typeName = objectTypeDefMatch[2];
+            const typeSpan = objectTypeDefMatch[4];
+            return { identifier: typeName, span: typeSpan, interestingIndex: objectTypeDefInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from a union
+    checkUnion(typeDecl) {
+        // type _ = A | B | C
+        const unionPattern = /(type )(.+)( = )((.+ | )+.+)/;
+        const unionMatch = typeDecl.match(unionPattern);
+        let unionInterestingIndex = -1;
+        if (unionMatch) {
+            unionInterestingIndex = (0, utils_1.indexOfRegexGroup)(unionMatch, 4);
+        }
+        if (unionInterestingIndex != -1) {
+            const typeName = unionMatch[2];
+            const typeSpan = unionMatch[4];
+            return { identifier: typeName, span: typeSpan, interestingIndex: unionInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from a function
+    checkFunction(typeDecl) {
+        // const myFunc : (arg1: typ1, ...) => _
+        const es6AnnotatedFunctionPattern = /(const )(.+)(: )(\(.+\) => .+)/;
+        const es6AnnotatedFunctionMatch = typeDecl.match(es6AnnotatedFunctionPattern);
+        let es6AnnotatedFunctionInterestingIndex = -1;
+        if (es6AnnotatedFunctionMatch) {
+            es6AnnotatedFunctionInterestingIndex = (0, utils_1.indexOfRegexGroup)(es6AnnotatedFunctionMatch, 4);
+        }
+        // type _ = (_: t1) => t2
+        const es6FunctionTypeDefPattern = /(type )(.+)( = )(\(.+\) => .+)/;
+        const es6FunctionTypeDefPatternMatch = typeDecl.match(es6FunctionTypeDefPattern);
+        let es6FunctionTypeDefInterestingIndex = -1;
+        if (es6FunctionTypeDefPatternMatch) {
+            es6FunctionTypeDefInterestingIndex = (0, utils_1.indexOfRegexGroup)(es6FunctionTypeDefPatternMatch, 4);
+        }
+        // function myFunc<T>(args: types, genarg: T): returntype
+        const genericFunctionTypePattern = /(function )(.+)(\<.+\>\(.*\))(: )(.+)/;
+        const genericFunctionTypeMatch = typeDecl.match(genericFunctionTypePattern);
+        let genericFunctionTypeInterestingIndex = -1;
+        if (genericFunctionTypeMatch) {
+            genericFunctionTypeInterestingIndex = (0, utils_1.indexOfRegexGroup)(genericFunctionTypeMatch, 3);
+        }
+        // function myFunc(args: types): returntype
+        const functionTypePattern = /(function )(.+)(\(.*\))(: )(.+)/;
+        const functionTypeMatch = typeDecl.match(functionTypePattern);
+        let functionTypeInterestingIndex = -1;
+        if (functionTypeMatch) {
+            functionTypeInterestingIndex = (0, utils_1.indexOfRegexGroup)(functionTypeMatch, 3);
+        }
+        if (es6AnnotatedFunctionInterestingIndex != -1) {
+            const typeName = es6AnnotatedFunctionMatch[2];
+            const typeSpan = es6AnnotatedFunctionMatch[4];
+            return { identifier: typeName, span: typeSpan, interestingIndex: es6AnnotatedFunctionInterestingIndex };
+        }
+        else if (es6FunctionTypeDefInterestingIndex != -1) {
+            const typeName = es6FunctionTypeDefPatternMatch[2];
+            const typeSpan = es6FunctionTypeDefPatternMatch[4];
+            return { identifier: typeName, span: typeSpan, interestingIndex: es6FunctionTypeDefInterestingIndex };
+        }
+        else if (genericFunctionTypeInterestingIndex != -1) {
+            const typeName = genericFunctionTypeMatch[2];
+            const typeSpan = genericFunctionTypeMatch[3] + genericFunctionTypeMatch[4] + genericFunctionTypeMatch[5];
+            return { identifier: typeName, span: typeSpan, interestingIndex: genericFunctionTypeInterestingIndex };
+        }
+        else if (functionTypeInterestingIndex != -1) {
+            const typeName = functionTypeMatch[2];
+            const typeSpan = functionTypeMatch[3] + functionTypeMatch[4] + functionTypeMatch[5];
+            return { identifier: typeName, span: typeSpan, interestingIndex: functionTypeInterestingIndex };
+        }
+        return null;
+    }
+    // check if hover result is from a hole
+    checkHole(typeDecl) {
+        // (type parameter) T in _<T>(): T
+        const holePattern = /(\(type parameter\) T in _\<T\>\(\): T)/;
+        const match = typeDecl.match(holePattern);
+        if (match) {
+            const typeName = "hole function";
+            const typeSpan = match[1];
+            return { identifier: typeName, span: typeSpan };
+        }
+        return null;
+    }
+    // check if hover result is from a parameter
+    checkParameter(typeDecl) {
+        // (parameter) name: type
+        // const parameterPattern = /(\(parameter\) )(.+)(: )(.+))/;
+        // const parameterMatch = typeDecl.match(parameterPattern);
+        // let parameterInterestingIndex = -1;
+        // if (parameterMatch) {
+        //   parameterInterestingIndex = indexOfRegexGroup(parameterMatch, 4);
+        // }
+        //
+        // if (parameterInterestingIndex != -1) {
+        //   const typeName = parameterMatch[2];
+        //   const typeSpan = parameterMatch[4];
+        //   return { typeName: typeName, typeSpan: typeSpan, interestingIndex: parameterInterestingIndex }
+        // }
+        return null;
+    }
+    isTuple(typeSpan) {
+        return typeSpan[0] === "[" && typeSpan[typeSpan.length - 1] === "]";
+    }
+    isUnion(typeSpan) {
+        return typeSpan.includes(" | ");
+    }
+    isArray(typeSpan) {
+        return typeSpan.slice(-2) === "[]";
+    }
+    isObject(typeSpan) {
+        return typeSpan[0] === "{" && typeSpan[typeSpan.length - 1] === "}";
+    }
+    // this is a very rudimentary check, so it should be expanded upon
+    isFunction(typeSpan) {
+        return typeSpan.includes("=>");
+    }
+    isPrimitive(typeSpan) {
+        const primitives = ["string", "number", "boolean"];
+        return primitives.includes(typeSpan);
+    }
+    isTypeAlias(typeSpan) {
+        const caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        return caps.includes(typeSpan[0]);
+    }
+    escapeQuotes(typeSpan) {
+        return typeSpan.replace(/"/g, `\\"`);
+    }
+    parseTypeArrayString(typeStr) {
+        // Remove all spaces
+        const cleaned = typeStr.replace(/\s/g, '');
+        // Remove the outermost square brackets
+        const inner = cleaned.slice(1, -1);
+        // const inner = cleaned.slice(-1) === ";" ? cleaned.slice(1, -2) : cleaned.slice(1, -1);
+        // Split the string, respecting nested structures
+        const result = [];
+        let currentItem = '';
+        let nestLevel = 0;
+        for (const char of inner) {
+            if (char === '[')
+                nestLevel++;
+            if (char === ']')
+                nestLevel--;
+            if (char === ',' && nestLevel === 0) {
+                // check if currentItem is a name: type pair or just type
+                if (currentItem.includes(":")) {
+                    result.push(currentItem.split(":")[1]);
+                }
+                else {
+                    result.push(currentItem);
+                }
+                currentItem = '';
+            }
+            else {
+                currentItem += char;
+            }
+        }
+        if (currentItem.includes(":")) {
+            result.push(currentItem.split(":")[1]);
+        }
+        else {
+            result.push(currentItem);
+        }
+        return result;
+    }
+    /* Version 2, using TypeScript Compiler API */
+    handleMembers(members, checker) {
+        return members.map(member => {
+            if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
+                const propertyType = member.type ? this.analyzeTypeNode(member.type, checker) : { kind: 'Any', text: 'any' };
+                return {
+                    kind: 'Property',
+                    text: member.getText(),
+                    constituents: [propertyType]
+                };
+            }
+            else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
+                const parameters = member.parameters.map(param => ({
+                    name: param.name.getText(),
+                    optional: !!param.questionToken,
+                    type: param.type ? this.analyzeTypeNode(param.type, checker) : { kind: 'Any', text: 'any' }
+                }));
+                const returnType = member.type ? this.analyzeTypeNode(member.type, checker) : { kind: 'Any', text: 'any' };
+                return {
+                    kind: 'Method',
+                    text: member.getText(),
+                    parameters,
+                    returnType
+                };
+            }
+            else {
+                return {
+                    kind: "Unknown",
+                    text: member.getText()
+                };
+            }
+        });
+    }
+    analyzeTypeNode(typeNode, checker) {
+        switch (typeNode.kind) {
+            case ts.SyntaxKind.NumericLiteral: {
+                return {
+                    kind: 'NumericLiteral',
+                    text: typeNode.getText(),
+                };
+            }
+            case ts.SyntaxKind.StringLiteral: {
+                return {
+                    kind: 'StringLiteral',
+                    text: typeNode.getText(),
+                };
+            }
+            case ts.SyntaxKind.FunctionType: {
+                const tn = typeNode;
+                return {
+                    kind: "Function",
+                    text: tn.getText(),
+                    parameters: tn.parameters.map(parameter => {
+                        return {
+                            name: parameter.name.getText(),
+                            optional: !!parameter.questionToken,
+                            type: parameter.type ? this.analyzeTypeNode(parameter.type, checker) : { kind: "Any", text: "any" }
+                        };
+                    }),
+                    returnType: tn.type ? this.analyzeTypeNode(tn.type, checker) : undefined
+                };
+            }
+            case ts.SyntaxKind.ArrayType: {
+                const tn = typeNode;
+                return {
+                    kind: 'Array',
+                    text: typeNode.getText(),
+                    constituents: [this.analyzeTypeNode(tn.elementType, checker)]
+                };
+            }
+            case ts.SyntaxKind.TupleType: {
+                const tn = typeNode;
+                const elements = tn.elements.map(element => {
+                    if (ts.isRestTypeNode(element)) {
+                        return {
+                            kind: 'RestElement',
+                            text: element.getText(),
+                            type: this.analyzeTypeNode(element.type, checker)
+                        };
+                    }
+                    else {
+                        return this.analyzeTypeNode(element, checker);
+                    }
+                });
+                return {
+                    kind: 'Tuple',
+                    text: typeNode.getText(),
+                    constituents: elements
+                };
+            }
+            case ts.SyntaxKind.UnionType: {
+                const tn = typeNode;
+                return {
+                    kind: "Union",
+                    text: tn.getText(),
+                    constituents: tn.types.map(typ => {
+                        return this.analyzeTypeNode(typ, checker);
+                    })
+                };
+            }
+            case ts.SyntaxKind.IntersectionType: {
+                const tn = typeNode;
+                return {
+                    kind: "Intersection",
+                    text: tn.getText(),
+                    constituents: tn.types.map(typ => {
+                        return this.analyzeTypeNode(typ, checker);
+                    })
+                };
+            }
+            case ts.SyntaxKind.TypeLiteral: {
+                const tn = typeNode;
+                return {
+                    kind: "Object",
+                    text: tn.getText(),
+                    constituents: this.handleMembers(tn.members, checker)
+                };
+            }
+            case ts.SyntaxKind.TypeReference: {
+                const tn = typeNode;
+                const symbol = checker.getSymbolAtLocation(tn.typeName);
+                let typeAliasAnalysis = { kind: 'TypeReference', text: typeNode.getText() };
+                if (symbol && symbol.declarations) {
+                    const declaration = symbol.declarations[0];
+                    if (ts.isTypeAliasDeclaration(declaration)) {
+                        const typeAlias = declaration;
+                        if (typeAlias.type) {
+                            typeAliasAnalysis = Object.assign(Object.assign({}, typeAliasAnalysis), { kind: `TypeReference of TypeAliasDeclaration`, constituents: [this.analyzeTypeNode(typeAlias.type, checker)] });
+                        }
+                    }
+                    else if (ts.isInterfaceDeclaration(declaration)) {
+                        const interfaceDecl = declaration;
+                        if (interfaceDecl.members) {
+                            typeAliasAnalysis = Object.assign(Object.assign({}, typeAliasAnalysis), { kind: `TypeReference of InterfaceDeclaration`, constituents: this.handleMembers(interfaceDecl.members, checker) });
+                        }
+                    }
+                    else if (ts.isClassDeclaration(declaration)) {
+                        const classDecl = declaration;
+                        if (classDecl.members) {
+                            typeAliasAnalysis = Object.assign(Object.assign({}, typeAliasAnalysis), { kind: `TypeReference of ClassDeclaration`, constituents: this.handleMembers(classDecl.members, checker) });
+                            if (classDecl.heritageClauses) {
+                                typeAliasAnalysis = Object.assign(Object.assign({}, typeAliasAnalysis), { heritage: classDecl.heritageClauses.map(heritageClause => {
+                                        return heritageClause.types.map(typ => {
+                                            return this.analyzeTypeNode(typ, checker);
+                                        });
+                                    }) });
+                            }
+                        }
+                    }
+                }
+                return typeAliasAnalysis;
+            }
+        }
+        return {
+            kind: ts.SyntaxKind[typeNode.kind],
+            text: typeNode.getText()
+        };
+    }
+    analyzeTypeString(typeString, program = this.createProgramFromSource("")) {
+        const sourceFile = ts.createSourceFile('temp.ts', `type T = ${typeString};`, ts.ScriptTarget.Latest, true);
+        let typeNode;
+        ts.forEachChild(sourceFile, node => {
+            if (ts.isTypeAliasDeclaration(node)) {
+                typeNode = node.type;
+            }
+        });
+        if (!typeNode) {
+            throw new Error('Failed to parse type string');
+        }
+        const checker = program.getTypeChecker();
+        return this.analyzeTypeNode(typeNode, checker);
+    }
+    createProgramFromSource(content) {
+        const fileName = 'test.ts';
+        const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+        const host = ts.createCompilerHost({});
+        host.getSourceFile = (fileName) => (fileName === 'test.ts' ? sourceFile : undefined);
+        const program = ts.createProgram([fileName], {}, host);
+        return program;
+    }
+    isPrimitive2(typeAnalysisResult) {
+        const re = /(.*)Keyword/;
+        return typeAnalysisResult.kind.match(re);
+    }
+    isFunction2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "Function";
+    }
+    isTuple2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "Tuple";
+    }
+    isObject2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "Object";
+    }
+    isUnion2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "Union";
+    }
+    isArray2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "Array";
+    }
+    isTypeAlias2(typeAnalysisResult) {
+        return typeAnalysisResult.kind === "TypeReference";
+    }
+}
+exports.TypeScriptTypeChecker = TypeScriptTypeChecker;

package/dist/utils.d.ts

@@ -0,0 +1,40 @@
+import { relevantTypeObject, varsObject, typesObject, typesQueryResult, varsQueryResult, relevantTypeQueryResult, typesAndLocationsQueryResult, Language } from "./types";
+declare const indexOfRegexGroup: (match: RegExpMatchArray, n: number) => number;
+declare const formatTypeSpan: (typeSpan: string) => string;
+declare const extractSnippet: (documentContent: string, start: {
+    line: number;
+    character: number;
+}, end: {
+    line: number;
+    character: number;
+}) => string;
+declare const isTuple: (typeSpan: string) => boolean;
+declare const isUnion: (typeSpan: string) => boolean;
+declare const isArray: (typeSpan: string) => boolean;
+declare const isObject: (typeSpan: string) => boolean;
+declare const isFunction: (typeSpan: string) => boolean;
+declare const isPrimitive: (typeSpan: string) => boolean;
+declare const isTypeAlias: (typeSpan: string) => boolean;
+declare const escapeQuotes: (typeSpan: string) => string;
+declare const parseTypeArrayString: (typeStr: string) => string[];
+declare const removeLines: (fileContent: string) => string[];
+declare const parseCodeQLRelevantTypes: (table: relevantTypeQueryResult) => Map<string, relevantTypeObject>;
+declare const parseCodeQLVars: (table: varsQueryResult) => Map<string, varsObject>;
+declare const parseCodeQLTypes: (table: typesQueryResult) => typesObject[];
+declare const parseCodeQLLocationsAndTypes: (table: typesAndLocationsQueryResult) => Map<string, string[]>;
+declare const parseCodeQLTypesAndLocations: (table: typesAndLocationsQueryResult) => Map<string, string>;
+declare const isQLFunction: (typeQLClass: string) => boolean;
+declare const isQLTuple: (typeQLClass: string) => boolean;
+declare const isQLUnion: (typeQLClass: string) => boolean;
+declare const isQLArray: (typeQLClass: string) => boolean;
+declare const isQLInterface: (typeQLClass: string) => boolean;
+declare const isQLLocalTypeAccess: (typeQLClass: string) => boolean;
+declare const isQLPredefined: (typeQLClass: string) => boolean;
+declare const isQLLiteral: (typeQLClass: string) => boolean;
+declare const isQLKeyword: (typeQLClass: string) => boolean;
+declare const isQLLabel: (typeQLClass: string) => boolean;
+declare const isQLIdentifier: (typeQLClass: string) => boolean;
+declare const supportsHole: (lang: Language) => boolean;
+declare const getAllTSFiles: (dirPath: string, arrayOfFiles?: string[]) => string[];
+declare const getAllOCamlFiles: (dirPath: string, arrayOfFiles?: string[]) => string[];
+export { indexOfRegexGroup, formatTypeSpan, extractSnippet, isTuple, isUnion, isArray, isObject, isFunction, isPrimitive, isTypeAlias, escapeQuotes, parseTypeArrayString, removeLines, parseCodeQLRelevantTypes, parseCodeQLVars, parseCodeQLTypes, parseCodeQLLocationsAndTypes, parseCodeQLTypesAndLocations, isQLFunction, isQLTuple, isQLUnion, isQLArray, isQLInterface, isQLLocalTypeAccess, isQLPredefined, isQLLiteral, isQLKeyword, isQLLabel, isQLIdentifier, supportsHole, getAllTSFiles, getAllOCamlFiles };