@jpoly1219/context-extractor 0.2.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,286 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.OcamlTypeChecker = void 0;
4
+ const utils_1 = require("./utils");
5
+ class OcamlTypeChecker {
6
+ getIdentifierFromDecl(typeDecl) {
7
+ const declRe = /(type )(.+)( =)(.*)/;
8
+ const match = typeDecl.match(declRe);
9
+ if (!match)
10
+ return "";
11
+ return match[2];
12
+ }
13
+ getTypeContextFromDecl(typeDecl) {
14
+ if (this.checkHole(typeDecl)) {
15
+ return this.checkHole(typeDecl);
16
+ }
17
+ else if (this.checkParameter(typeDecl)) {
18
+ return this.checkParameter(typeDecl);
19
+ }
20
+ else if (this.checkFunction(typeDecl)) {
21
+ return this.checkFunction(typeDecl);
22
+ }
23
+ else if (this.checkUnion(typeDecl)) {
24
+ return this.checkUnion(typeDecl);
25
+ }
26
+ else if (this.checkObject(typeDecl)) {
27
+ return this.checkObject(typeDecl);
28
+ }
29
+ else if (this.checkImports(typeDecl)) {
30
+ return this.checkImports(typeDecl);
31
+ }
32
+ else if (this.checkModule(typeDecl)) {
33
+ return this.checkModule(typeDecl);
34
+ }
35
+ else {
36
+ return this.checkPrimitive(typeDecl);
37
+ }
38
+ }
39
+ // pattern matching
40
+ // attempts to match strings to corresponding types, then returns an object containing the name, type span, and an interesting index
41
+ // base case - type can no longer be stepped into
42
+ // boolean, number, string, enum, unknown, any, void, null, undefined, never
43
+ // ideally this should be checked for before we do the for loop
44
+ // return typeSpan;
45
+ // check if hover result is from a primitive type
46
+ checkPrimitive(typeDecl) {
47
+ // type _ = boolean
48
+ const primitivePattern = /(type )(.+)( = )(.+)/;
49
+ const primitiveMatch = typeDecl.match(primitivePattern);
50
+ let primitiveInterestingIndex = -1;
51
+ if (primitiveMatch) {
52
+ primitiveInterestingIndex = (0, utils_1.indexOfRegexGroup)(primitiveMatch, 4);
53
+ }
54
+ if (primitiveInterestingIndex != -1) {
55
+ const typeName = primitiveMatch[2];
56
+ const typeSpan = primitiveMatch[4];
57
+ return { identifier: typeName, span: typeSpan, interestingIndex: primitiveInterestingIndex };
58
+ }
59
+ return null;
60
+ }
61
+ // check if hover result is from an import
62
+ checkImports(typeDecl) {
63
+ // import { _, _ };
64
+ const importPattern = /(import )(\{.+\})/;
65
+ const importMatch = typeDecl.match(importPattern);
66
+ let importInterestingIndex = -1;
67
+ if (importMatch) {
68
+ importInterestingIndex = (0, utils_1.indexOfRegexGroup)(importMatch, 2);
69
+ }
70
+ // import _;
71
+ const defaultImportPattern = /(import )(.+)/;
72
+ const defaultImportMatch = typeDecl.match(defaultImportPattern);
73
+ let defaultImportInterestingIndex = -1;
74
+ if (defaultImportMatch) {
75
+ defaultImportInterestingIndex = (0, utils_1.indexOfRegexGroup)(defaultImportMatch, 2);
76
+ }
77
+ if (importInterestingIndex != -1) {
78
+ const typeName = importMatch[2];
79
+ const typeSpan = importMatch[2];
80
+ return { identifier: typeName, span: typeSpan, interestingIndex: importInterestingIndex };
81
+ }
82
+ else if (defaultImportInterestingIndex != -1) {
83
+ const typeName = defaultImportMatch[2];
84
+ const typeSpan = defaultImportMatch[2];
85
+ return { identifier: typeName, span: typeSpan, interestingIndex: defaultImportInterestingIndex };
86
+ }
87
+ return null;
88
+ }
89
+ // check if hover result is from a module
90
+ checkModule(typeDecl) {
91
+ // module "path/to/module"
92
+ const modulePattern = /(module )(.+)/;
93
+ const moduleMatch = typeDecl.match(modulePattern);
94
+ let moduleInterestingIndex = -1;
95
+ if (moduleMatch) {
96
+ moduleInterestingIndex = (0, utils_1.indexOfRegexGroup)(moduleMatch, 2);
97
+ }
98
+ if (moduleInterestingIndex != -1) {
99
+ const typeName = moduleMatch[2];
100
+ const typeSpan = moduleMatch[2];
101
+ return { identifier: typeName, span: typeSpan, interestingIndex: moduleInterestingIndex };
102
+ }
103
+ return null;
104
+ }
105
+ // check if hover result is from an object
106
+ checkObject(typeDecl) {
107
+ // type _ = {
108
+ // _: t1;
109
+ // _: t2;
110
+ // }
111
+ const objectTypeDefPattern = /(type )(.+)( = )(\{.+\})/;
112
+ const objectTypeDefMatch = typeDecl.match(objectTypeDefPattern);
113
+ let objectTypeDefInterestingIndex = -1;
114
+ if (objectTypeDefMatch) {
115
+ objectTypeDefInterestingIndex = (0, utils_1.indexOfRegexGroup)(objectTypeDefMatch, 4);
116
+ }
117
+ if (objectTypeDefInterestingIndex != -1) {
118
+ const typeName = objectTypeDefMatch[2];
119
+ const typeSpan = objectTypeDefMatch[4];
120
+ return { identifier: typeName, span: typeSpan, interestingIndex: objectTypeDefInterestingIndex };
121
+ }
122
+ return null;
123
+ }
124
+ // check if hover result is from a union
125
+ checkUnion(typeDecl) {
126
+ // type _ = A | B | C
127
+ const unionPattern = /(type )(.+)( = )((.+ | )+.+)/;
128
+ const unionMatch = typeDecl.match(unionPattern);
129
+ let unionInterestingIndex = -1;
130
+ if (unionMatch) {
131
+ unionInterestingIndex = (0, utils_1.indexOfRegexGroup)(unionMatch, 4);
132
+ }
133
+ if (unionInterestingIndex != -1) {
134
+ const typeName = unionMatch[2];
135
+ const typeSpan = unionMatch[4];
136
+ return { identifier: typeName, span: typeSpan, interestingIndex: unionInterestingIndex };
137
+ }
138
+ return null;
139
+ }
140
+ // check if hover result is from a function
141
+ checkFunction(typeDecl) {
142
+ // const myFunc : (arg1: typ1, ...) => _
143
+ const es6AnnotatedFunctionPattern = /(const )(.+)(: )(\(.+\) => .+)/;
144
+ const es6AnnotatedFunctionMatch = typeDecl.match(es6AnnotatedFunctionPattern);
145
+ let es6AnnotatedFunctionInterestingIndex = -1;
146
+ if (es6AnnotatedFunctionMatch) {
147
+ es6AnnotatedFunctionInterestingIndex = (0, utils_1.indexOfRegexGroup)(es6AnnotatedFunctionMatch, 4);
148
+ }
149
+ // type _ = (_: t1) => t2
150
+ const es6FunctionTypeDefPattern = /(type )(.+)( = )(\(.+\) => .+)/;
151
+ const es6FunctionTypeDefPatternMatch = typeDecl.match(es6FunctionTypeDefPattern);
152
+ let es6FunctionTypeDefInterestingIndex = -1;
153
+ if (es6FunctionTypeDefPatternMatch) {
154
+ es6FunctionTypeDefInterestingIndex = (0, utils_1.indexOfRegexGroup)(es6FunctionTypeDefPatternMatch, 4);
155
+ }
156
+ // function myFunc<T>(args: types, genarg: T): returntype
157
+ const genericFunctionTypePattern = /(function )(.+)(\<.+\>\(.*\))(: )(.+)/;
158
+ const genericFunctionTypeMatch = typeDecl.match(genericFunctionTypePattern);
159
+ let genericFunctionTypeInterestingIndex = -1;
160
+ if (genericFunctionTypeMatch) {
161
+ genericFunctionTypeInterestingIndex = (0, utils_1.indexOfRegexGroup)(genericFunctionTypeMatch, 3);
162
+ }
163
+ // function myFunc(args: types): returntype
164
+ const functionTypePattern = /(function )(.+)(\(.*\))(: )(.+)/;
165
+ const functionTypeMatch = typeDecl.match(functionTypePattern);
166
+ let functionTypeInterestingIndex = -1;
167
+ if (functionTypeMatch) {
168
+ functionTypeInterestingIndex = (0, utils_1.indexOfRegexGroup)(functionTypeMatch, 3);
169
+ }
170
+ if (es6AnnotatedFunctionInterestingIndex != -1) {
171
+ const typeName = es6AnnotatedFunctionMatch[2];
172
+ const typeSpan = es6AnnotatedFunctionMatch[4];
173
+ return { identifier: typeName, span: typeSpan, interestingIndex: es6AnnotatedFunctionInterestingIndex };
174
+ }
175
+ else if (es6FunctionTypeDefInterestingIndex != -1) {
176
+ const typeName = es6FunctionTypeDefPatternMatch[2];
177
+ const typeSpan = es6FunctionTypeDefPatternMatch[4];
178
+ return { identifier: typeName, span: typeSpan, interestingIndex: es6FunctionTypeDefInterestingIndex };
179
+ }
180
+ else if (genericFunctionTypeInterestingIndex != -1) {
181
+ const typeName = genericFunctionTypeMatch[2];
182
+ const typeSpan = genericFunctionTypeMatch[3] + genericFunctionTypeMatch[4] + genericFunctionTypeMatch[5];
183
+ return { identifier: typeName, span: typeSpan, interestingIndex: genericFunctionTypeInterestingIndex };
184
+ }
185
+ else if (functionTypeInterestingIndex != -1) {
186
+ const typeName = functionTypeMatch[2];
187
+ const typeSpan = functionTypeMatch[3] + functionTypeMatch[4] + functionTypeMatch[5];
188
+ return { identifier: typeName, span: typeSpan, interestingIndex: functionTypeInterestingIndex };
189
+ }
190
+ return null;
191
+ }
192
+ // check if hover result is from a hole
193
+ checkHole(typeDecl) {
194
+ // (type parameter) T in _<T>(): T
195
+ const holePattern = /(\(type parameter\) T in _\<T\>\(\): T)/;
196
+ const match = typeDecl.match(holePattern);
197
+ if (match) {
198
+ const typeName = "hole function";
199
+ const typeSpan = match[1];
200
+ return { identifier: typeName, span: typeSpan };
201
+ }
202
+ return null;
203
+ }
204
+ // check if hover result is from a parameter
205
+ checkParameter(typeDecl) {
206
+ // (parameter) name: type
207
+ // const parameterPattern = /(\(parameter\) )(.+)(: )(.+))/;
208
+ // const parameterMatch = typeDecl.match(parameterPattern);
209
+ // let parameterInterestingIndex = -1;
210
+ // if (parameterMatch) {
211
+ // parameterInterestingIndex = indexOfRegexGroup(parameterMatch, 4);
212
+ // }
213
+ //
214
+ // if (parameterInterestingIndex != -1) {
215
+ // const typeName = parameterMatch[2];
216
+ // const typeSpan = parameterMatch[4];
217
+ // return { typeName: typeName, typeSpan: typeSpan, interestingIndex: parameterInterestingIndex }
218
+ // }
219
+ return null;
220
+ }
221
+ isTuple(typeSpan) {
222
+ return typeSpan[0] === "[" && typeSpan[typeSpan.length - 1] === "]";
223
+ }
224
+ isUnion(typeSpan) {
225
+ return typeSpan.includes(" | ");
226
+ }
227
+ isArray(typeSpan) {
228
+ return typeSpan.slice(-2) === "[]";
229
+ }
230
+ isObject(typeSpan) {
231
+ return typeSpan[0] === "{" && typeSpan[typeSpan.length - 1] === "}";
232
+ }
233
+ // this is a very rudimentary check, so it should be expanded upon
234
+ isFunction(typeSpan) {
235
+ return typeSpan.includes("=>");
236
+ }
237
+ isPrimitive(typeSpan) {
238
+ const primitives = ["string", "number", "boolean"];
239
+ return primitives.includes(typeSpan);
240
+ }
241
+ isTypeAlias(typeSpan) {
242
+ const caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
243
+ return caps.includes(typeSpan[0]);
244
+ }
245
+ escapeQuotes(typeSpan) {
246
+ return typeSpan.replace(/"/g, `\\"`);
247
+ }
248
+ parseTypeArrayString(typeStr) {
249
+ // Remove all spaces
250
+ const cleaned = typeStr.replace(/\s/g, '');
251
+ // Remove the outermost square brackets
252
+ const inner = cleaned.slice(1, -1);
253
+ // const inner = cleaned.slice(-1) === ";" ? cleaned.slice(1, -2) : cleaned.slice(1, -1);
254
+ // Split the string, respecting nested structures
255
+ const result = [];
256
+ let currentItem = '';
257
+ let nestLevel = 0;
258
+ for (const char of inner) {
259
+ if (char === '[')
260
+ nestLevel++;
261
+ if (char === ']')
262
+ nestLevel--;
263
+ if (char === ',' && nestLevel === 0) {
264
+ // check if currentItem is a name: type pair or just type
265
+ if (currentItem.includes(":")) {
266
+ result.push(currentItem.split(":")[1]);
267
+ }
268
+ else {
269
+ result.push(currentItem);
270
+ }
271
+ currentItem = '';
272
+ }
273
+ else {
274
+ currentItem += char;
275
+ }
276
+ }
277
+ if (currentItem.includes(":")) {
278
+ result.push(currentItem.split(":")[1]);
279
+ }
280
+ else {
281
+ result.push(currentItem);
282
+ }
283
+ return result;
284
+ }
285
+ }
286
+ exports.OcamlTypeChecker = OcamlTypeChecker;
@@ -0,0 +1 @@
1
+ export {};
package/dist/runner.js ADDED
@@ -0,0 +1,52 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ const main_1 = require("./main");
4
+ const types_1 = require("./types");
5
+ // extract("/home/jacob/projects/context-extractor/targets/todo/sketch.ts").then(r => console.log("todo\n", r));
6
+ // extract("/home/jacob/projects/context-extractor/targets/playlist/sketch.ts").then(r => console.log("playlist\n", r));
7
+ // extract("/home/jacob/projects/context-extractor/targets/passwords/sketch.ts").then(r => console.log("passwords\n", r));
8
+ // extract("/home/jacob/projects/context-extractor/targets/booking/sketch.ts").then(r => console.log("booking\n", r));
9
+ // extract("/home/jacob/projects/context-extractor/targets/emojipaint/sketch.ts").then(r => console.log("emojipaint\n", r));
10
+ (async () => {
11
+ try {
12
+ const x = await (0, main_1.extractContext)(types_1.Language.TypeScript, "/home/jacob/projects/context-extractor/targets/todo/sketch.ts", "/home/jacob/projects/context-extractor/targets/todo/");
13
+ console.dir(x, { depth: null });
14
+ // const y = await completeWithLLM(
15
+ // x!,
16
+ // Language.TypeScript,
17
+ // "/home/jacob/projects/context-extractor/targets/todo/sketch.ts",
18
+ // "/home/jacob/projects/context-extractor/credentials.json"
19
+ // )
20
+ //
21
+ // console.dir(y)
22
+ // const y = await extractContext(
23
+ // Language.OCaml,
24
+ // "/home/jacob/projects/context-extractor/targets/ocaml/todo/sketch.ml",
25
+ // "/home/jacob/projects/context-extractor/targets/ocaml/todo/",
26
+ // "/home/jacob/projects/context-extractor/config.json"
27
+ // );
28
+ // console.dir(y, { depth: null })
29
+ }
30
+ catch (err) {
31
+ console.log("top level err: ", err);
32
+ }
33
+ finally {
34
+ // Debug active handles if the app doesn't terminate
35
+ // if ((process as any)._getActiveHandles().length > 0) {
36
+ // // console.log(`${(process as any)._getActiveHandles().length} active handles detected:`);
37
+ // // console.log((process as any)._getActiveHandles());
38
+ // console.log(`${(process as any)._getActiveHandles().length} active handles detected.`);
39
+ // }
40
+ // process.exit(0);
41
+ }
42
+ })();
43
+ // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/playlist/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("playlist\n", r));
44
+ // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/passwords/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("passwords\n", r));
45
+ // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("booking\n", r));
46
+ // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/emojipaint/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("emojipaint\n", r));
47
+ // extractWithNew(Language.OCaml, "/home/jacob/projects/context-extractor/targets/ocaml/todo/sketch.ml", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("todo\n", r));
48
+ // extractWithNew(Language.OCaml, "/home/jacob/projects/context-extractor/targets/ocaml/playlist/sketch.ml", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("playlist\n", r));
49
+ // extractWithNew(Language.OCaml, "/home/jacob/projects/context-extractor/targets/ocaml/passwords/sketch.ml", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("passwords\n", r));
50
+ // extractWithNew(Language.OCaml, "/home/jacob/projects/context-extractor/targets/ocaml/booking/sketch.ml", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("booking\n", r));
51
+ // extractWithNew(Language.OCaml, "/home/jacob/projects/context-extractor/targets/ocaml/emojipaint/sketch.ml", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("emojipaint\n", r));
52
+ // extractWithNew(Language.TypeScript, "/app/targets/todo/sketch.ts").then(r => console.log("todo\n", r));
@@ -0,0 +1,135 @@
1
+ import { LspClient } from "../ts-lsp-client-dist/src/lspClient";
2
+ import { Range } from "../ts-lsp-client-dist/src/models";
3
+ interface relevantTypeObject {
4
+ typeAliasDeclaration: string;
5
+ typeName: string;
6
+ typeDefinition: string;
7
+ typeQLClass: string;
8
+ components: typesObject[];
9
+ }
10
+ interface varsObject {
11
+ constDeclaration: string;
12
+ bindingPattern: string;
13
+ typeAnnotation: string;
14
+ init: string;
15
+ typeQLClass: string;
16
+ functionReturnType: string;
17
+ functionReturnTypeQLClass: string;
18
+ components: typesObject[];
19
+ }
20
+ interface typesObject {
21
+ typeName: string;
22
+ typeQLClass: string;
23
+ }
24
+ interface typeAndLocation {
25
+ typeName: string;
26
+ locatedFile: string;
27
+ }
28
+ interface relevantTypeQueryResult {
29
+ "#select": {
30
+ tuples: [{
31
+ label: string;
32
+ }, string, {
33
+ label: string;
34
+ }, string, {
35
+ label: string;
36
+ }, string][];
37
+ };
38
+ }
39
+ interface varsQueryResult {
40
+ "#select": {
41
+ tuples: [{
42
+ label: string;
43
+ }, {
44
+ label: string;
45
+ }, {
46
+ label: string;
47
+ }, {
48
+ label: string;
49
+ }, string, string, string, {
50
+ label: string;
51
+ }, string][];
52
+ };
53
+ }
54
+ interface typesQueryResult {
55
+ "#select": {
56
+ tuples: [string, string, number][];
57
+ };
58
+ }
59
+ interface typesAndLocationsQueryResult {
60
+ "#select": {
61
+ tuples: [string, string][];
62
+ };
63
+ }
64
+ interface LanguageDriver {
65
+ init: (lspClient: LspClient, sketchPath: string) => Promise<void>;
66
+ getHoleContext: (lspClient: LspClient, sketchFilePath: string) => Promise<{
67
+ fullHoverResult: string;
68
+ functionName: string;
69
+ functionTypeSpan: string;
70
+ linePosition: number;
71
+ characterPosition: number;
72
+ holeTypeDefLinePos: number;
73
+ holeTypeDefCharPos: number;
74
+ range: Range;
75
+ source: string;
76
+ }>;
77
+ extractRelevantTypes: (lspClient: LspClient, fullHoverResult: string, typeName: string, startLine: number, endLine: number, foundSoFar: Map<string, TypeSpanAndSourceFile>, currentFile: string) => Promise<Map<string, TypeSpanAndSourceFile>>;
78
+ extractRelevantHeaders: (lspClient: LspClient, sources: string[], relevantTypes: Map<string, TypeSpanAndSourceFile>, holeType: string) => Promise<Set<TypeSpanAndSourceFile>>;
79
+ }
80
+ type Filepath = string;
81
+ type RelevantType = string;
82
+ type RelevantHeader = string;
83
+ interface Context {
84
+ holeType: string;
85
+ relevantTypes: Map<Filepath, RelevantType[]>;
86
+ relevantHeaders: Map<Filepath, RelevantHeader[]>;
87
+ }
88
+ declare enum Language {
89
+ TypeScript = 0,
90
+ OCaml = 1
91
+ }
92
+ interface TypeChecker {
93
+ getTypeContextFromDecl: (typeDecl: string) => {
94
+ identifier: string;
95
+ span: string;
96
+ } | null;
97
+ }
98
+ interface TypeSpanAndSourceFile {
99
+ typeSpan: string;
100
+ sourceFile: string;
101
+ }
102
+ declare enum Model {
103
+ None = 0,
104
+ GPT4 = "gpt4",
105
+ Starcoder2 = "starcoder2"
106
+ }
107
+ interface LLMConfig {
108
+ model: Model;
109
+ }
110
+ interface GPT4Config extends LLMConfig {
111
+ apiBase: string;
112
+ deployment: string;
113
+ gptModel: string;
114
+ apiVersion: string;
115
+ apiKey: string;
116
+ temperature: number;
117
+ }
118
+ interface GPT4PromptComponent {
119
+ role: string;
120
+ content: string;
121
+ }
122
+ interface TypeAnalysis {
123
+ kind: string;
124
+ text: string;
125
+ constituents?: TypeAnalysis[];
126
+ parameters?: ParameterAnalysis[];
127
+ returnType?: TypeAnalysis;
128
+ heritage?: TypeAnalysis[][];
129
+ }
130
+ interface ParameterAnalysis {
131
+ name: string;
132
+ optional: boolean;
133
+ type: TypeAnalysis;
134
+ }
135
+ export { relevantTypeObject, varsObject, typesObject, typeAndLocation, relevantTypeQueryResult, varsQueryResult, typesQueryResult, typesAndLocationsQueryResult, LanguageDriver, Language, TypeChecker, TypeSpanAndSourceFile, Context, Model, LLMConfig, GPT4Config, GPT4PromptComponent, TypeAnalysis, ParameterAnalysis };
package/dist/types.js ADDED
@@ -0,0 +1,14 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.Model = exports.Language = void 0;
4
+ var Language;
5
+ (function (Language) {
6
+ Language[Language["TypeScript"] = 0] = "TypeScript";
7
+ Language[Language["OCaml"] = 1] = "OCaml";
8
+ })(Language || (exports.Language = Language = {}));
9
+ var Model;
10
+ (function (Model) {
11
+ Model[Model["None"] = 0] = "None";
12
+ Model["GPT4"] = "gpt4";
13
+ Model["Starcoder2"] = "starcoder2";
14
+ })(Model || (exports.Model = Model = {}));
@@ -0,0 +1,27 @@
1
+ import { LspClient, Range } from "../ts-lsp-client-dist/src/main";
2
+ import { LanguageDriver, TypeSpanAndSourceFile } from "./types";
3
+ import { TypeScriptTypeChecker } from "./typescript-type-checker";
4
+ export declare class TypeScriptDriver implements LanguageDriver {
5
+ typeChecker: TypeScriptTypeChecker;
6
+ init(lspClient: LspClient, sketchPath: string): Promise<void>;
7
+ getHoleContext(lspClient: LspClient, sketchFilePath: string): Promise<{
8
+ fullHoverResult: string;
9
+ functionName: string;
10
+ functionTypeSpan: string;
11
+ linePosition: number;
12
+ characterPosition: number;
13
+ holeTypeDefLinePos: number;
14
+ holeTypeDefCharPos: number;
15
+ range: Range;
16
+ source: string;
17
+ }>;
18
+ extractRelevantTypes(lspClient: LspClient, fullHoverResult: string, typeName: string, startLine: number, endLine: number, foundSoFar: Map<string, TypeSpanAndSourceFile>, // identifier -> [full hover result, source]
19
+ currentFile: string): Promise<Map<string, TypeSpanAndSourceFile>>;
20
+ extractRelevantHeaders(_: LspClient, sources: string[], relevantTypes: Map<string, TypeSpanAndSourceFile>, holeType: string): Promise<Set<TypeSpanAndSourceFile>>;
21
+ generateTargetTypes(relevantTypes: Map<string, TypeSpanAndSourceFile>, holeType: string): Set<string>;
22
+ generateTargetTypesHelper(relevantTypes: Map<string, TypeSpanAndSourceFile>, currType: string, targetTypes: Set<string>): void;
23
+ extractRelevantHeadersHelper(typeSpan: string, targetTypes: Set<string>, relevantTypes: Map<string, TypeSpanAndSourceFile>, relevantContext: Set<TypeSpanAndSourceFile>, line: string, source: string): void;
24
+ isTypeEquivalent(t1: string, t2: string, relevantTypes: Map<string, TypeSpanAndSourceFile>): boolean;
25
+ normalize(typeSpan: string, relevantTypes: Map<string, TypeSpanAndSourceFile>): string;
26
+ normalize2(typeSpan: string, relevantTypes: Map<string, TypeSpanAndSourceFile>): string;
27
+ }