| import * as fs from 'fs'; |
| import * as ts from 'typescript'; |
| |
| |
| interface Const { |
| typeName: string // repeated in each const |
| goType: string |
| me: ts.Node |
| name: string // constant's name |
| value: string // constant's value |
| } |
| let Consts: Const[] = []; |
| let seenConstTypes = new Map<string, boolean>(); |
| |
| interface Struct { |
| me: ts.Node |
| name: string |
| embeds: string[] |
| fields?: Field[] |
| } |
| let Structs: Struct[] = []; |
| |
| interface Field { |
| me: ts.Node |
| id: ts.Identifier |
| goName: string |
| optional: boolean |
| goType: string |
| json: string |
| gostuff?: string |
| substruct?: Field[] // embedded struct from TypeLiteral |
| } |
| |
| interface Type { |
| me: ts.Node |
| goName: string |
| goType: string |
| stuff: string |
| } |
| let Types: Type[] = []; |
| |
| // Used in printing the AST |
| let seenThings = new Map<string, number>(); |
| function seenAdd(x: string) { |
| seenThings[x] = (seenThings[x] === undefined ? 1 : seenThings[x] + 1) |
| } |
| |
| let dir = process.env['HOME']; |
| let fnames = [ |
| `/vscode-languageserver-node/protocol/src/protocol.ts`, |
| `/vscode-languageserver-node/types/src/main.ts` |
| ]; |
| let outFname = '/tmp/tsprotocol.go'; |
| let fda: number, fdb: number, fde: number; // file descriptors |
| |
| function createOutputFiles() { |
| fda = fs.openSync('/tmp/ts-a', 'w') // dump of AST |
| fdb = fs.openSync('/tmp/ts-b', 'w') // unused, for debugging |
| fde = fs.openSync(outFname, 'w') // generated Go |
| } |
| function pra(s: string) { |
| return (fs.writeSync(fda, s)) |
| } |
| function prb(s: string) { |
| return (fs.writeSync(fdb, s)) |
| } |
| function prgo(s: string) { |
| return (fs.writeSync(fde, s)) |
| } |
| |
| function generate(files: string[], options: ts.CompilerOptions): void { |
| let program = ts.createProgram(files, options); |
| program.getTypeChecker(); // used for side-effects |
| |
| // dump the ast, for debugging |
| for (const sourceFile of program.getSourceFiles()) { |
| if (!sourceFile.isDeclarationFile) { |
| // walk the tree to do stuff |
| ts.forEachChild(sourceFile, describe); |
| } |
| } |
| pra('\n') |
| for (const key of Object.keys(seenThings).sort()) { |
| pra(`${key}: ${seenThings[key]}\n`) |
| } |
| |
| // visit every sourceFile in the program, generating types |
| for (const sourceFile of program.getSourceFiles()) { |
| if (!sourceFile.isDeclarationFile) { |
| ts.forEachChild(sourceFile, genTypes) |
| } |
| } |
| return; |
| |
| function genTypes(node: ts.Node) { |
| // Ignore top-level items with no output |
| if (ts.isExpressionStatement(node) || ts.isFunctionDeclaration(node) || |
| ts.isImportDeclaration(node) || ts.isVariableStatement(node) || |
| ts.isExportDeclaration(node) || |
| node.kind == ts.SyntaxKind.EndOfFileToken) { |
| return; |
| } |
| if (ts.isInterfaceDeclaration(node)) { |
| doInterface(node) |
| return; |
| } else if (ts.isTypeAliasDeclaration(node)) { |
| doTypeAlias(node) |
| } else if (ts.isModuleDeclaration(node)) { |
| doModuleDeclaration(node) |
| } else if (ts.isEnumDeclaration(node)) { |
| doEnumDecl(node) |
| } else if (ts.isClassDeclaration(node)) { |
| doClassDeclaration(node) |
| } else { |
| throw new Error(`unexpected ${ts.SyntaxKind[node.kind]} ${loc(node)}`) |
| } |
| } |
| |
| function doClassDeclaration(node: ts.ClassDeclaration) { |
| let id: ts.Identifier |
| let props = new Array<ts.PropertyDeclaration>() |
| let extend: ts.HeritageClause; |
| let bad = false |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n; |
| return |
| } |
| if (ts.isPropertyDeclaration(n)) { |
| props.push(n); |
| return |
| } |
| if (n.kind == ts.SyntaxKind.ExportKeyword) { |
| return |
| } |
| if (n.kind == ts.SyntaxKind.Constructor || ts.isMethodDeclaration(n) || |
| ts.isGetAccessor(n) || ts.isTypeParameterDeclaration(n)) { |
| bad = true; |
| return |
| } |
| if (ts.isHeritageClause(n)) { |
| extend = n; |
| return |
| } |
| throw new Error(`doClass ${loc(n)} ${kinds(n)}`) |
| }) |
| if (bad) { |
| // the class is not useful for Go. |
| return |
| } // might we want the PropertyDecls? (don't think so) |
| let fields: Field[] = []; |
| for (const pr of props) { |
| fields.push(fromPropDecl(pr)) |
| } |
| let ans = { |
| me: node, |
| name: toGoName(getText(id)), |
| embeds: heritageStrs(extend), |
| fields: fields |
| }; |
| Structs.push(ans) |
| } |
| |
| function fromPropDecl(node: ts.PropertyDeclaration): Field { |
| let id: ts.Identifier; |
| let opt = false |
| let typ: ts.Node |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n; |
| return |
| } |
| if (n.kind == ts.SyntaxKind.QuestionToken) { |
| opt = true; |
| return |
| } |
| if (typ != undefined) |
| throw new Error(`fromPropDecl too long ${loc(node)}`) |
| typ = n |
| }) |
| let goType = computeType(typ).goType |
| let ans = { |
| me: node, |
| id: id, |
| goName: toGoName(getText(id)), |
| optional: opt, |
| goType: goType, |
| json: `\`json:"${id.text}${opt ? ',omitempty' : ''}"\`` |
| }; |
| return ans |
| } |
| |
| function doInterface(node: ts.InterfaceDeclaration) { |
| // name: Identifier; |
| // typeParameters?: NodeArray<TypeParameterDeclaration>; |
| // heritageClauses?: NodeArray<HeritageClause>; |
| // members: NodeArray<TypeElement>; |
| |
| // find the Identifier from children |
| // process the PropertySignature children |
| // the members might have generic info, but so do the children |
| let id: ts.Identifier; |
| let extend: ts.HeritageClause |
| let generid: ts.Identifier |
| let properties = new Array<ts.PropertySignature>() |
| let index: ts.IndexSignatureDeclaration // generate some sort of map |
| node.forEachChild((n: ts.Node) => { |
| if (n.kind == ts.SyntaxKind.ExportKeyword || ts.isMethodSignature(n)) { |
| // ignore |
| } else if (ts.isIdentifier(n)) { |
| id = n; |
| } else if (ts.isHeritageClause(n)) { |
| extend = n; |
| } else if (ts.isTypeParameterDeclaration(n)) { |
| // Act as if this is <T = any> |
| generid = n.name; |
| } else if (ts.isPropertySignature(n)) { |
| properties.push(n); |
| } else if (ts.isIndexSignatureDeclaration(n)) { |
| if (index !== undefined) { |
| throw new Error(`${loc(n)} multiple index expressions`) |
| } |
| index = n |
| } else { |
| throw new Error(`${loc(n)} doInterface ${ts.SyntaxKind[n.kind]} `) |
| } |
| }) |
| let fields: Field[] = []; |
| for (const p of properties) { |
| fields.push(genProp(p, generid)) |
| } |
| if (index != undefined) { |
| fields.push(fromIndexSignature(index)) |
| } |
| const ans = { |
| me: node, |
| name: toGoName(getText(id)), |
| embeds: heritageStrs(extend), |
| fields: fields |
| }; |
| |
| Structs.push(ans) |
| } |
| |
| function heritageStrs(node: ts.HeritageClause): string[] { |
| // ExpressionWithTypeArguments+, and each is an Identifier |
| let ans: string[] = []; |
| if (node == undefined) { |
| return ans |
| } |
| let x: ts.ExpressionWithTypeArguments[] = [] |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isExpressionWithTypeArguments(n)) x.push(n) |
| }) |
| for (const p of x) { |
| p.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| ans.push(toGoName(getText(n))); |
| return; |
| } |
| if (ts.isTypeReferenceNode(n)) { |
| // don't want these, ignore them |
| return; |
| } |
| throw new Error(`expected Identifier ${loc(n)} ${kinds(p)} `) |
| }) |
| } |
| return ans |
| } |
| |
| function genProp(node: ts.PropertySignature, gen: ts.Identifier): Field { |
| let id: ts.Identifier |
| let thing: ts.Node |
| let opt = false |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n |
| } else if (n.kind == ts.SyntaxKind.QuestionToken) { |
| opt = true |
| } else if (n.kind == ts.SyntaxKind.ReadonlyKeyword) { |
| return |
| } else { |
| if (thing !== undefined) { |
| throw new Error(`${loc(n)} weird`) |
| } |
| thing = n |
| } |
| }) |
| let goName = toGoName(id.text) |
| let { goType, gostuff, optional, fields } = computeType(thing) |
| // Generics |
| if (gen && gen.text == goType) goType = 'interface{}'; |
| opt = opt || optional; |
| let ans = { |
| me: node, |
| id: id, |
| goName: goName, |
| optional: opt, |
| goType: goType, |
| gostuff: gostuff, |
| substruct: fields, |
| json: `\`json:"${id.text}${opt ? ',omitempty' : ''}"\`` |
| }; |
| // Rather than checking that goName is a const type, just do |
| switch (goType) { |
| case 'CompletionItemKind': |
| case 'TextDocumentSyncKind': |
| case 'CodeActionKind': |
| case 'InsertTextFormat': // float64 |
| case 'DiagnosticSeverity': |
| ans.optional = false |
| } |
| return ans |
| } |
| |
| function doModuleDeclaration(node: ts.ModuleDeclaration) { |
| // Export Identifier ModuleBlock |
| let id: ts.Identifier; |
| let mb: ts.ModuleBlock; |
| node.forEachChild((n: ts.Node) => { |
| if ((ts.isIdentifier(n) && (id = n)) || |
| (ts.isModuleBlock(n) && mb === undefined && (mb = n)) || |
| (n.kind == ts.SyntaxKind.ExportKeyword)) { |
| return; |
| } |
| throw new Error(`doModuleDecl ${loc(n)} ${ts.SyntaxKind[n.kind]}`) |
| }) |
| // Don't want FunctionDeclarations |
| // mb has VariableStatement and useless TypeAliasDeclaration |
| // some of the VariableStatement are consts, and want their comments |
| // and each VariableStatement is Export, VariableDeclarationList |
| // and each VariableDeclarationList is a single VariableDeclaration |
| let v: ts.VariableDeclaration[] = []; |
| function f(n: ts.Node) { |
| if (ts.isVariableDeclaration(n)) { |
| v.push(n); |
| return |
| } |
| if (ts.isFunctionDeclaration(n)) { |
| return |
| } |
| n.forEachChild(f) |
| } |
| f(node) |
| for (const vx of v) { |
| if (hasNewExpression(vx)) { |
| return |
| } |
| buildConst(getText(id), vx) |
| } |
| } |
| |
| function buildConst(tname: string, node: ts.VariableDeclaration): Const { |
| // node is Identifier, optional-goo, (FirstLiteralToken|StringLiteral) |
| let id: ts.Identifier |
| let str: string |
| let first: string |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n |
| } else if (ts.isStringLiteral(n)) { |
| str = getText(n) |
| } else if (n.kind == ts.SyntaxKind.FirstLiteralToken) { |
| first = getText(n) |
| } |
| }) |
| if (str == undefined && first == undefined) { |
| return |
| } // various |
| const ty = (str != undefined) ? 'string' : 'float64' |
| const val = (str != undefined) ? str.replace(/'/g, '"') : first |
| const name = toGoName(getText(id)) |
| const c = { |
| typeName: tname, |
| goType: ty, |
| me: node.parent.parent, |
| name: name, |
| value: val |
| }; |
| Consts.push(c) |
| return c |
| } |
| |
| // is node an ancestor of a NewExpression |
| function hasNewExpression(n: ts.Node): boolean { |
| let ans = false; |
| n.forEachChild((n: ts.Node) => { |
| if (ts.isNewExpression(n)) ans = true; |
| }) |
| return ans |
| } |
| |
| function doEnumDecl(node: ts.EnumDeclaration) { |
| // Generates Consts. Identifier EnumMember+ |
| // EnumMember: Identifier StringLiteral |
| let id: ts.Identifier |
| let mems: ts.EnumMember[] = [] |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n // check for uniqueness? |
| } else if (ts.isEnumMember(n)) { |
| mems.push(n) |
| } else if (n.kind != ts.SyntaxKind.ExportKeyword) { |
| throw new Error(`doEnumDecl ${ts.SyntaxKind[n.kind]} ${loc(n)}`) |
| } |
| }) |
| for (const m of mems) { |
| let name: string |
| let value: string |
| m.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| name = getText(n) |
| } else if (ts.isStringLiteral(n)) { |
| value = getText(n).replace(/'/g, '"') |
| } else { |
| throw new Error(`in doEnumDecl ${ts.SyntaxKind[n.kind]} ${loc(n)}`) |
| } |
| }) |
| let ans = { |
| typeName: getText(id), |
| goType: 'string', |
| me: m, |
| name: name, |
| value: value |
| }; |
| Consts.push(ans) |
| } |
| } |
| |
| // top-level TypeAlias |
| function doTypeAlias(node: ts.TypeAliasDeclaration) { |
| // these are all Export Identifier alias |
| let id: ts.Identifier; |
| let alias: ts.Node; |
| let genid: ts.TypeParameterDeclaration // <T>, but we don't care |
| node.forEachChild((n: ts.Node) => { |
| if ((ts.isIdentifier(n) && (id = n)) || |
| (n.kind == ts.SyntaxKind.ExportKeyword) || |
| ts.isTypeParameterDeclaration(n) && (genid = n) || |
| (alias === undefined && (alias = n))) { |
| return |
| } |
| throw new Error(`doTypeAlias ${loc(n)} ${ts.SyntaxKind[n.kind]}`) |
| }) |
| let ans = { |
| me: node, |
| id: id, |
| goName: toGoName(getText(id)), |
| goType: '?', |
| stuff: '' |
| }; |
| if (id.text.indexOf('--') != -1) { |
| return |
| } // don't care |
| if (ts.isUnionTypeNode(alias)) { |
| ans.goType = weirdUnionType(alias) |
| if (ans.goType == undefined) { // these are redundant |
| return |
| } |
| Types.push(ans) |
| return |
| } |
| if (ts.isIntersectionTypeNode(alias)) { // a Struct, not a Type |
| let embeds: string[] = [] |
| alias.forEachChild((n: ts.Node) => { |
| if (ts.isTypeReferenceNode(n)) { |
| embeds.push(toGoName(computeType(n).goType)) |
| } else |
| throw new Error(`expected TypeRef ${ts.SyntaxKind[n.kind]} ${loc(n)}`) |
| }) |
| let ans = { me: node, name: toGoName(getText(id)), embeds: embeds }; |
| Structs.push(ans) |
| return |
| } |
| if (ts.isArrayTypeNode(alias)) { // []DocumentFilter |
| ans.goType = '[]DocumentFilter'; |
| Types.push(ans) |
| return |
| } |
| if (ts.isLiteralTypeNode(alias)) { |
| return // type A = 1, so nope |
| } |
| if (ts.isTypeReferenceNode(alias)) { |
| ans.goType = computeType(alias).goType |
| if (ans.goType.match(/und/) != null) throw new Error('396') |
| Types.push(ans) // type A B |
| return |
| } |
| if (alias.kind == ts.SyntaxKind.StringKeyword) { // type A string |
| ans.goType = 'string'; |
| Types.push(ans); |
| return |
| } |
| throw new Error(`in doTypeAlias ${loc(node)} ${kinds(node)} ${ |
| ts.SyntaxKind[alias.kind]}\n`) |
| } |
| |
| // extract the one useful but weird case () |
| function weirdUnionType(node: ts.UnionTypeNode): string { |
| let bad = false |
| let tl: ts.TypeLiteralNode[] = [] |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isTypeLiteralNode(n)) { |
| tl.push(n) |
| } else |
| bad = true |
| }) |
| if (bad) return // none of these are useful (so far) |
| let x = computeType(tl[0]) |
| x.fields[0].json = x.fields[0].json.replace(/"`/, ',omitempty"`') |
| let out: string[] = []; |
| for (const f of x.fields) { |
| out.push(strField(f)) |
| } |
| out.push('}\n') |
| let ans = 'struct {\n'.concat(...out); |
| return ans |
| } |
| |
| function computeType(node: ts.Node): { goType: string, gostuff?: string, optional?: boolean, fields?: Field[] } { |
| switch (node.kind) { |
| case ts.SyntaxKind.AnyKeyword: |
| case ts.SyntaxKind.ObjectKeyword: |
| return { goType: 'interface{}' }; |
| case ts.SyntaxKind.BooleanKeyword: |
| return { goType: 'bool' }; |
| case ts.SyntaxKind.NumberKeyword: |
| return { goType: 'float64' }; |
| case ts.SyntaxKind.StringKeyword: |
| return { goType: 'string' }; |
| case ts.SyntaxKind.NullKeyword: |
| case ts.SyntaxKind.UndefinedKeyword: |
| return { goType: 'nil' }; |
| } |
| if (ts.isArrayTypeNode(node)) { |
| let { goType, gostuff, optional } = computeType(node.elementType) |
| return ({ goType: '[]' + goType, gostuff: gostuff, optional: optional }) |
| } else if (ts.isTypeReferenceNode(node)) { |
| // typeArguments?: NodeArray<TypeNode>;typeName: EntityName; |
| // typeArguments won't show up in the generated Go |
| // EntityName: Identifier|QualifiedName |
| let tn: ts.EntityName = node.typeName; |
| if (ts.isQualifiedName(tn)) { |
| throw new Error(`qualified name at ${loc(node)}`); |
| } else if (ts.isIdentifier(tn)) { |
| return { goType: tn.text }; |
| } else { |
| throw new Error(`expected identifier got ${ |
| ts.SyntaxKind[node.typeName.kind]} at ${loc(tn)}`) |
| } |
| } else if (ts.isLiteralTypeNode(node)) { |
| // string|float64 (are there other possibilities?) |
| const txt = getText(node); |
| let typ = 'float64' |
| if (txt.charAt(0) == '\'') { |
| typ = 'string' |
| } |
| return { goType: typ, gostuff: getText(node) }; |
| } else if (ts.isTypeLiteralNode(node)) { |
| let x: Field[] = []; |
| let indexCnt = 0 |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isPropertySignature(n)) { |
| x.push(genProp(n, undefined)) |
| return |
| } else if (ts.isIndexSignatureDeclaration(n)) { |
| indexCnt++ |
| x.push(fromIndexSignature(n)) |
| return |
| } |
| throw new Error( |
| `${loc(n)} gotype ${ts.SyntaxKind[n.kind]}, not expected`) |
| }); |
| if (indexCnt > 0) { |
| if (indexCnt != 1 || x.length != 1) |
| throw new Error(`undexpected Index ${loc(x[0].me)}`) |
| // instead of {map...} just the map |
| return ({ goType: x[0].goType, gostuff: x[0].gostuff }) |
| } |
| return ({ goType: 'embedded!', fields: x }) |
| } else if (ts.isUnionTypeNode(node)) { |
| let x = new Array<{ goType: string, gostuff?: string, optiona?: boolean }>() |
| node.forEachChild((n: ts.Node) => { x.push(computeType(n)) }) |
| if (x.length == 2 && x[1].goType == 'nil') { |
| return x[0] // make it optional somehow? TODO |
| } |
| if (x[0].goType == 'bool') { // take it |
| return ({ goType: 'bool', gostuff: getText(node) }) |
| } |
| // these are special cases from looking at the source |
| let gostuff = getText(node); |
| if (x[0].goType == `"off"` || x[0].goType == 'string') { |
| return ({ goType: 'string', gostuff: gostuff }) |
| } |
| if (x[0].goType == 'TextDocumentSyncOptions') { |
| return ({ goType: 'interface{}', gostuff: gostuff }) |
| } |
| if (x[0].goType == 'float64' && x[1].goType == 'string') { |
| return { |
| goType: 'interface{}', gostuff: gostuff |
| } |
| } |
| if (x[0].goType == 'MarkupContent' && x[1].goType == 'MarkedString') { |
| return { |
| goType: 'MarkupContent', gostuff: gostuff |
| } |
| } |
| // Fail loudly |
| console.log(`UnionType ${loc(node)}`) |
| for (const v of x) { |
| console.log(`${v.goType}`) |
| } |
| throw new Error('in UnionType, weird') |
| } else if (ts.isParenthesizedTypeNode(node)) { |
| // check that this is (TextDocumentEdit | CreateFile | RenameFile | |
| // DeleteFile) |
| return { |
| goType: 'TextDocumentEdit', gostuff: getText(node) |
| } |
| } else if (ts.isTupleTypeNode(node)) { |
| // string | [number, number] |
| return { |
| goType: 'string', gostuff: getText(node) |
| } |
| } |
| throw new Error(`unknown ${ts.SyntaxKind[node.kind]} at ${loc(node)}`) |
| } |
| |
| function fromIndexSignature(node: ts.IndexSignatureDeclaration): Field { |
| let parm: ts.ParameterDeclaration |
| let at: ts.Node |
| node.forEachChild((n: ts.Node) => { |
| if (ts.isParameter(n)) { |
| parm = n |
| } else if ( |
| ts.isArrayTypeNode(n) || n.kind == ts.SyntaxKind.AnyKeyword || |
| ts.isUnionTypeNode(n)) { |
| at = n |
| } else |
| throw new Error(`fromIndexSig ${ts.SyntaxKind[n.kind]} ${loc(n)}`) |
| }) |
| let goType = computeType(at).goType |
| let id: ts.Identifier |
| parm.forEachChild((n: ts.Node) => { |
| if (ts.isIdentifier(n)) { |
| id = n |
| } else if (n.kind != ts.SyntaxKind.StringKeyword) { |
| throw new Error( |
| `fromIndexSig expected string, ${ts.SyntaxKind[n.kind]} ${loc(n)}`) |
| } |
| }) |
| goType = `map[string]${goType}` |
| return { |
| me: node, goName: toGoName(id.text), id: null, goType: goType, |
| optional: false, json: `\`json:"${id.text}"\``, |
| gostuff: `${getText(node)}` |
| } |
| } |
| |
| function toGoName(s: string): string { |
| let ans = s |
| if (s.charAt(0) == '_') { |
| ans = 'Inner' + s.substring(1) |
| } |
| else { ans = s.substring(0, 1).toUpperCase() + s.substring(1) }; |
| ans = ans.replace(/Uri$/, 'URI') |
| ans = ans.replace(/Id$/, 'ID') |
| return ans |
| } |
| |
| |
| // find the text of a node |
| function getText(node: ts.Node): string { |
| let sf = node.getSourceFile(); |
| let start = node.getStart(sf) |
| let end = node.getEnd() |
| return sf.text.substring(start, end) |
| } |
| // return a string of the kinds of the immediate descendants |
| function kinds(n: ts.Node): string { |
| let res = 'Seen ' + ts.SyntaxKind[n.kind]; |
| function f(n: ts.Node): void { res += ' ' + ts.SyntaxKind[n.kind] }; |
| ts.forEachChild(n, f) |
| return res |
| } |
| |
| function describe(node: ts.Node) { |
| if (node === undefined) { |
| return |
| } |
| let indent = ''; |
| |
| function f(n: ts.Node) { |
| seenAdd(kinds(n)) |
| if (ts.isIdentifier(n)) { |
| pra(`${indent} ${loc(n)} ${ts.SyntaxKind[n.kind]} ${n.text}\n`) |
| } |
| else if (ts.isPropertySignature(n) || ts.isEnumMember(n)) { |
| pra(`${indent} ${loc(n)} ${ts.SyntaxKind[n.kind]}\n`) |
| } |
| else if (ts.isTypeLiteralNode(n)) { |
| let m = n.members |
| pra(`${indent} ${loc(n)} ${ts.SyntaxKind[n.kind]} ${m.length}\n`) |
| } |
| else { pra(`${indent} ${loc(n)} ${ts.SyntaxKind[n.kind]}\n`) }; |
| indent += ' ' |
| ts.forEachChild(n, f) |
| indent = indent.slice(0, indent.length - 2) |
| } |
| f(node) |
| } |
| |
| |
| function loc(node: ts.Node): string { |
| const sf = node.getSourceFile() |
| const start = node.getStart() |
| const x = sf.getLineAndCharacterOfPosition(start) |
| const full = node.getFullStart() |
| const y = sf.getLineAndCharacterOfPosition(full) |
| let fn = sf.fileName |
| const n = fn.search(/-node./) |
| fn = fn.substring(n + 6) |
| return `${fn} ${x.line + 1}:${x.character + 1} (${y.line + 1}:${ |
| y.character + 1})` |
| } |
| } |
| |
| function getComments(node: ts.Node): string { |
| const sf = node.getSourceFile(); |
| const start = node.getStart(sf, false) |
| const starta = node.getStart(sf, true) |
| const x = sf.text.substring(starta, start) |
| return x |
| } |
| |
| function emitTypes() { |
| for (const t of Types) { |
| if (t.goName == 'CodeActionKind') continue; // consts better choice |
| let stuff = (t.stuff == undefined) ? '' : t.stuff; |
| prgo(`// ${t.goName} is a type\n`) |
| prgo(`${getComments(t.me)}`) |
| prgo(`type ${t.goName} ${t.goType}${stuff}\n`) |
| } |
| } |
| |
| function emitStructs() { |
| let seenName = new Map<string, boolean>() |
| for (const str of Structs) { |
| if (str.name == 'InitializeError') { |
| // only want the consts |
| continue |
| } |
| if (seenName[str.name]) { |
| continue |
| } |
| seenName[str.name] = true |
| prgo(genComments(str.name, getComments(str.me))) |
| /* prgo(`// ${str.name} is:\n`) |
| prgo(getComments(str.me))*/ |
| prgo(`type ${str.name} struct {\n`) |
| for (const s of str.embeds) { |
| prgo(`\t${s}\n`) |
| } |
| if (str.fields != undefined) { |
| for (const f of str.fields) { |
| prgo(strField(f)) |
| } |
| } |
| prgo(`}\n`) |
| } |
| } |
| |
| function genComments(name: string, maybe: string): string { |
| if (maybe == '') return `\n\t// ${name} is\n`; |
| if (maybe.indexOf('/**') == 0) { |
| return maybe.replace('/**', `\n/*${name} defined:`) |
| } |
| throw new Error(`weird comment ${maybe.indexOf('/**')}`) |
| } |
| |
| // Turn a Field into an output string |
| function strField(f: Field): string { |
| let ans: string[] = []; |
| let opt = f.optional ? '*' : '' |
| switch (f.goType.charAt(0)) { |
| case 's': // string |
| case 'b': // bool |
| case 'f': // float64 |
| case 'i': // interface{} |
| case '[': // []foo |
| opt = '' |
| } |
| let stuff = (f.gostuff == undefined) ? '' : ` // ${f.gostuff}` |
| ans.push(genComments(f.goName, getComments(f.me))) |
| if (f.substruct == undefined) { |
| ans.push(`\t${f.goName} ${opt}${f.goType} ${f.json}${stuff}\n`) |
| } |
| else { |
| ans.push(`\t${f.goName} ${opt}struct {\n`) |
| for (const x of f.substruct) { |
| ans.push(strField(x)) |
| } |
| ans.push(`\t} ${f.json}${stuff}\n`) |
| } |
| return (''.concat(...ans)) |
| } |
| |
| function emitConsts() { |
| // Generate modifying prefixes and suffixes to ensure consts are |
| // unique. (Go consts are package-level, but Typescript's are not.) |
| // Use suffixes to minimize changes to gopls. |
| let pref = new Map<string, string>( |
| [['DiagnosticSeverity', 'Severity']]) // typeName->prefix |
| let suff = new Map<string, string>([ |
| ['CompletionItemKind', 'Completion'], ['InsertTextFormat', 'TextFormat'] |
| ]) |
| for (const c of Consts) { |
| if (seenConstTypes[c.typeName]) { |
| continue |
| } |
| seenConstTypes[c.typeName] = true |
| if (pref.get(c.typeName) == undefined) { |
| pref.set(c.typeName, '') // initialize to empty value |
| } |
| if (suff.get(c.typeName) == undefined) { |
| suff.set(c.typeName, '') |
| } |
| prgo(`// ${c.typeName} defines constants\n`) |
| prgo(`type ${c.typeName} ${c.goType}\n`) |
| } |
| prgo('const (\n') |
| let seenConsts = new Map<string, boolean>() // to avoid duplicates |
| for (const c of Consts) { |
| const x = `${pref.get(c.typeName)}${c.name}${suff.get(c.typeName)}` |
| if (seenConsts.get(x)) { |
| continue |
| } |
| seenConsts.set(x, true) |
| prgo(genComments(x, getComments(c.me))) |
| prgo(`\t${x} ${c.typeName} = ${c.value}\n`) |
| } |
| prgo(')\n') |
| } |
| |
| function emitHeader(files: string[]) { |
| let lastMod = 0 |
| let lastDate: Date |
| for (const f of files) { |
| const st = fs.statSync(f) |
| if (st.mtimeMs > lastMod) { |
| lastMod = st.mtimeMs |
| lastDate = st.mtime |
| } |
| } |
| prgo(`// Package protocol contains data types for LSP jsonrpcs\n`) |
| prgo(`// generated automatically from vscode-languageserver-node |
| // version of ${lastDate}\n`) |
| prgo('package protocol\n\n') |
| }; |
| |
| // ad hoc argument parsing: [-d dir] [-o outputfile], and order matters |
| function main() { |
| let args = process.argv.slice(2) // effective command line |
| if (args.length > 0) { |
| let j = 0; |
| if (args[j] == '-d') { |
| dir = args[j + 1] |
| j += 2 |
| } |
| if (args[j] == '-o') { |
| outFname = args[j + 1] |
| j += 2 |
| } |
| if (j != args.length) throw new Error(`incomprehensible args ${args}`) |
| } |
| let files: string[] = []; |
| for (let i = 0; i < fnames.length; i++) { |
| files.push(`${dir}${fnames[i]}`) |
| } |
| createOutputFiles() |
| generate( |
| files, { target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS }); |
| emitHeader(files) |
| emitStructs() |
| emitConsts() |
| emitTypes() |
| } |
| |
| main() |
