FilesExpand file tree

 typeOperations

/

buildProtocol.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

191 lines (170 loc) · 8.23 KB

 typeOperations

/

buildProtocol.ts

Copy path

Top

File metadata and controls

• Code
• Blame

191 lines (170 loc) · 8.23 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

/// <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 {

for (const decl of s.getDeclarations()) {

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;

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.fileName} 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);