refactor(compiler): remove all source-level traces to tsc-wrapped (#18966)
- temporarily keeps the old sources under packages/tsc-wrapped until the build scripts are changed to use compiler-cli everywhere. - removes the compiler options `disableTransformerPipeline` that was introduced in a previous beta of Angular 5, i.e. the transformer based compiler is now always enabled. PR Close #18966
This commit is contained in:
Matias Niemelä
274
packages/compiler-cli/test/metadata/bundler_spec.ts
Normal file
274
packages/compiler-cli/test/metadata/bundler_spec.ts
Normal file
@ -0,0 +1,274 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright Google Inc. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by an MIT-style license that can be
|
||||
* found in the LICENSE file at https://angular.io/license
|
||||
*/
|
||||
|
||||
import * as path from 'path';
|
||||
import * as ts from 'typescript';
|
||||
|
||||
import {MetadataBundler, MetadataBundlerHost} from '../../src/metadata/bundler';
|
||||
import {MetadataCollector} from '../../src/metadata/collector';
|
||||
import {ClassMetadata, MetadataGlobalReferenceExpression, ModuleMetadata} from '../../src/metadata/schema';
|
||||
|
||||
import {Directory, open} from './typescript.mocks';
|
||||
|
||||
describe('metadata bundler', () => {
|
||||
|
||||
it('should be able to bundle a simple library', () => {
|
||||
const host = new MockStringBundlerHost('/', SIMPLE_LIBRARY);
|
||||
const bundler = new MetadataBundler('/lib/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
expect(Object.keys(result.metadata.metadata).sort()).toEqual([
|
||||
'ONE_CLASSES', 'One', 'OneMore', 'TWO_CLASSES', 'Two', 'TwoMore', 'ɵa', 'ɵb'
|
||||
]);
|
||||
|
||||
const originalOne = './src/one';
|
||||
const originalTwo = './src/two/index';
|
||||
expect(Object.keys(result.metadata.origins)
|
||||
.sort()
|
||||
.map(name => ({name, value: result.metadata.origins ![name]})))
|
||||
.toEqual([
|
||||
{name: 'ONE_CLASSES', value: originalOne}, {name: 'One', value: originalOne},
|
||||
{name: 'OneMore', value: originalOne}, {name: 'TWO_CLASSES', value: originalTwo},
|
||||
{name: 'Two', value: originalTwo}, {name: 'TwoMore', value: originalTwo},
|
||||
{name: 'ɵa', value: originalOne}, {name: 'ɵb', value: originalTwo}
|
||||
]);
|
||||
expect(result.privates).toEqual([
|
||||
{privateName: 'ɵa', name: 'PrivateOne', module: originalOne},
|
||||
{privateName: 'ɵb', name: 'PrivateTwo', module: originalTwo}
|
||||
]);
|
||||
});
|
||||
|
||||
it('should be able to bundle an oddly constructed library', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'lib': {
|
||||
'index.ts': `
|
||||
export * from './src/index';
|
||||
`,
|
||||
'src': {
|
||||
'index.ts': `
|
||||
export {One, OneMore, ONE_CLASSES} from './one';
|
||||
export {Two, TwoMore, TWO_CLASSES} from './two/index';
|
||||
`,
|
||||
'one.ts': `
|
||||
class One {}
|
||||
class OneMore extends One {}
|
||||
class PrivateOne {}
|
||||
const ONE_CLASSES = [One, OneMore, PrivateOne];
|
||||
export {One, OneMore, PrivateOne, ONE_CLASSES};
|
||||
`,
|
||||
'two': {
|
||||
'index.ts': `
|
||||
class Two {}
|
||||
class TwoMore extends Two {}
|
||||
class PrivateTwo {}
|
||||
const TWO_CLASSES = [Two, TwoMore, PrivateTwo];
|
||||
export {Two, TwoMore, PrivateTwo, TWO_CLASSES};
|
||||
`
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
const bundler = new MetadataBundler('/lib/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
expect(Object.keys(result.metadata.metadata).sort()).toEqual([
|
||||
'ONE_CLASSES', 'One', 'OneMore', 'TWO_CLASSES', 'Two', 'TwoMore', 'ɵa', 'ɵb'
|
||||
]);
|
||||
expect(result.privates).toEqual([
|
||||
{privateName: 'ɵa', name: 'PrivateOne', module: './src/one'},
|
||||
{privateName: 'ɵb', name: 'PrivateTwo', module: './src/two/index'}
|
||||
]);
|
||||
});
|
||||
|
||||
it('should not output windows paths in metadata', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'index.ts': `
|
||||
export * from './exports/test';
|
||||
`,
|
||||
'exports': {'test.ts': `export class TestExport {}`}
|
||||
});
|
||||
const bundler = new MetadataBundler('/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
|
||||
expect(result.metadata.origins).toEqual({'TestExport': './exports/test'});
|
||||
});
|
||||
|
||||
it('should convert re-exported to the export', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'index.ts': `
|
||||
export * from './bar';
|
||||
export * from './foo';
|
||||
`,
|
||||
'bar.ts': `
|
||||
import {Foo} from './foo';
|
||||
export class Bar extends Foo {
|
||||
|
||||
}
|
||||
`,
|
||||
'foo.ts': `
|
||||
export {Foo} from 'foo';
|
||||
`
|
||||
});
|
||||
const bundler = new MetadataBundler('/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
// Expect the extends reference to refer to the imported module
|
||||
expect((result.metadata.metadata as any).Bar.extends.module).toEqual('foo');
|
||||
expect(result.privates).toEqual([]);
|
||||
});
|
||||
|
||||
it('should treat import then export as a simple export', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'index.ts': `
|
||||
export * from './a';
|
||||
export * from './c';
|
||||
`,
|
||||
'a.ts': `
|
||||
import { B } from './b';
|
||||
export { B };
|
||||
`,
|
||||
'b.ts': `
|
||||
export class B { }
|
||||
`,
|
||||
'c.ts': `
|
||||
import { B } from './b';
|
||||
export class C extends B { }
|
||||
`
|
||||
});
|
||||
const bundler = new MetadataBundler('/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
expect(Object.keys(result.metadata.metadata).sort()).toEqual(['B', 'C']);
|
||||
expect(result.privates).toEqual([]);
|
||||
});
|
||||
|
||||
it('should be able to bundle a private from a un-exported module', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'index.ts': `
|
||||
export * from './foo';
|
||||
`,
|
||||
'foo.ts': `
|
||||
import {Bar} from './bar';
|
||||
export class Foo extends Bar {
|
||||
|
||||
}
|
||||
`,
|
||||
'bar.ts': `
|
||||
export class Bar {}
|
||||
`
|
||||
});
|
||||
const bundler = new MetadataBundler('/index', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
expect(Object.keys(result.metadata.metadata).sort()).toEqual(['Foo', 'ɵa']);
|
||||
expect(result.privates).toEqual([{privateName: 'ɵa', name: 'Bar', module: './bar'}]);
|
||||
});
|
||||
|
||||
it('should be able to bundle a library with re-exported symbols', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'public-api.ts': `
|
||||
export * from './src/core';
|
||||
export * from './src/externals';
|
||||
`,
|
||||
'src': {
|
||||
'core.ts': `
|
||||
export class A {}
|
||||
export class B extends A {}
|
||||
`,
|
||||
'externals.ts': `
|
||||
export {E, F, G} from 'external_one';
|
||||
export * from 'external_two';
|
||||
`
|
||||
}
|
||||
});
|
||||
|
||||
const bundler = new MetadataBundler('/public-api', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
expect(result.metadata.exports).toEqual([
|
||||
{from: 'external_two'}, {
|
||||
export: [{name: 'E', as: 'E'}, {name: 'F', as: 'F'}, {name: 'G', as: 'G'}],
|
||||
from: 'external_one'
|
||||
}
|
||||
]);
|
||||
expect(result.metadata.origins !['E']).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should be able to de-duplicate symbols of re-exported modules', () => {
|
||||
const host = new MockStringBundlerHost('/', {
|
||||
'public-api.ts': `
|
||||
export {A as A2, A, B as B1, B as B2} from './src/core';
|
||||
`,
|
||||
'src': {
|
||||
'core.ts': `
|
||||
export class A {}
|
||||
export class B {}
|
||||
`,
|
||||
}
|
||||
});
|
||||
|
||||
const bundler = new MetadataBundler('/public-api', undefined, host);
|
||||
const result = bundler.getMetadataBundle();
|
||||
const {A, A2, B1, B2} = result.metadata.metadata as{
|
||||
A: ClassMetadata,
|
||||
A2: MetadataGlobalReferenceExpression,
|
||||
B1: ClassMetadata,
|
||||
B2: MetadataGlobalReferenceExpression
|
||||
};
|
||||
expect(A.__symbolic).toEqual('class');
|
||||
expect(A2.__symbolic).toEqual('reference');
|
||||
expect(A2.name).toEqual('A');
|
||||
expect(B1.__symbolic).toEqual('class');
|
||||
expect(B2.__symbolic).toEqual('reference');
|
||||
expect(B2.name).toEqual('B1');
|
||||
});
|
||||
});
|
||||
|
||||
export class MockStringBundlerHost implements MetadataBundlerHost {
|
||||
collector = new MetadataCollector();
|
||||
|
||||
constructor(private dirName: string, private directory: Directory) {}
|
||||
|
||||
getMetadataFor(moduleName: string): ModuleMetadata|undefined {
|
||||
const fileName = path.join(this.dirName, moduleName) + '.ts';
|
||||
const text = open(this.directory, fileName);
|
||||
if (typeof text == 'string') {
|
||||
const sourceFile = ts.createSourceFile(
|
||||
fileName, text, ts.ScriptTarget.Latest, /* setParent */ true, ts.ScriptKind.TS);
|
||||
const diagnostics: ts.Diagnostic[] = (sourceFile as any).parseDiagnostics;
|
||||
if (diagnostics && diagnostics.length) {
|
||||
throw Error('Unexpected syntax error in test');
|
||||
}
|
||||
const result = this.collector.getMetadata(sourceFile);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
export const SIMPLE_LIBRARY = {
|
||||
'lib': {
|
||||
'index.ts': `
|
||||
export * from './src/index';
|
||||
`,
|
||||
'src': {
|
||||
'index.ts': `
|
||||
export {One, OneMore, ONE_CLASSES} from './one';
|
||||
export {Two, TwoMore, TWO_CLASSES} from './two/index';
|
||||
`,
|
||||
'one.ts': `
|
||||
export class One {}
|
||||
export class OneMore extends One {}
|
||||
export class PrivateOne {}
|
||||
export const ONE_CLASSES = [One, OneMore, PrivateOne];
|
||||
`,
|
||||
'two': {
|
||||
'index.ts': `
|
||||
export class Two {}
|
||||
export class TwoMore extends Two {}
|
||||
export class PrivateTwo {}
|
||||
export const TWO_CLASSES = [Two, TwoMore, PrivateTwo];
|
||||
`
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
1484
packages/compiler-cli/test/metadata/collector_spec.ts
Normal file
1484
packages/compiler-cli/test/metadata/collector_spec.ts
Normal file
File diff suppressed because it is too large
Load Diff
373
packages/compiler-cli/test/metadata/evaluator_spec.ts
Normal file
373
packages/compiler-cli/test/metadata/evaluator_spec.ts
Normal file
@ -0,0 +1,373 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright Google Inc. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by an MIT-style license that can be
|
||||
* found in the LICENSE file at https://angular.io/license
|
||||
*/
|
||||
|
||||
import * as fs from 'fs';
|
||||
import * as ts from 'typescript';
|
||||
|
||||
import {Evaluator} from '../../src/metadata/evaluator';
|
||||
import {Symbols} from '../../src/metadata/symbols';
|
||||
|
||||
import {Directory, Host, expectNoDiagnostics, findVar, findVarInitializer} from './typescript.mocks';
|
||||
|
||||
describe('Evaluator', () => {
|
||||
const documentRegistry = ts.createDocumentRegistry();
|
||||
let host: ts.LanguageServiceHost;
|
||||
let service: ts.LanguageService;
|
||||
let program: ts.Program;
|
||||
let typeChecker: ts.TypeChecker;
|
||||
let symbols: Symbols;
|
||||
let evaluator: Evaluator;
|
||||
|
||||
beforeEach(() => {
|
||||
host = new Host(FILES, [
|
||||
'expressions.ts', 'consts.ts', 'const_expr.ts', 'forwardRef.ts', 'classes.ts',
|
||||
'newExpression.ts', 'errors.ts', 'declared.ts'
|
||||
]);
|
||||
service = ts.createLanguageService(host, documentRegistry);
|
||||
program = service.getProgram();
|
||||
typeChecker = program.getTypeChecker();
|
||||
symbols = new Symbols(null as any as ts.SourceFile);
|
||||
evaluator = new Evaluator(symbols, new Map());
|
||||
});
|
||||
|
||||
it('should not have typescript errors in test data', () => {
|
||||
expectNoDiagnostics(service.getCompilerOptionsDiagnostics());
|
||||
for (const sourceFile of program.getSourceFiles()) {
|
||||
expectNoDiagnostics(service.getSyntacticDiagnostics(sourceFile.fileName));
|
||||
if (sourceFile.fileName != 'errors.ts') {
|
||||
// Skip errors.ts because we it has intentional semantic errors that we are testing for.
|
||||
expectNoDiagnostics(service.getSemanticDiagnostics(sourceFile.fileName));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should be able to fold literal expressions', () => {
|
||||
const consts = program.getSourceFile('consts.ts');
|
||||
expect(evaluator.isFoldable(findVarInitializer(consts, 'someName'))).toBeTruthy();
|
||||
expect(evaluator.isFoldable(findVarInitializer(consts, 'someBool'))).toBeTruthy();
|
||||
expect(evaluator.isFoldable(findVarInitializer(consts, 'one'))).toBeTruthy();
|
||||
expect(evaluator.isFoldable(findVarInitializer(consts, 'two'))).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should be able to fold expressions with foldable references', () => {
|
||||
const expressions = program.getSourceFile('expressions.ts');
|
||||
symbols.define('someName', 'some-name');
|
||||
symbols.define('someBool', true);
|
||||
symbols.define('one', 1);
|
||||
symbols.define('two', 2);
|
||||
expect(evaluator.isFoldable(findVarInitializer(expressions, 'three'))).toBeTruthy();
|
||||
expect(evaluator.isFoldable(findVarInitializer(expressions, 'four'))).toBeTruthy();
|
||||
symbols.define('three', 3);
|
||||
symbols.define('four', 4);
|
||||
expect(evaluator.isFoldable(findVarInitializer(expressions, 'obj'))).toBeTruthy();
|
||||
expect(evaluator.isFoldable(findVarInitializer(expressions, 'arr'))).toBeTruthy();
|
||||
});
|
||||
|
||||
it('should be able to evaluate literal expressions', () => {
|
||||
const consts = program.getSourceFile('consts.ts');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(consts, 'someName'))).toBe('some-name');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(consts, 'someBool'))).toBe(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(consts, 'one'))).toBe(1);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(consts, 'two'))).toBe(2);
|
||||
});
|
||||
|
||||
it('should be able to evaluate expressions', () => {
|
||||
const expressions = program.getSourceFile('expressions.ts');
|
||||
symbols.define('someName', 'some-name');
|
||||
symbols.define('someBool', true);
|
||||
symbols.define('one', 1);
|
||||
symbols.define('two', 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'three'))).toBe(3);
|
||||
symbols.define('three', 3);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'four'))).toBe(4);
|
||||
symbols.define('four', 4);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'obj')))
|
||||
.toEqual({one: 1, two: 2, three: 3, four: 4});
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'arr'))).toEqual([1, 2, 3, 4]);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bTrue'))).toEqual(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bFalse'))).toEqual(false);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bAnd'))).toEqual(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bOr'))).toEqual(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'nDiv'))).toEqual(2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'nMod'))).toEqual(1);
|
||||
|
||||
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bLOr'))).toEqual(false || true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bLAnd'))).toEqual(true && true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bBOr'))).toEqual(0x11 | 0x22);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bBAnd'))).toEqual(0x11 & 0x03);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bXor'))).toEqual(0x11 ^ 0x21);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bEqual')))
|
||||
.toEqual(1 == <any>'1');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bNotEqual')))
|
||||
.toEqual(1 != <any>'1');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bIdentical')))
|
||||
.toEqual(1 === <any>'1');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bNotIdentical')))
|
||||
.toEqual(1 !== <any>'1');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bLessThan'))).toEqual(1 < 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bGreaterThan'))).toEqual(1 > 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bLessThanEqual')))
|
||||
.toEqual(1 <= 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bGreaterThanEqual')))
|
||||
.toEqual(1 >= 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bShiftLeft'))).toEqual(1 << 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bShiftRight'))).toEqual(-1 >> 2);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'bShiftRightU')))
|
||||
.toEqual(-1 >>> 2);
|
||||
|
||||
});
|
||||
|
||||
it('should report recursive references as symbolic', () => {
|
||||
const expressions = program.getSourceFile('expressions.ts');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'recursiveA')))
|
||||
.toEqual({__symbolic: 'reference', name: 'recursiveB'});
|
||||
expect(evaluator.evaluateNode(findVarInitializer(expressions, 'recursiveB')))
|
||||
.toEqual({__symbolic: 'reference', name: 'recursiveA'});
|
||||
});
|
||||
|
||||
it('should correctly handle special cases for CONST_EXPR', () => {
|
||||
const const_expr = program.getSourceFile('const_expr.ts');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(const_expr, 'bTrue'))).toEqual(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(const_expr, 'bFalse'))).toEqual(false);
|
||||
});
|
||||
|
||||
it('should resolve a forwardRef', () => {
|
||||
const forwardRef = program.getSourceFile('forwardRef.ts');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(forwardRef, 'bTrue'))).toEqual(true);
|
||||
expect(evaluator.evaluateNode(findVarInitializer(forwardRef, 'bFalse'))).toEqual(false);
|
||||
});
|
||||
|
||||
it('should return new expressions', () => {
|
||||
symbols.define('Value', {__symbolic: 'reference', module: './classes', name: 'Value'});
|
||||
evaluator = new Evaluator(symbols, new Map());
|
||||
const newExpression = program.getSourceFile('newExpression.ts');
|
||||
expect(evaluator.evaluateNode(findVarInitializer(newExpression, 'someValue'))).toEqual({
|
||||
__symbolic: 'new',
|
||||
expression: {__symbolic: 'reference', name: 'Value', module: './classes'},
|
||||
arguments: ['name', 12]
|
||||
});
|
||||
expect(evaluator.evaluateNode(findVarInitializer(newExpression, 'complex'))).toEqual({
|
||||
__symbolic: 'new',
|
||||
expression: {__symbolic: 'reference', name: 'Value', module: './classes'},
|
||||
arguments: ['name', 12]
|
||||
});
|
||||
});
|
||||
|
||||
it('should support referene to a declared module type', () => {
|
||||
const declared = program.getSourceFile('declared.ts');
|
||||
const aDecl = findVar(declared, 'a') !;
|
||||
expect(evaluator.evaluateNode(aDecl.type !)).toEqual({
|
||||
__symbolic: 'select',
|
||||
expression: {__symbolic: 'reference', name: 'Foo'},
|
||||
member: 'A'
|
||||
});
|
||||
});
|
||||
|
||||
it('should return errors for unsupported expressions', () => {
|
||||
const errors = program.getSourceFile('errors.ts');
|
||||
const fDecl = findVar(errors, 'f') !;
|
||||
expect(evaluator.evaluateNode(fDecl.initializer !))
|
||||
.toEqual(
|
||||
{__symbolic: 'error', message: 'Function call not supported', line: 1, character: 12});
|
||||
const eDecl = findVar(errors, 'e') !;
|
||||
expect(evaluator.evaluateNode(eDecl.type !)).toEqual({
|
||||
__symbolic: 'error',
|
||||
message: 'Could not resolve type',
|
||||
line: 2,
|
||||
character: 11,
|
||||
context: {typeName: 'NotFound'}
|
||||
});
|
||||
const sDecl = findVar(errors, 's') !;
|
||||
expect(evaluator.evaluateNode(sDecl.initializer !)).toEqual({
|
||||
__symbolic: 'error',
|
||||
message: 'Name expected',
|
||||
line: 3,
|
||||
character: 14,
|
||||
context: {received: '1'}
|
||||
});
|
||||
const tDecl = findVar(errors, 't') !;
|
||||
expect(evaluator.evaluateNode(tDecl.initializer !)).toEqual({
|
||||
__symbolic: 'error',
|
||||
message: 'Expression form not supported',
|
||||
line: 4,
|
||||
character: 12
|
||||
});
|
||||
});
|
||||
|
||||
it('should be able to fold an array spread', () => {
|
||||
const expressions = program.getSourceFile('expressions.ts');
|
||||
symbols.define('arr', [1, 2, 3, 4]);
|
||||
const arrSpread = findVar(expressions, 'arrSpread') !;
|
||||
expect(evaluator.evaluateNode(arrSpread.initializer !)).toEqual([0, 1, 2, 3, 4, 5]);
|
||||
});
|
||||
|
||||
it('should be able to produce a spread expression', () => {
|
||||
const expressions = program.getSourceFile('expressions.ts');
|
||||
const arrSpreadRef = findVar(expressions, 'arrSpreadRef') !;
|
||||
expect(evaluator.evaluateNode(arrSpreadRef.initializer !)).toEqual([
|
||||
0, {__symbolic: 'spread', expression: {__symbolic: 'reference', name: 'arrImport'}}, 5
|
||||
]);
|
||||
});
|
||||
|
||||
it('should be able to handle a new expression with no arguments', () => {
|
||||
const source = sourceFileOf(`
|
||||
export var a = new f;
|
||||
`);
|
||||
const expr = findVar(source, 'a') !;
|
||||
expect(evaluator.evaluateNode(expr.initializer !))
|
||||
.toEqual({__symbolic: 'new', expression: {__symbolic: 'reference', name: 'f'}});
|
||||
});
|
||||
|
||||
describe('with substitution', () => {
|
||||
let evaluator: Evaluator;
|
||||
const lambdaTemp = 'lambdaTemp';
|
||||
|
||||
beforeEach(() => {
|
||||
evaluator = new Evaluator(symbols, new Map(), {
|
||||
substituteExpression: (value, node) => {
|
||||
if (node.kind == ts.SyntaxKind.ArrowFunction) {
|
||||
return {__symbolic: 'reference', name: lambdaTemp};
|
||||
}
|
||||
return value;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('should be able to substitute a lambda with a reference', () => {
|
||||
const source = sourceFileOf(`
|
||||
var b = 1;
|
||||
export var a = () => b;
|
||||
`);
|
||||
const expr = findVar(source, 'a');
|
||||
expect(evaluator.evaluateNode(expr !.initializer !))
|
||||
.toEqual({__symbolic: 'reference', name: lambdaTemp});
|
||||
});
|
||||
|
||||
it('should be able to substitute a lambda in an expression', () => {
|
||||
const source = sourceFileOf(`
|
||||
var b = 1;
|
||||
export var a = [
|
||||
{ provide: 'someValue': useFactory: () => b }
|
||||
];
|
||||
`);
|
||||
const expr = findVar(source, 'a');
|
||||
expect(evaluator.evaluateNode(expr !.initializer !)).toEqual([
|
||||
{provide: 'someValue', useFactory: {__symbolic: 'reference', name: lambdaTemp}}
|
||||
]);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
function sourceFileOf(text: string): ts.SourceFile {
|
||||
return ts.createSourceFile('test.ts', text, ts.ScriptTarget.Latest, true);
|
||||
}
|
||||
|
||||
const FILES: Directory = {
|
||||
'directives.ts': `
|
||||
export function Pipe(options: { name?: string, pure?: boolean}) {
|
||||
return function(fn: Function) { }
|
||||
}
|
||||
`,
|
||||
'classes.ts': `
|
||||
export class Value {
|
||||
constructor(public name: string, public value: any) {}
|
||||
}
|
||||
`,
|
||||
'consts.ts': `
|
||||
export var someName = 'some-name';
|
||||
export var someBool = true;
|
||||
export var one = 1;
|
||||
export var two = 2;
|
||||
export var arrImport = [1, 2, 3, 4];
|
||||
`,
|
||||
'expressions.ts': `
|
||||
import {arrImport} from './consts';
|
||||
|
||||
export var someName = 'some-name';
|
||||
export var someBool = true;
|
||||
export var one = 1;
|
||||
export var two = 2;
|
||||
|
||||
export var three = one + two;
|
||||
export var four = two * two;
|
||||
export var obj = { one: one, two: two, three: three, four: four };
|
||||
export var arr = [one, two, three, four];
|
||||
export var bTrue = someBool;
|
||||
export var bFalse = !someBool;
|
||||
export var bAnd = someBool && someBool;
|
||||
export var bOr = someBool || someBool;
|
||||
export var nDiv = four / two;
|
||||
export var nMod = (four + one) % two;
|
||||
|
||||
export var bLOr = false || true; // true
|
||||
export var bLAnd = true && true; // true
|
||||
export var bBOr = 0x11 | 0x22; // 0x33
|
||||
export var bBAnd = 0x11 & 0x03; // 0x01
|
||||
export var bXor = 0x11 ^ 0x21; // 0x20
|
||||
export var bEqual = 1 == <any>"1"; // true
|
||||
export var bNotEqual = 1 != <any>"1"; // false
|
||||
export var bIdentical = 1 === <any>"1"; // false
|
||||
export var bNotIdentical = 1 !== <any>"1"; // true
|
||||
export var bLessThan = 1 < 2; // true
|
||||
export var bGreaterThan = 1 > 2; // false
|
||||
export var bLessThanEqual = 1 <= 2; // true
|
||||
export var bGreaterThanEqual = 1 >= 2; // false
|
||||
export var bShiftLeft = 1 << 2; // 0x04
|
||||
export var bShiftRight = -1 >> 2; // -1
|
||||
export var bShiftRightU = -1 >>> 2; // 0x3fffffff
|
||||
|
||||
export var arrSpread = [0, ...arr, 5];
|
||||
|
||||
export var arrSpreadRef = [0, ...arrImport, 5];
|
||||
|
||||
export var recursiveA = recursiveB;
|
||||
export var recursiveB = recursiveA;
|
||||
`,
|
||||
'A.ts': `
|
||||
import {Pipe} from './directives';
|
||||
|
||||
@Pipe({name: 'A', pure: false})
|
||||
export class A {}`,
|
||||
'B.ts': `
|
||||
import {Pipe} from './directives';
|
||||
import {someName, someBool} from './consts';
|
||||
|
||||
@Pipe({name: someName, pure: someBool})
|
||||
export class B {}`,
|
||||
'const_expr.ts': `
|
||||
function CONST_EXPR(value: any) { return value; }
|
||||
export var bTrue = CONST_EXPR(true);
|
||||
export var bFalse = CONST_EXPR(false);
|
||||
`,
|
||||
'forwardRef.ts': `
|
||||
function forwardRef(value: any) { return value; }
|
||||
export var bTrue = forwardRef(() => true);
|
||||
export var bFalse = forwardRef(() => false);
|
||||
`,
|
||||
'newExpression.ts': `
|
||||
import {Value} from './classes';
|
||||
function CONST_EXPR(value: any) { return value; }
|
||||
function forwardRef(value: any) { return value; }
|
||||
export const someValue = new Value("name", 12);
|
||||
export const complex = CONST_EXPR(new Value("name", forwardRef(() => 12)));
|
||||
`,
|
||||
'errors.ts': `
|
||||
let f = () => 1;
|
||||
let e: NotFound;
|
||||
let s = { 1: 1, 2: 2 };
|
||||
let t = typeof 12;
|
||||
`,
|
||||
'declared.ts': `
|
||||
declare namespace Foo {
|
||||
type A = string;
|
||||
}
|
||||
|
||||
let a: Foo.A = 'some value';
|
||||
`
|
||||
};
|
||||
25
packages/compiler-cli/test/metadata/index_writer_spec.ts
Normal file
25
packages/compiler-cli/test/metadata/index_writer_spec.ts
Normal file
@ -0,0 +1,25 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright Google Inc. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by an MIT-style license that can be
|
||||
* found in the LICENSE file at https://angular.io/license
|
||||
*/
|
||||
|
||||
import {MetadataBundler} from '../../src/metadata/bundler';
|
||||
import {MetadataCollector} from '../../src/metadata/collector';
|
||||
import {privateEntriesToIndex} from '../../src/metadata/index_writer';
|
||||
|
||||
import {MockStringBundlerHost, SIMPLE_LIBRARY} from './bundler_spec';
|
||||
|
||||
describe('index_writer', () => {
|
||||
it('should be able to write the index of a simple library', () => {
|
||||
const host = new MockStringBundlerHost('/', SIMPLE_LIBRARY);
|
||||
const bundler = new MetadataBundler('/lib/index', undefined, host);
|
||||
const bundle = bundler.getMetadataBundle();
|
||||
const result = privateEntriesToIndex('./index', bundle.privates);
|
||||
expect(result).toContain(`export * from './index';`);
|
||||
expect(result).toContain(`export {PrivateOne as ɵa} from './src/one';`);
|
||||
expect(result).toContain(`export {PrivateTwo as ɵb} from './src/two/index';`);
|
||||
});
|
||||
});
|
||||
133
packages/compiler-cli/test/metadata/symbols_spec.ts
Normal file
133
packages/compiler-cli/test/metadata/symbols_spec.ts
Normal file
@ -0,0 +1,133 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright Google Inc. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by an MIT-style license that can be
|
||||
* found in the LICENSE file at https://angular.io/license
|
||||
*/
|
||||
|
||||
import * as ts from 'typescript';
|
||||
|
||||
import {isMetadataGlobalReferenceExpression} from '../../src/metadata/schema';
|
||||
import {Symbols} from '../../src/metadata/symbols';
|
||||
|
||||
import {Directory, Host, expectNoDiagnostics} from './typescript.mocks';
|
||||
|
||||
describe('Symbols', () => {
|
||||
let symbols: Symbols;
|
||||
const someValue = 'some-value';
|
||||
|
||||
beforeEach(() => symbols = new Symbols(null as any as ts.SourceFile));
|
||||
|
||||
it('should be able to add a symbol', () => symbols.define('someSymbol', someValue));
|
||||
|
||||
beforeEach(() => symbols.define('someSymbol', someValue));
|
||||
|
||||
it('should be able to `has` a symbol', () => expect(symbols.has('someSymbol')).toBeTruthy());
|
||||
it('should be able to `get` a symbol value',
|
||||
() => expect(symbols.resolve('someSymbol')).toBe(someValue));
|
||||
it('should be able to `get` a symbol value',
|
||||
() => expect(symbols.resolve('someSymbol')).toBe(someValue));
|
||||
it('should be able to determine symbol is missing',
|
||||
() => expect(symbols.has('missingSymbol')).toBeFalsy());
|
||||
it('should return undefined from `get` for a missing symbol',
|
||||
() => expect(symbols.resolve('missingSymbol')).toBeUndefined());
|
||||
|
||||
let host: ts.LanguageServiceHost;
|
||||
let service: ts.LanguageService;
|
||||
let program: ts.Program;
|
||||
let expressions: ts.SourceFile;
|
||||
let imports: ts.SourceFile;
|
||||
|
||||
beforeEach(() => {
|
||||
host = new Host(FILES, ['consts.ts', 'expressions.ts', 'imports.ts']);
|
||||
service = ts.createLanguageService(host);
|
||||
program = service.getProgram();
|
||||
expressions = program.getSourceFile('expressions.ts');
|
||||
imports = program.getSourceFile('imports.ts');
|
||||
});
|
||||
|
||||
it('should not have syntax errors in the test sources', () => {
|
||||
expectNoDiagnostics(service.getCompilerOptionsDiagnostics());
|
||||
for (const sourceFile of program.getSourceFiles()) {
|
||||
expectNoDiagnostics(service.getSyntacticDiagnostics(sourceFile.fileName));
|
||||
}
|
||||
});
|
||||
|
||||
it('should be able to find the source files', () => {
|
||||
expect(expressions).toBeDefined();
|
||||
expect(imports).toBeDefined();
|
||||
});
|
||||
|
||||
it('should be able to create symbols for a source file', () => {
|
||||
const symbols = new Symbols(expressions);
|
||||
expect(symbols).toBeDefined();
|
||||
});
|
||||
|
||||
|
||||
it('should be able to find symbols in expression', () => {
|
||||
const symbols = new Symbols(expressions);
|
||||
expect(symbols.has('someName')).toBeTruthy();
|
||||
expect(symbols.resolve('someName'))
|
||||
.toEqual({__symbolic: 'reference', module: './consts', name: 'someName'});
|
||||
expect(symbols.has('someBool')).toBeTruthy();
|
||||
expect(symbols.resolve('someBool'))
|
||||
.toEqual({__symbolic: 'reference', module: './consts', name: 'someBool'});
|
||||
});
|
||||
|
||||
it('should be able to detect a * import', () => {
|
||||
const symbols = new Symbols(imports);
|
||||
expect(symbols.resolve('b')).toEqual({__symbolic: 'reference', module: 'b'});
|
||||
});
|
||||
|
||||
it('should be able to detect importing a default export', () => {
|
||||
const symbols = new Symbols(imports);
|
||||
expect(symbols.resolve('d')).toEqual({__symbolic: 'reference', module: 'd', default: true});
|
||||
});
|
||||
|
||||
it('should be able to import a renamed symbol', () => {
|
||||
const symbols = new Symbols(imports);
|
||||
expect(symbols.resolve('g')).toEqual({__symbolic: 'reference', name: 'f', module: 'f'});
|
||||
});
|
||||
|
||||
it('should be able to resolve any symbol in core global scope', () => {
|
||||
const core = program.getSourceFiles().find(source => source.fileName.endsWith('lib.d.ts'));
|
||||
expect(core).toBeDefined();
|
||||
const visit = (node: ts.Node): boolean => {
|
||||
switch (node.kind) {
|
||||
case ts.SyntaxKind.VariableStatement:
|
||||
case ts.SyntaxKind.VariableDeclarationList:
|
||||
return !!ts.forEachChild(node, visit);
|
||||
case ts.SyntaxKind.VariableDeclaration:
|
||||
const variableDeclaration = <ts.VariableDeclaration>node;
|
||||
const nameNode = <ts.Identifier>variableDeclaration.name;
|
||||
const name = nameNode.text;
|
||||
const result = symbols.resolve(name);
|
||||
expect(isMetadataGlobalReferenceExpression(result) && result.name).toEqual(name);
|
||||
|
||||
// Ignore everything after Float64Array as it is IE specific.
|
||||
return name === 'Float64Array';
|
||||
}
|
||||
return false;
|
||||
};
|
||||
ts.forEachChild(core !, visit);
|
||||
});
|
||||
});
|
||||
|
||||
const FILES: Directory = {
|
||||
'consts.ts': `
|
||||
export var someName = 'some-name';
|
||||
export var someBool = true;
|
||||
export var one = 1;
|
||||
export var two = 2;
|
||||
`,
|
||||
'expressions.ts': `
|
||||
import {someName, someBool, one, two} from './consts';
|
||||
`,
|
||||
'imports.ts': `
|
||||
import * as b from 'b';
|
||||
import 'c';
|
||||
import d from 'd';
|
||||
import {f as g} from 'f';
|
||||
`
|
||||
};
|
||||
204
packages/compiler-cli/test/metadata/typescript.mocks.ts
Normal file
204
packages/compiler-cli/test/metadata/typescript.mocks.ts
Normal file
@ -0,0 +1,204 @@
|
||||
/**
|
||||
* @license
|
||||
* Copyright Google Inc. All Rights Reserved.
|
||||
*
|
||||
* Use of this source code is governed by an MIT-style license that can be
|
||||
* found in the LICENSE file at https://angular.io/license
|
||||
*/
|
||||
|
||||
import * as fs from 'fs';
|
||||
import * as ts from 'typescript';
|
||||
|
||||
export interface Directory { [name: string]: (Directory|string); }
|
||||
|
||||
export class Host implements ts.LanguageServiceHost {
|
||||
private overrides = new Map<string, string>();
|
||||
private version = 1;
|
||||
|
||||
constructor(private directory: Directory, private scripts: string[]) {}
|
||||
|
||||
getCompilationSettings(): ts.CompilerOptions {
|
||||
return {
|
||||
experimentalDecorators: true,
|
||||
module: ts.ModuleKind.CommonJS,
|
||||
target: ts.ScriptTarget.ES5
|
||||
};
|
||||
}
|
||||
|
||||
getScriptFileNames(): string[] { return this.scripts; }
|
||||
|
||||
getScriptVersion(fileName: string): string { return this.version.toString(); }
|
||||
|
||||
getScriptSnapshot(fileName: string): ts.IScriptSnapshot|undefined {
|
||||
const content = this.getFileContent(fileName);
|
||||
if (content) return ts.ScriptSnapshot.fromString(content);
|
||||
}
|
||||
|
||||
fileExists(fileName: string): boolean { return this.getFileContent(fileName) != null; }
|
||||
|
||||
getCurrentDirectory(): string { return '/'; }
|
||||
|
||||
getDefaultLibFileName(options: ts.CompilerOptions): string { return 'lib.d.ts'; }
|
||||
|
||||
overrideFile(fileName: string, content: string) {
|
||||
this.overrides.set(fileName, content);
|
||||
this.version++;
|
||||
}
|
||||
|
||||
addFile(fileName: string) {
|
||||
this.scripts.push(fileName);
|
||||
this.version++;
|
||||
}
|
||||
|
||||
private getFileContent(fileName: string): string|undefined {
|
||||
if (this.overrides.has(fileName)) {
|
||||
return this.overrides.get(fileName);
|
||||
}
|
||||
if (fileName.endsWith('lib.d.ts')) {
|
||||
return fs.readFileSync(ts.getDefaultLibFilePath(this.getCompilationSettings()), 'utf8');
|
||||
}
|
||||
const current = open(this.directory, fileName);
|
||||
if (typeof current === 'string') return current;
|
||||
}
|
||||
}
|
||||
|
||||
export function open(directory: Directory, fileName: string): Directory|string|undefined {
|
||||
// Path might be normalized by the current node environment. But it could also happen that this
|
||||
// path directly comes from the compiler in POSIX format. Support both separators for development.
|
||||
const names = fileName.split(/[\\/]/);
|
||||
let current: Directory|string = directory;
|
||||
if (names.length && names[0] === '') names.shift();
|
||||
for (const name of names) {
|
||||
if (!current || typeof current === 'string') return undefined;
|
||||
current = current[name];
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
export class MockNode implements ts.Node {
|
||||
constructor(
|
||||
public kind: ts.SyntaxKind = ts.SyntaxKind.Identifier, public flags: ts.NodeFlags = 0,
|
||||
public pos: number = 0, public end: number = 0) {}
|
||||
getSourceFile(): ts.SourceFile { return null as any as ts.SourceFile; }
|
||||
getChildCount(sourceFile?: ts.SourceFile): number { return 0; }
|
||||
getChildAt(index: number, sourceFile?: ts.SourceFile): ts.Node { return null as any as ts.Node; }
|
||||
getChildren(sourceFile?: ts.SourceFile): ts.Node[] { return []; }
|
||||
getStart(sourceFile?: ts.SourceFile): number { return 0; }
|
||||
getFullStart(): number { return 0; }
|
||||
getEnd(): number { return 0; }
|
||||
getWidth(sourceFile?: ts.SourceFile): number { return 0; }
|
||||
getFullWidth(): number { return 0; }
|
||||
getLeadingTriviaWidth(sourceFile?: ts.SourceFile): number { return 0; }
|
||||
getFullText(sourceFile?: ts.SourceFile): string { return ''; }
|
||||
getText(sourceFile?: ts.SourceFile): string { return ''; }
|
||||
getFirstToken(sourceFile?: ts.SourceFile): ts.Node { return null as any as ts.Node; }
|
||||
getLastToken(sourceFile?: ts.SourceFile): ts.Node { return null as any as ts.Node; }
|
||||
forEachChild<T>(
|
||||
cbNode: (node: ts.Node) => T | undefined,
|
||||
cbNodeArray?: (nodes: ts.NodeArray<ts.Node>) => T | undefined): T|undefined {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
export class MockIdentifier extends MockNode implements ts.Identifier {
|
||||
public text: string;
|
||||
// tslint:disable
|
||||
public _primaryExpressionBrand: any;
|
||||
public _memberExpressionBrand: any;
|
||||
public _leftHandSideExpressionBrand: any;
|
||||
public _incrementExpressionBrand: any;
|
||||
public _unaryExpressionBrand: any;
|
||||
public _expressionBrand: any;
|
||||
public _updateExpressionBrand: any;
|
||||
// tslint:enable
|
||||
|
||||
constructor(
|
||||
public name: string, public kind: ts.SyntaxKind.Identifier = ts.SyntaxKind.Identifier,
|
||||
flags: ts.NodeFlags = 0, pos: number = 0, end: number = 0) {
|
||||
super(kind, flags, pos, end);
|
||||
this.text = name;
|
||||
}
|
||||
}
|
||||
|
||||
export class MockVariableDeclaration extends MockNode implements ts.VariableDeclaration {
|
||||
// tslint:disable-next-line
|
||||
public _declarationBrand: any;
|
||||
|
||||
constructor(
|
||||
public name: ts.Identifier,
|
||||
public kind: ts.SyntaxKind.VariableDeclaration = ts.SyntaxKind.VariableDeclaration,
|
||||
flags: ts.NodeFlags = 0, pos: number = 0, end: number = 0) {
|
||||
super(kind, flags, pos, end);
|
||||
}
|
||||
|
||||
static of (name: string): MockVariableDeclaration {
|
||||
return new MockVariableDeclaration(new MockIdentifier(name));
|
||||
}
|
||||
}
|
||||
|
||||
export class MockSymbol implements ts.Symbol {
|
||||
constructor(
|
||||
public name: string, private node: ts.Declaration = MockVariableDeclaration.of(name),
|
||||
public flags: ts.SymbolFlags = 0) {}
|
||||
|
||||
getFlags(): ts.SymbolFlags { return this.flags; }
|
||||
getName(): string { return this.name; }
|
||||
getDeclarations(): ts.Declaration[] { return [this.node]; }
|
||||
getDocumentationComment(): ts.SymbolDisplayPart[] { return []; }
|
||||
// TODO(vicb): removed in TS 2.2
|
||||
getJsDocTags(): any[] { return []; }
|
||||
|
||||
static of (name: string): MockSymbol { return new MockSymbol(name); }
|
||||
}
|
||||
|
||||
export function expectNoDiagnostics(diagnostics: ts.Diagnostic[]) {
|
||||
for (const diagnostic of diagnostics) {
|
||||
const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
|
||||
if (diagnostic.file && diagnostic.start) {
|
||||
const {line, character} = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
|
||||
// tslint:disable-next-line:no-console
|
||||
console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
|
||||
}
|
||||
}
|
||||
expect(diagnostics.length).toBe(0);
|
||||
}
|
||||
|
||||
export function expectValidSources(service: ts.LanguageService, program: ts.Program) {
|
||||
expectNoDiagnostics(service.getCompilerOptionsDiagnostics());
|
||||
for (const sourceFile of program.getSourceFiles()) {
|
||||
expectNoDiagnostics(service.getSyntacticDiagnostics(sourceFile.fileName));
|
||||
expectNoDiagnostics(service.getSemanticDiagnostics(sourceFile.fileName));
|
||||
}
|
||||
}
|
||||
|
||||
export function allChildren<T>(node: ts.Node, cb: (node: ts.Node) => T | undefined): T|undefined {
|
||||
return ts.forEachChild(node, child => cb(node) || allChildren(child, cb));
|
||||
}
|
||||
|
||||
export function findClass(sourceFile: ts.SourceFile, name: string): ts.ClassDeclaration|undefined {
|
||||
return ts.forEachChild(
|
||||
sourceFile, node => isClass(node) && isNamed(node.name, name) ? node : undefined);
|
||||
}
|
||||
|
||||
export function findVar(sourceFile: ts.SourceFile, name: string): ts.VariableDeclaration|undefined {
|
||||
return allChildren(
|
||||
sourceFile, node => isVar(node) && isNamed(node.name, name) ? node : undefined);
|
||||
}
|
||||
|
||||
export function findVarInitializer(sourceFile: ts.SourceFile, name: string): ts.Expression {
|
||||
const v = findVar(sourceFile, name);
|
||||
expect(v && v.initializer).toBeDefined();
|
||||
return v !.initializer !;
|
||||
}
|
||||
|
||||
export function isClass(node: ts.Node): node is ts.ClassDeclaration {
|
||||
return node.kind === ts.SyntaxKind.ClassDeclaration;
|
||||
}
|
||||
|
||||
export function isNamed(node: ts.Node | undefined, name: string): node is ts.Identifier {
|
||||
return !!node && node.kind === ts.SyntaxKind.Identifier && (<ts.Identifier>node).text === name;
|
||||
}
|
||||
|
||||
export function isVar(node: ts.Node): node is ts.VariableDeclaration {
|
||||
return node.kind === ts.SyntaxKind.VariableDeclaration;
|
||||
}
|
||||
Reference in New Issue
Block a user