protocol/typescript/go.ts

import * as fs from 'fs';
import * as ts from 'typescript';

// Need a general strategy for union types. This code tries (heuristically)
// to choose one, but sometimes defaults (heuristically) to interface{}
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[];
  extends?: string[]
}
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'];
const srcDir = '/vscode-languageserver-node'
let fnames = [
  `${srcDir}/protocol/src/protocol.ts`, `${srcDir}/types/src/main.ts`,
  `${srcDir}/jsonrpc/src/main.ts`
];
let gitHash = 'fda16d6b63ba0fbdbd21d437ea810685528a0018';
let outFname = '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))
}

// struct names that don't need to go in the output
let dontEmit = new Map<string, boolean>();

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 that produce no output
    if (ts.isExpressionStatement(node) || ts.isFunctionDeclaration(node) ||
      ts.isImportDeclaration(node) || ts.isVariableStatement(node) ||
      ts.isExportDeclaration(node) || ts.isEmptyStatement(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 ${strKind(node)} ${loc(node)}`)
    }
  }

  function doClassDeclaration(node: ts.ClassDeclaration) {
    let id: ts.Identifier = node.name;
    let props = new Array<ts.PropertyDeclaration>()
    let extend: ts.HeritageClause;
    let bad = false
    node.forEachChild((n: ts.Node) => {
      if (ts.isIdentifier(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.isSetAccessor(n) ||
        ts.isTypeParameterDeclaration(n)) {
        bad = true;
        return
      }
      if (ts.isHeritageClause(n)) {
        return
      }
      if (n.kind == ts.SyntaxKind.AbstractKeyword) {
        bad = true;  // we think all of these are useless, but are unsure
        return;
      }
      throw new Error(`doClass ${loc(n)} ${kinds(n)}`)
    })
    if (bad) {
      // the class is not useful for Go.
      return
    }
    let fields: Field[] = [];
    for (const pr of props) {
      fields.push(fromPropDecl(pr))
    }
    let ans = {
      me: node,
      name: toGoName(getText(id)),
      extends: heritageStrs(extend),
      fields: fields
    };
    Structs.push(ans)
  }

  // called only from doClassDeclaration
  function fromPropDecl(node: ts.PropertyDeclaration): Field {
    let id: ts.Identifier = (ts.isIdentifier(node.name) && node.name);
    let opt = node.questionToken != undefined;
    let typ: ts.Node = node.type;
    const computed = computeType(typ);
    let goType = computed.goType
    let ans = {
      me: node,
      id: id,
      goName: toGoName(getText(id)),
      optional: opt,
      goType: goType,
      json: `\`json:"${id.text}${opt ? ',omitempty' : ''}"\``,
      substruct: computed.fields
    };
    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 = node.name
    let extend: ts.HeritageClause
    let generid: ts.Identifier
    let properties = new Array<ts.PropertySignature>()
    let index: ts.IndexSignatureDeclaration  // generate some sort of map
    let bad = false;  // maybe we don't care about this one at all
    node.forEachChild((n: ts.Node) => {
      if (n.kind == ts.SyntaxKind.ExportKeyword || ts.isMethodSignature(n)) {
        // ignore
      } else if (ts.isIdentifier(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 if (n.kind == ts.SyntaxKind.CallSignature) {
        bad = true;
      } else {
        throw new Error(`${loc(n)} doInterface ${strKind(n)} `)
      }
    })
    if (bad) return;
    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)),
      extends: 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
  }

  // optional gen is the contents of <T>
  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' : ''}"\``
    };
    // These are not structs, so '*' would be wrong.
    switch (goType) {
      case 'CompletionItemKind':
      case 'TextDocumentSyncKind':
      case 'CodeActionKind':
      case 'FailureHandlingKind':  // string
      case 'InsertTextFormat':     // float64
      case 'DiagnosticSeverity':
        ans.optional = false
    }
    return ans
  }

  function doModuleDeclaration(node: ts.ModuleDeclaration) {
    // Export Identifier ModuleBlock
    let id: ts.Identifier = (ts.isIdentifier(node.name) && node.name);
    // Don't want FunctionDeclarations
    // 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 = (ts.isIdentifier(node.name) && node.name);
    let str: string
    let first: string
    node.forEachChild((n: ts.Node) => {
      if (ts.isStringLiteral(n)) {
        str = getText(n)
      } else if (n.kind == ts.SyntaxKind.NumericLiteral) {
        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 = node.name
    let mems = node.members
    let theType = 'string';
    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 if (ts.isNumericLiteral(n)) {
          value = getText(n);
          theType = 'float64';
        } else {
          throw new Error(`in doEnumDecl ${strKind(n)} ${loc(n)}`)
        }
      })
      let ans = {
        typeName: getText(id),
        goType: theType,
        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 = node.name;
    let alias: ts.TypeNode = node.type;
    let ans = {
      me: node,
      id: id,
      goName: toGoName(getText(id)),
      goType: '?',  // filled in later in this function
      stuff: ''
    };
    if (ts.isUnionTypeNode(alias)) {
      ans.goType = weirdUnionType(alias)
      if (ans.goType == undefined) {
        // these are mostly redundant; maybe sort them out later
        return
      }
      if (ans.goType == 'interface{}') {
        // we didn't know what to do, so explain the choice
        ans.stuff = `// ` + getText(alias)
      }
      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)) {
          const s = toGoName(computeType(n).goType)
          embeds.push(s)
          // It's here just for embedding, and not used independently, maybe
          // PJW!
          // dontEmit.set(s, true); // PJW: do we need this?
        } else
          throw new Error(`expected TypeRef ${strKind(n)} ${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.isTypeLiteralNode(alias)) {
      return;  // type A = {...}
    }
    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(alias)} ${kinds(node)}: ${strKind(alias)}\n`)
  }

  // string, or number, or DocumentFilter
  function weirdUnionType(node: ts.UnionTypeNode): string {
    let bad = false;
    let aNumber = false;
    let aString = false;
    let tl: ts.TypeLiteralNode[] = []
    node.forEachChild((n: ts.Node) => {
      if (ts.isTypeLiteralNode(n)) {
        tl.push(n);
        return;
      }
      if (ts.isLiteralTypeNode(n)) {
        n.literal.kind == ts.SyntaxKind.NumericLiteral ? aNumber = true :
          aString = true;
        return;
      }
      if (n.kind == ts.SyntaxKind.NumberKeyword ||
        n.kind == ts.SyntaxKind.StringKeyword) {
        n.kind == ts.SyntaxKind.NumberKeyword ? aNumber = true : aString = true;
        return
      }
      bad = true
    })
    if (bad) return;  // none of these are useful (so far)
    if (aNumber) {
      if (aString) return 'interface{}';
      return 'float64';
    }
    if (aString) return 'string';
    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
  }

  // complex and filled with heuristics
  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: toGoName(tn.text) };
      } else {
        throw new Error(
          `expected identifier got ${strKind(node.typeName)} at ${loc(tn)}`)
      }
    } else if (ts.isLiteralTypeNode(node)) {
      // string|float64 (are there other possibilities?)
      // as of 20190908: only see string
      const txt = getText(node);
      let typ = 'float64'
      if (txt.charAt(0) == '\'') {
        typ = 'string'
      }
      return { goType: typ, gostuff: getText(node) };
    } else if (ts.isTypeLiteralNode(node)) {
      // {[uri:string]: TextEdit[];} -> map[string][]TextEdit
      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 ${strKind(n)}, 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)) {
      // The major heuristics
      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') {
        // Foo | null, or Foo | undefined
        return x[0]  // make it optional somehow? TODO
      }
      if (x[0].goType == 'bool') {  // take it, mostly
        if (x[1].goType == 'RenameOptions' ||
          x[1].goType == 'CodeActionOptions') {
          return ({ goType: 'interface{}', gostuff: getText(node) })
        }
        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') {
        // TextDocumentSyncOptions | TextDocumentSyncKind
        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
        }
      }
      if (x[0].goType == 'RequestMessage' && x[1].goType == 'ResponseMessage') {
        return {
          goType: 'interface{}', 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) TODO(pjw) IT IS NOT! FIX THIS! ALSO:
      // (variousOptions & StaticFegistrationOptions)
      return {
        goType: 'TextDocumentEdit', gostuff: getText(node)
      }
    } else if (ts.isTupleTypeNode(node)) {
      // in string | [number, number]. TODO(pjw): check it really is
      return {
        goType: 'string', gostuff: getText(node)
      }
    } else if (ts.isFunctionTypeNode(node)) {
      // we don't want these members; mark them
      return {
        goType: 'bad', gostuff: getText(node)
      }
    }
    throw new Error(`computeType unknown ${strKind(node)} 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 ${strKind(n)} ${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, ${strKind(n)} ${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 ' + strKind(n);
    function f(n: ts.Node): void { res += ' ' + strKind(n) };
    ts.forEachChild(n, f)
    return res
  }

  function strKind(n: ts.Node): string {
    const x = ts.SyntaxKind[n.kind];
    // some of these have two names
    switch (x) {
      default:
        return x;
      case 'FirstAssignment':
        return 'EqualsToken';
      case 'FirstBinaryOperator':
        return 'LessThanToken';
      case 'FirstCompoundAssignment':
        return 'PlusEqualsToken';
      case 'FirstContextualKeyword':
        return 'AbstractKeyword';
      case 'FirstLiteralToken':
        return 'NumericLiteral';
      case 'FirstNode':
        return 'QualifiedName';
      case 'FirstTemplateToken':
        return 'NoSubstitutionTemplateLiteral';
      case 'LastTemplateToken':
        return 'TemplateTail';
      case 'FirstTypeNode':
        return 'TypePredicate';
    }
  }

  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)} ${strKind(n)} ${n.text}\n`)
      }
      else if (ts.isPropertySignature(n) || ts.isEnumMember(n)) {
        pra(`${indent} ${loc(n)} ${strKind(n)}\n`)
      }
      else if (ts.isTypeLiteralNode(n)) {
        let m = n.members
        pra(`${indent} ${loc(n)} ${strKind(n)} ${m.length}\n`)
      }
      else { pra(`${indent} ${loc(n)} ${strKind(n)}\n`) };
      indent += '  '
      ts.forEachChild(n, f)
      indent = indent.slice(0, indent.length - 2)
    }
    f(node)
  }
}

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 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 emitTypes() {
  seenConstTypes.set('MessageQueue', true);  // skip
  for (const t of Types) {
    if (seenConstTypes.get(t.goName)) continue;
    if (t.goName == 'CodeActionKind') continue;  // consts better choice
    if (t.goType === undefined) continue;
    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`)
    seenConstTypes.set(t.goName, true);
  }
}

let byName = new Map<string, Struct>();
function emitStructs() {
  dontEmit.set('Thenable', true);
  dontEmit.set('EmitterOptions', true);
  dontEmit.set('MessageReader', true);
  dontEmit.set('MessageWriter', true);
  dontEmit.set('CancellationToken', true);
  dontEmit.set('PipeTransport', true);
  dontEmit.set('SocketTransport', true);
  dontEmit.set('Item', true);
  dontEmit.set('Event', true);
  dontEmit.set('Logger', true);
  dontEmit.set('Disposable', true);
  dontEmit.set('PartialMessageInfo', true);
  dontEmit.set('MessageConnection', true);
  dontEmit.set('ResponsePromise', true);
  dontEmit.set('ResponseMessage', true);
  dontEmit.set('ErrorMessage', true);
  dontEmit.set('NotificationMessage', true);
  dontEmit.set('RequestHandlerElement', true);
  dontEmit.set('RequestMessage', true);
  dontEmit.set('NotificationHandlerElement', true);
  dontEmit.set('Message', true);  // duplicate of jsonrpc2:wire.go
  dontEmit.set('LSPLogMessage', true);
  dontEmit.set('InnerEM', true);
  dontEmit.set('ResponseErrorLiteral', true);
  dontEmit.set('TraceOptions', true);
  dontEmit.set('MessageType', true);  // want the enum
  // backwards compatibility, done in requests.ts:
  dontEmit.set('CancelParams', true);

  for (const str of Structs) {
    byName.set(str.name, str)
  }
  let seenName = new Map<string, boolean>()
  for (const str of Structs) {
    if (str.name == 'InitializeError') {
      // only want its consts, not the struct
      continue
    }
    if (seenName.get(str.name) || dontEmit.get(str.name)) {
      continue
    }
    let noopt = false;
    seenName.set(str.name, true)
    prgo(genComments(str.name, getComments(str.me)))
    prgo(`type ${str.name} struct {\n`)
    // if it has fields, generate them
    if (str.fields != undefined) {
      for (const f of str.fields) {
        prgo(strField(f, noopt))
      }
    }
    if (str.extends) {
      // ResourceOperation just repeats the Kind field
      for (const s of str.extends) {
        if (s != 'ResourceOperation')
          prgo(`\t${s}\n`)  // what this type extends.
      }
    } else if (str.embeds) {
      prb(`embeds: ${str.name}\n`);
      noopt = (str.name == 'ClientCapabilities');
      // embedded struct. the hard case is from intersection types,
      // where fields with the same name have to be combined into
      // a single struct
      let fields = new Map<string, Field[]>();
      for (const e of str.embeds) {
        const nm = byName.get(e);
        if (nm.embeds) throw new Error(`${nm.name} is an embedded embed`);
        // each of these fields might be a something that needs amalgamating
        for (const f of nm.fields) {
          let x = fields.get(f.goName);
          if (x === undefined) x = [];
          x.push(f);
          fields.set(f.goName, x);
        }
      }
      fields.forEach((val, key) => {
        if (val.length > 1) {
          // merge the fields with the same name
          prgo(strField(val[0], noopt, val));
        } else {
          prgo(strField(val[0], noopt));
        }
      });
    }
    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
// flds is for merging
function strField(f: Field, noopt?: boolean, flds?: Field[]): string {
  let ans: string[] = [];
  let opt = (!noopt && 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 (flds === undefined && f.substruct == undefined) {
    ans.push(`\t${f.goName} ${opt}${f.goType} ${f.json}${stuff}\n`)
  }
  else if (flds !== undefined) {
    // The logic that got us here is imprecise, so it is possible that
    // the fields are really all the same, and don't need to be
    // combined into a struct.
    let simple = true;
    for (const ff of flds) {
      if (ff.substruct !== undefined || byName.get(ff.goType) !== undefined) {
        simple = false
        break
      }
    }
    if (simple) {
      // should check that the ffs are really all the same
      return strField(flds[0], noopt)
    }
    ans.push(`\t${f.goName} ${opt}struct{\n`);
    for (const ff of flds) {
      if (ff.substruct !== undefined) {
        for (const x of ff.substruct) {
          ans.push(strField(x, noopt))
        }
      } else if (byName.get(ff.goType) !== undefined) {
        const st = byName.get(ff.goType);
        for (let i = 0; i < st.fields.length; i++) {
          ans.push(strField(st.fields[i], noopt))
        }
      } else {
        ans.push(strField(ff, noopt));
      }
    }
    ans.push(`\t} ${f.json}${stuff}\n`);
  }
  else {
    ans.push(`\t${f.goName} ${opt}struct {\n`)
    for (const x of f.substruct) {
      ans.push(strField(x, noopt))
    }
    ans.push(`\t} ${f.json}${stuff}\n`)
  }
  return (''.concat(...ans))
}

function emitConsts() {
  // need the consts too! 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'], ['WatchKind', 'Watch']
  ])  // typeName->prefix
  let suff = new Map<string, string>([
    ['CompletionItemKind', 'Completion'], ['InsertTextFormat', 'TextFormat']
  ])
  for (const c of Consts) {
    if (seenConstTypes.get(c.typeName)) {
      continue
    }
    seenConstTypes.set(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)
    if (c.value === undefined) continue;      // didn't figure it out
    if (x.startsWith('undefined')) continue;  // what's going on here?
    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
    }
  }
  let a = fs.readFileSync(`${dir}${srcDir}/.git/refs/heads/master`);
  prgo(`// Package protocol contains data types and code for LSP jsonrpcs\n`)
  prgo(`// generated automatically from vscode-languageserver-node\n`)
  prgo(`// commit: ${gitHash}\n`)
  prgo(`// last fetched ${lastDate}\n`)
  prgo('package protocol\n\n')
  prgo(`// Code generated (see typescript/README.md) DO NOT EDIT.\n`);
};

function git(): string {
  let a = fs.readFileSync(`${dir}${srcDir}/.git/HEAD`).toString();
  // ref: refs/heads/foo, or a hash like cc12d1a1c7df935012cdef5d085cdba04a7c8ebe
  if (a.charAt(a.length - 1) == '\n') {
    a = a.substring(0, a.length - 1);
  }
  if (a.length == 40) {
    return a // a hash
  }
  if (a.substring(0, 5) == 'ref: ') {
    const fname = `${dir}${srcDir}/.git/` + a.substring(5);
    let b = fs.readFileSync(fname).toString()
    if (b.length == 41) {
      return b.substring(0, 40);
    }
  }
  throw new Error("failed to find the git commit hash")
}

// ad hoc argument parsing: [-d dir] [-o outputfile], and order matters
function main() {
  if (gitHash != git()) {
    throw new Error(`git hash mismatch, wanted\n${gitHash} but source is at\n${git()}`)
  }
  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()