Merge pull request #1 from fabiandev/ts-emit

Transformations with unofficial TypeScript API

Author: fabiandev

package.json

@@ -17,9 +17,10 @@
     "escodegen": "^1.8.1",
     "esprima": "^3.1.3",
     "flow-runtime": "^0.2.1",
+    "node-require-fallback": "^0.1.2",
     "tcomb": "^3.2.16",
     "ts-type-info": "^6.2.2",
     "tspoon": "^1.0.254",
-    "typescript": "^2.1.5"
+    "typescript": "Microsoft/TypeScript#6c122bcf16c329a21da04d7b5256f20ecc0bbd1d"
   }
 }

src/compiler/Compiler.ts

@@ -1,11 +1,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { TranspilerOutput, Visitor, transpile } from 'tspoon';
-import { TsRuntimeOptions } from '../options';
-import { CompilerResult } from './CompilerResult';
-import { CompilerConfig } from './CompilerConfig';
-import { FileResult } from './FileResult';
-import * as DEFAULT_VISITORS from './visitors/default_visitors';
+import * as ts from 'typescript/built/local/typescript';
+import CompilerResult from './CompilerResult';
+import CompilerConfig from './CompilerConfig';
+import FileResult from './FileResult';
+import { Transformer, DEFAULT_TRANSFORMERS } from './transformers';
 
 export class Compiler {
 
@@ -16,8 +15,21 @@ export class Compiler {
   public process(): Promise<CompilerResult> {
     const toTransform: Array<Promise<FileResult>> = [];
 
+    const transformers: ts.Transformer[] = Object.keys(DEFAULT_TRANSFORMERS).map((key: string) => {
+      const transformer = new (DEFAULT_TRANSFORMERS as any)[key]();
+
+      const transform: ts.Transformer = (context) => (f) => {
+        for (const substitution of transformer.getSubstitutions()) {
+          context.enableSubstitution(substitution);
+        }
+        context.onSubstituteNode = transformer.process.bind(transformer);
+        return f;
+      };
+      return transform;
+    });
+
     for (const file of this.config.files) {
-      toTransform.push(this.transformFile(file));
+      toTransform.push(this.transformFile(file, transformers));
     }
 
     return Promise.all(toTransform)
@@ -26,56 +38,40 @@ export class Compiler {
           config: this.config,
           fileResults: results,
         };
+      })
+      .catch(err => {
+        console.error(err);
       });
   }
 
-  private transformFile(file: string): Promise<FileResult> {
+  private transformFile(filePath: string, transformers: ts.Transformer[]): Promise<FileResult> {
     return new Promise((resolve, reject) => {
-      fs.readFile(file, this.config.options.encoding, (err, source) => {
+      fs.readFile(filePath, this.config.options.encoding, (err, source) => {
         if (err) {
-          return reject(`Error reading file ${file}`);
+          return reject(`Error reading file ${filePath}`);
         }
 
-        const visitors = Object.keys(DEFAULT_VISITORS).map((key: string) => {
-          return new (DEFAULT_VISITORS as any)[key]();
-        });
+        const fileName = path.basename(filePath);
 
-        const transpiler = transpile(source, {
-          compilerOptions: this.config.options.compilerOptions,
-          sourceFileName: path.basename(file),
-          visitors,
-        });
+        const f = ts.createSourceFile(
+          fileName,
+          source,
+          this.config.options.compilerOptions.target || ts.ScriptTarget.Latest,
+          true,
+          ts.ScriptKind.TS,
+        );
 
-        this.reportFile(transpiler);
+        const result = ts.emit(f, transformers).result;
 
         resolve({
-          transpiler,
-          file,
+          fileName,
+          filePath,
+          result,
         });
       });
     });
   }
 
-  private reportFile(transpiler: TranspilerOutput): boolean {
-    if (transpiler.diags) {
-      for (const d of transpiler.diags) {
-        const position = d.file.getLineAndCharacterOfPosition(d.start);
-
-        const name = d.file.fileName;
-        const line = position.line + 1;
-        const character = position.character;
-        const text = d.messageText;
-
-        console.error(`-> ${name}:${line}:${character}:${text}`);
-      }
-    }
-
-    if (transpiler.halted) {
-      console.error('Transpiler halted. Exiting now.');
-      process.exit(1);
-    }
-
-    return !!transpiler.diags;
-  }
-
 }
+
+export default Compiler;

src/compiler/CompilerConfig.ts

@@ -1,7 +1,9 @@
-import { TsRuntimeOptions } from '../options/TsRuntimeOptions';
-import { FileResult } from './FileResult';
+import Options from '../options/Options';
+import FileResult from './FileResult';
 
 export interface CompilerConfig {
   files: string[];
-  options: TsRuntimeOptions;
+  options: Options;
 }
+
+export default CompilerConfig;

src/compiler/CompilerResult.ts

@@ -1,7 +1,9 @@
-import { FileResult } from './FileResult';
-import { CompilerConfig } from './CompilerConfig';
+import FileResult from './FileResult';
+import CompilerConfig from './CompilerConfig';
 
 export interface CompilerResult {
   config: CompilerConfig;
   fileResults: FileResult[];
 }
+
+export default CompilerResult;

src/compiler/FileResult.ts

@@ -1,6 +1,7 @@
-import { TranspilerOutput } from 'tspoon';
-
 export interface FileResult {
-  transpiler: TranspilerOutput;
-  file: string;
+  result: string;
+  filePath: string;
+  fileName: string
 }
+
+export default FileResult;

src/compiler/generators.ts renamed to src/compiler/_archive/generators.ts

@@ -62,6 +62,10 @@ export function typeCalls(type: ts.TypeNode): null | any {
         return callExpression;
       }
     default:
-      throw new Error('Node Type not supported.');
+      {
+        const callExpression = utils.ast.getCallExpression('any');
+        return callExpression;
+      }
+    // throw new Error('Node Type not supported.');
   }
 }

src/compiler/_archive/generators/class_definition.ts

@@ -5,6 +5,8 @@ import * as utils from '../utils';
 export function variableAssignment(name: string, assignment: ts.Expression) {
   const text = assignment.getText();
   const callExpression = utils.ast.getCallExpression('assert', `_${name}Type`);
+  // const transpiled = ts.transpileModule(assignment.getText(), {});
+  // console.log(transpiled);
   const toAssert = esprima.parse(assignment.getText()).body.pop();
 
   callExpression.arguments.push((toAssert as any).expression);