* Enable '--strictNullChecks' * Fix API baselines * Make sys.getEnvironmentVariable non-nullable * make properties optional instead of using `| undefined` in thier type * reportDiagnostics should be required * Declare firstAccessor as non-nullable * Make `some` a type guard * Fix `getEnvironmentVariable` definition in tests * Pretend transformFlags are always defined * Fix one more use of sys.getEnvironmentVariable * `requiredResponse` accepts undefined, remove assertions * Mark optional properties as optional instead of using `| undefined` * Mark optional properties as optional instead of using ` | undefined` * Remove unnecessary null assertions * Put the bang on the declaration instead of every use * Make `createMapFromTemplate` require a parameter * Mark `EmitResult.emittedFiles` and `EmitResult.sourceMaps` as optional * Plumb through undefined in emitLsit and EmitExpressionList * `ElementAccessExpression.argumentExpression` can not be `undefined` * Add overloads for `writeTokenText` * Make `shouldWriteSeparatingLineTerminator` argument non-nullable * Make `synthesizedNodeStartsOnNewLine` argument required * `PropertyAssignment.initializer` cannot be undefined * Use one `!` at declaration site instead of on every use site * Capture host in a constant and avoid null assertions * Remove few more unused assertions * Update baselines * Use parameter defaults * Update baselines * Fix lint * Make Symbol#valueDeclaration and Symbol#declarations non-optional to reduce assertions * Make Node#symbol and Type#symbol non-optional to reduce assertions * Make `flags` non-nullable to reduce assertions * Convert some asserts to type guards * Make `isNonLocalAlias` a type guard * Add overload for `getSymbolOfNode` for `Declaration` * Some more `getSymbolOfNode` changes * Push undefined suppression into `typeToTypeNodeHelper` * `NodeBuilderContext.tracker` is never `undefined` * use `Debug.assertDefined` * Remove unnecessary tag * Mark `LiteralType.freshType` and `LiteralTupe.regularType` as required
194 lines
8.4 KiB
TypeScript
194 lines
8.4 KiB
TypeScript
/// <reference types="node"/>
|
|
|
|
import * as ts from "../lib/typescript";
|
|
import * as path from "path";
|
|
|
|
function endsWith(s: string, suffix: string) {
|
|
return s.lastIndexOf(suffix, s.length - suffix.length) !== -1;
|
|
}
|
|
|
|
function isStringEnum(declaration: ts.EnumDeclaration) {
|
|
return declaration.members.length && declaration.members.every(m => !!m.initializer && m.initializer.kind === ts.SyntaxKind.StringLiteral);
|
|
}
|
|
|
|
class DeclarationsWalker {
|
|
private visitedTypes: ts.Type[] = [];
|
|
private text = "";
|
|
private removedTypes: ts.Type[] = [];
|
|
|
|
private constructor(private typeChecker: ts.TypeChecker, private protocolFile: ts.SourceFile) {
|
|
}
|
|
|
|
static getExtraDeclarations(typeChecker: ts.TypeChecker, protocolFile: ts.SourceFile): string {
|
|
let text = "declare namespace ts.server.protocol {\n";
|
|
var walker = new DeclarationsWalker(typeChecker, protocolFile);
|
|
walker.visitTypeNodes(protocolFile);
|
|
text = walker.text
|
|
? `declare namespace ts.server.protocol {\n${walker.text}}`
|
|
: "";
|
|
if (walker.removedTypes) {
|
|
text += "\ndeclare namespace ts {\n";
|
|
text += " // these types are empty stubs for types from services and should not be used directly\n"
|
|
for (const type of walker.removedTypes) {
|
|
text += ` export type ${type.symbol!.name} = never;\n`;
|
|
}
|
|
text += "}"
|
|
}
|
|
return text;
|
|
}
|
|
|
|
private processType(type: ts.Type): void {
|
|
if (this.visitedTypes.indexOf(type) >= 0) {
|
|
return;
|
|
}
|
|
this.visitedTypes.push(type);
|
|
let s = type.aliasSymbol || type.getSymbol();
|
|
if (!s) {
|
|
return;
|
|
}
|
|
if (s.name === "Array") {
|
|
// we should process type argument instead
|
|
return this.processType((<any>type).typeArguments[0]);
|
|
}
|
|
else {
|
|
const declarations = s.getDeclarations();
|
|
if (declarations) {
|
|
for (const decl of declarations) {
|
|
const sourceFile = decl.getSourceFile();
|
|
if (sourceFile === this.protocolFile || path.basename(sourceFile.fileName) === "lib.d.ts") {
|
|
return;
|
|
}
|
|
if (decl.kind === ts.SyntaxKind.EnumDeclaration && !isStringEnum(decl as ts.EnumDeclaration)) {
|
|
this.removedTypes.push(type);
|
|
return;
|
|
}
|
|
else {
|
|
// splice declaration in final d.ts file
|
|
let text = decl.getFullText();
|
|
this.text += `${text}\n`;
|
|
// recursively pull all dependencies into result dts file
|
|
|
|
this.visitTypeNodes(decl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private visitTypeNodes(node: ts.Node) {
|
|
if (node.parent) {
|
|
switch (node.parent.kind) {
|
|
case ts.SyntaxKind.VariableDeclaration:
|
|
case ts.SyntaxKind.MethodDeclaration:
|
|
case ts.SyntaxKind.MethodSignature:
|
|
case ts.SyntaxKind.PropertyDeclaration:
|
|
case ts.SyntaxKind.PropertySignature:
|
|
case ts.SyntaxKind.Parameter:
|
|
case ts.SyntaxKind.IndexSignature:
|
|
if (((<ts.VariableDeclaration | ts.MethodDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.PropertySignature | ts.MethodSignature | ts.IndexSignatureDeclaration>node.parent).type) === node) {
|
|
this.processTypeOfNode(node);
|
|
}
|
|
break;
|
|
case ts.SyntaxKind.InterfaceDeclaration:
|
|
const heritageClauses = (<ts.InterfaceDeclaration>node.parent).heritageClauses;
|
|
if (heritageClauses) {
|
|
if (heritageClauses[0].token !== ts.SyntaxKind.ExtendsKeyword) {
|
|
throw new Error(`Unexpected kind of heritage clause: ${ts.SyntaxKind[heritageClauses[0].kind]}`);
|
|
}
|
|
for (const type of heritageClauses[0].types) {
|
|
this.processTypeOfNode(type);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ts.forEachChild(node, n => this.visitTypeNodes(n));
|
|
}
|
|
|
|
private processTypeOfNode(node: ts.Node): void {
|
|
if (node.kind === ts.SyntaxKind.UnionType) {
|
|
for (const t of (<ts.UnionTypeNode>node).types) {
|
|
this.processTypeOfNode(t);
|
|
}
|
|
}
|
|
else {
|
|
const type = this.typeChecker.getTypeAtLocation(node);
|
|
if (type && !(type.flags & (ts.TypeFlags.TypeParameter))) {
|
|
this.processType(type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function writeProtocolFile(outputFile: string, protocolTs: string, typeScriptServicesDts: string) {
|
|
const options = { target: ts.ScriptTarget.ES5, declaration: true, noResolve: true, types: <string[]>[], stripInternal: true };
|
|
|
|
/**
|
|
* 1st pass - generate a program from protocol.ts and typescriptservices.d.ts and emit core version of protocol.d.ts with all internal members stripped
|
|
* @return text of protocol.d.t.s
|
|
*/
|
|
function getInitialDtsFileForProtocol() {
|
|
const program = ts.createProgram([protocolTs, typeScriptServicesDts], options);
|
|
|
|
let protocolDts: string | undefined;
|
|
program.emit(program.getSourceFile(protocolTs), (file, content) => {
|
|
if (endsWith(file, ".d.ts")) {
|
|
protocolDts = content;
|
|
}
|
|
});
|
|
if (protocolDts === undefined) {
|
|
throw new Error(`Declaration file for protocol.ts is not generated`)
|
|
}
|
|
return protocolDts;
|
|
}
|
|
|
|
const protocolFileName = "protocol.d.ts";
|
|
/**
|
|
* Second pass - generate a program from protocol.d.ts and typescriptservices.d.ts, then augment core protocol.d.ts with extra types from typescriptservices.d.ts
|
|
*/
|
|
function getProgramWithProtocolText(protocolDts: string, includeTypeScriptServices: boolean) {
|
|
const host = ts.createCompilerHost(options);
|
|
const originalGetSourceFile = host.getSourceFile;
|
|
host.getSourceFile = (fileName) => {
|
|
if (fileName === protocolFileName) {
|
|
return ts.createSourceFile(fileName, protocolDts, options.target);
|
|
}
|
|
return originalGetSourceFile.apply(host, [fileName]);
|
|
}
|
|
const rootFiles = includeTypeScriptServices ? [protocolFileName, typeScriptServicesDts] : [protocolFileName];
|
|
return ts.createProgram(rootFiles, options, host);
|
|
}
|
|
|
|
let protocolDts = getInitialDtsFileForProtocol();
|
|
const program = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ true);
|
|
|
|
const protocolFile = program.getSourceFile("protocol.d.ts")!;
|
|
const extraDeclarations = DeclarationsWalker.getExtraDeclarations(program.getTypeChecker(), protocolFile);
|
|
if (extraDeclarations) {
|
|
protocolDts += extraDeclarations;
|
|
}
|
|
protocolDts += "\nimport protocol = ts.server.protocol;";
|
|
protocolDts += "\nexport = protocol;";
|
|
protocolDts += "\nexport as namespace protocol;";
|
|
|
|
// do sanity check and try to compile generated text as standalone program
|
|
const sanityCheckProgram = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ false);
|
|
const diagnostics = [...sanityCheckProgram.getSyntacticDiagnostics(), ...sanityCheckProgram.getSemanticDiagnostics(), ...sanityCheckProgram.getGlobalDiagnostics()];
|
|
|
|
ts.sys.writeFile(outputFile, protocolDts);
|
|
|
|
if (diagnostics.length) {
|
|
const flattenedDiagnostics = diagnostics.map(d => `${ts.flattenDiagnosticMessageText(d.messageText, "\n")} at ${d.file ? d.file.fileName : "<unknown>"} line ${d.start}`).join("\n");
|
|
throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
|
|
}
|
|
}
|
|
|
|
if (process.argv.length < 5) {
|
|
console.log(`Expected 3 arguments: path to 'protocol.ts', path to 'typescriptservices.d.ts' and path to output file`);
|
|
process.exit(1);
|
|
}
|
|
|
|
const protocolTs = process.argv[2];
|
|
const typeScriptServicesDts = process.argv[3];
|
|
const outputFile = process.argv[4];
|
|
writeProtocolFile(outputFile, protocolTs, typeScriptServicesDts);
|