Skip to content

Commit fdf3504

Browse files
srujzssrujzs
authored
Merge pull request dart-archive#75 from derekxu16/master
Added the ability to emit file ASTs as JSON
2 parents fed13b3 + 32c849d commit fdf3504

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

45 files changed

+2914
-10
lines changed

‎gulpfile.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ gulp.task('test.compile', gulp.series('compile', function(done) {
5959
done();
6060
return;
6161
}
62-
return gulp.src(['test/*.ts', 'node_modules/dart-style/dart-style.d.ts'], {base: '.'})
62+
return gulp.src(['test/**/*.ts', 'node_modules/dart-style/dart-style.d.ts'], {base: '.'})
6363
.pipe(sourcemaps.init())
6464
.pipe(tsProject())
6565
.on('error', onError)

‎index.js

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ var args = require('minimist')(process.argv.slice(2), {
66
string: ['base-path'],
77
boolean: [
88
'semantic-diagnostics', 'skip-formatting', 'generate-html', 'rename-conflicting-types',
9-
'explicit-static', 'trust-js-types'
9+
'explicit-static', 'trust-js-types', 'to-json'
1010
],
1111
default: {'base-path': ''},
1212
alias: {
@@ -16,7 +16,8 @@ var args = require('minimist')(process.argv.slice(2), {
1616
'generate-html': 'generateHTML',
1717
'rename-conflicting-types': 'renameConflictingTypes',
1818
'explicit-static': 'explicitStatic',
19-
'trust-js-types': 'trustJSTypes'
19+
'trust-js-types': 'trustJSTypes',
20+
'to-json': 'toJSON'
2021
}
2122
});
2223
try {

‎lib/json/conversions.ts

Lines changed: 200 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,200 @@
1+
import * as ts from 'typescript';
2+
3+
import {ExportAssignment, ExportDeclaration, ImportDeclaration, ModuleDeclaration} from './module_declarations';
4+
import {CallSignatureDeclaration, ClassDeclaration, ConstructorDeclaration, ConstructSignatureDeclaration, FunctionDeclaration, GetAccessorDeclaration, InterfaceDeclaration, MemberDeclaration, MethodDeclaration, ParameterDeclaration, PropertyDeclaration, SetAccessorDeclaration, TypeAliasDeclaration, TypeParameterDeclaration, VariableDeclaration} from './named_declarations';
5+
import {Node} from './node';
6+
import {SourceFile} from './source_file';
7+
import {FunctionType, isKeywordTypeNode, KeywordType, LiteralType, Type, TypeLiteral, TypeReference} from './types';
8+
import {VariableStatement} from './variable_statement';
9+
10+
/**
11+
* The conversion helpers may return undefined when the input TS node doesn't contain useful
12+
* information. This function is used to filter undefined out of arrays before serializing the
13+
* converted AST to JSON.
14+
*/
15+
export function filterUndefined(node: Node): boolean {
16+
return node !== undefined;
17+
}
18+
19+
/**
20+
* Helper function that converts Names into strings.
21+
*/
22+
export function convertName(node: ts.DeclarationName|ts.EntityName|ts.BindingName|
23+
ts.QualifiedName): string {
24+
if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
25+
return node.text;
26+
}
27+
if (ts.isQualifiedName(node)) {
28+
const leftName = convertName(node.left);
29+
if (leftName) {
30+
return leftName + '.' + convertName(node.right);
31+
}
32+
}
33+
const error = new Error(`Unexpected Name kind: ${ts.SyntaxKind[node.kind]}`);
34+
error.name = 'DartFacadeError';
35+
throw error;
36+
}
37+
38+
/**
39+
* Helper function that converts Expressions into strings.
40+
*/
41+
export function convertExpression(node: ts.Expression): string {
42+
if (ts.isIdentifier(node)) {
43+
return node.text;
44+
}
45+
if (ts.isStringLiteralLike(node)) {
46+
return `'${node.text}'`;
47+
}
48+
const error = new Error(`Unexpected Expression kind: ${ts.SyntaxKind[node.kind]}`);
49+
error.name = 'DartFacadeError';
50+
throw error;
51+
}
52+
53+
/**
54+
* Takes in a ts.SourceFile and returns a new SourceFile object that is compatible with Dart and can
55+
* be serialized to JSON.
56+
*/
57+
export function convertAST(node: ts.SourceFile): SourceFile {
58+
return new SourceFile(node);
59+
}
60+
61+
export function convertNode(node: ts.Node): Node|undefined {
62+
if (ts.isImportDeclaration(node)) {
63+
return new ImportDeclaration(node);
64+
} else if (ts.isExportDeclaration(node)) {
65+
return new ExportDeclaration(node);
66+
} else if (ts.isExportAssignment(node)) {
67+
return new ExportAssignment(node);
68+
} else if (ts.isModuleDeclaration(node)) {
69+
return new ModuleDeclaration(node);
70+
} else if (ts.isVariableDeclaration(node)) {
71+
return new VariableDeclaration(node);
72+
} else if (ts.isVariableStatement(node)) {
73+
return new VariableStatement(node);
74+
} else if (ts.isFunctionDeclaration(node)) {
75+
return new FunctionDeclaration(node);
76+
} else if (ts.isClassLike(node)) {
77+
return new ClassDeclaration(node);
78+
} else if (ts.isInterfaceDeclaration(node)) {
79+
return new InterfaceDeclaration(node);
80+
} else if (ts.isTypeAliasDeclaration(node)) {
81+
return new TypeAliasDeclaration(node);
82+
} else if (node.kind === ts.SyntaxKind.EndOfFileToken) {
83+
// no-op
84+
return undefined;
85+
} else {
86+
const error = new Error(`Unexpected Node kind ${ts.SyntaxKind[node.kind]}`);
87+
error.name = 'DartFacadeError';
88+
throw error;
89+
}
90+
}
91+
92+
export function convertTypeParameter(typeParam: ts.TypeParameterDeclaration):
93+
TypeParameterDeclaration {
94+
return new TypeParameterDeclaration(typeParam);
95+
}
96+
97+
export function convertTypeNode(node: ts.TypeNode): Type {
98+
if (isKeywordTypeNode(node)) {
99+
return convertKeywordTypeNode(node);
100+
} else if (ts.isTypeReferenceNode(node)) {
101+
return new TypeReference(node);
102+
} else if (ts.isTypeLiteralNode(node)) {
103+
return new TypeLiteral(node);
104+
} else if (ts.isLiteralTypeNode(node)) {
105+
return undefined;
106+
} else if (ts.isFunctionTypeNode(node)) {
107+
return new FunctionType(node);
108+
} else {
109+
const error = new Error(`Unexpected TypeNode kind: ${ts.SyntaxKind[node.kind]}`);
110+
error.name = 'DartFacadeError';
111+
throw error;
112+
}
113+
}
114+
115+
export function convertKeywordTypeNode(node: ts.KeywordTypeNode): KeywordType {
116+
switch (node.kind) {
117+
case ts.SyntaxKind.AnyKeyword:
118+
return new KeywordType(node, 'any');
119+
case ts.SyntaxKind.UnknownKeyword:
120+
return new KeywordType(node, 'unknown');
121+
case ts.SyntaxKind.NumberKeyword:
122+
return new KeywordType(node, 'number');
123+
case ts.SyntaxKind.BigIntKeyword:
124+
return new KeywordType(node, 'bigint');
125+
case ts.SyntaxKind.ObjectKeyword:
126+
return new KeywordType(node, 'object');
127+
case ts.SyntaxKind.BooleanKeyword:
128+
return new KeywordType(node, 'boolean');
129+
case ts.SyntaxKind.StringKeyword:
130+
return new KeywordType(node, 'string');
131+
case ts.SyntaxKind.SymbolKeyword:
132+
return new KeywordType(node, 'symbol');
133+
case ts.SyntaxKind.ThisKeyword:
134+
return new KeywordType(node, 'this');
135+
case ts.SyntaxKind.VoidKeyword:
136+
return new KeywordType(node, 'void');
137+
case ts.SyntaxKind.UndefinedKeyword:
138+
return new KeywordType(node, 'undefined');
139+
case ts.SyntaxKind.NullKeyword:
140+
return new KeywordType(node, 'null');
141+
case ts.SyntaxKind.NeverKeyword:
142+
return new KeywordType(node, 'never');
143+
default:
144+
const error =
145+
new Error(`Unexpected KeywordTypeNode kind: ${ts.SyntaxKind[(node as ts.Node).kind]}`);
146+
error.name = 'DartFacadeError';
147+
throw error;
148+
}
149+
}
150+
151+
export function convertLiteralTypeNode(node: ts.LiteralTypeNode): LiteralType {
152+
if (ts.isLiteralExpression(node)) {
153+
return new LiteralType(node, node.text);
154+
} else {
155+
switch (node.literal.kind) {
156+
case ts.SyntaxKind.TrueKeyword:
157+
return new LiteralType(node, 'true');
158+
case ts.SyntaxKind.FalseKeyword:
159+
return new LiteralType(node, 'false');
160+
default:
161+
const error = new Error(`Unexpected LiteralTypeNode kind: ${ts.SyntaxKind[(node.kind)]}`);
162+
error.name = 'DartFacadeError';
163+
throw error;
164+
}
165+
}
166+
}
167+
168+
export function convertMember(member: ts.ClassElement|ts.TypeElement): MemberDeclaration {
169+
if (ts.isSemicolonClassElement(member)) {
170+
return undefined;
171+
}
172+
if (ts.isPropertyDeclaration(member) || ts.isPropertySignature(member)) {
173+
return new PropertyDeclaration(member);
174+
}
175+
if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
176+
return new MethodDeclaration(member);
177+
}
178+
if (ts.isConstructorDeclaration(member)) {
179+
return new ConstructorDeclaration(member);
180+
}
181+
if (ts.isConstructSignatureDeclaration(member)) {
182+
return new ConstructSignatureDeclaration(member);
183+
}
184+
if (ts.isGetAccessor(member)) {
185+
return new GetAccessorDeclaration(member);
186+
}
187+
if (ts.isSetAccessor(member)) {
188+
return new SetAccessorDeclaration(member);
189+
}
190+
if (ts.isCallSignatureDeclaration(member)) {
191+
return new CallSignatureDeclaration(member);
192+
}
193+
const error = new Error(`Unexpected Member kind: ${ts.SyntaxKind[member.kind]}`);
194+
error.name = 'DartFacadeError';
195+
throw error;
196+
}
197+
198+
export function convertParameter(parameter: ts.ParameterDeclaration) {
199+
return new ParameterDeclaration(parameter);
200+
}

0 commit comments

Comments
 (0)