angular-cn/tools/transpiler/index.js

239 lines
8.7 KiB
JavaScript

// Entry point for Node.
var fs = require('fs');
var glob = require('glob');
var path = require('path');
var traceur = require('traceur');
var assert = require('assert');
exports.RUNTIME_PATH = traceur.RUNTIME_PATH;
var TRACEUR_PATH = traceur.RUNTIME_PATH.replace('traceur-runtime.js', 'traceur.js');
var SELF_SOURCE_REGEX = /transpiler\/src/;
var SELF_COMPILE_OPTIONS = {
modules: 'register',
memberVariables: false,
moduleName: true,
script: false // parse as a module
};
var needsReload = true;
var oldSystemGet = System.get;
exports.reloadSources = function() {
needsReload = true;
};
exports.compile = function compile(options, paths, source, reloadTraceur) {
if (needsReload) {
reloadCompiler(reloadTraceur);
needsReload = false;
}
var inputPath, outputPath, moduleName;
if (typeof paths === 'string') {
inputPath = outputPath = paths;
} else {
inputPath = paths.inputPath;
outputPath = paths.inputPath;
moduleName = paths.moduleName;
}
outputPath = outputPath || inputPath;
moduleName = moduleName || inputPath;
moduleName = moduleName.replace(/\.\w*$/, '');
var CompilerCls = System.get('transpiler/src/compiler').Compiler;
var compiler = new CompilerCls(options, moduleName);
var result = {
js: compiler.compile(source, inputPath, outputPath),
sourceMap: null
};
var sourceMapString = compiler.getSourceMap();
if (sourceMapString) {
result.sourceMap = JSON.parse(sourceMapString);
}
if (options.outputLanguage === 'es6' && source.indexOf('$traceurRuntime') === -1) {
assert(result.js.indexOf('$traceurRuntime') === -1,
'Transpile to ES6 must not add references to $traceurRuntime, '
+ inputPath + ' is transpiled to:\n' + result.js);
}
return result;
};
exports.init = function() {
if (needsReload) {
reloadCompiler();
needsReload = false;
}
}
// Transpile and evaluate the code in `src`.
// Use existing traceur to compile our sources.
function reloadCompiler(reloadTraceur) {
if (reloadTraceur) {
loadModule(TRACEUR_PATH, false);
}
glob.sync(__dirname + '/src/**/*.js').forEach(function(fileName) {
loadModule(fileName, true);
});
// Traceur modules are register with the ".js" extension but we don't want
// to add it to all the import statements.
System.get = function get(normalizedName) {
var m = oldSystemGet.call(this, normalizedName);
if (!m && normalizedName.indexOf('traceur') == 0) {
m = oldSystemGet.call(this, normalizedName + '.js');
}
return m;
};
useRttsAssertModuleForConvertingTypesToExpressions();
supportSuperCallsInEs6Patch();
convertTypesToExpressionsInEs6Patch();
disableGetterSetterAssertionPatch();
patchCommonJSModuleTransformerToSupportExportStar();
}
function loadModule(filepath, transpile) {
var data = fs.readFileSync(filepath, 'utf8');
if (!data) {
throw new Error('Failed to import ' + filepath);
}
if (transpile) {
var moduleName = path.normalize(filepath)
.replace(__dirname, 'transpiler')
.replace(/\\/g, '/')
.replace(/\.\w*$/, '');
data = traceur.compile(data, SELF_COMPILE_OPTIONS, moduleName);
}
('global', eval)(data);
}
function extend(source, props) {
var res = {};
for (var prop in source) {
res[prop] = source[prop];
}
for (var prop in props) {
res[prop] = props[prop];
}
return res;
}
// TODO(tbosch): remove when traceur is fixed.
// see https://github.com/google/traceur-compiler/issues/1700
function supportSuperCallsInEs6Patch() {
var traceurVersion = System.map['traceur'];
var ParseTreeMapWriter = System.get(traceurVersion+'/src/outputgeneration/ParseTreeMapWriter').ParseTreeMapWriter;
var _enterBranch = ParseTreeMapWriter.prototype.enterBranch;
ParseTreeMapWriter.prototype.enterBranch = function(location) {
if (!location.start) {
// This would throw...
return;
}
return _enterBranch.apply(this, arguments);
}
}
// TODO(tbosch): Remove when traceur is fixed.
// see https://github.com/google/traceur-compiler/issues/1699
function convertTypesToExpressionsInEs6Patch() {
var traceurVersion = System.map['traceur'];
var TypeToExpressionTransformer = System.get(traceurVersion+'/src/codegeneration/TypeToExpressionTransformer').TypeToExpressionTransformer;
var PureES6Transformer = System.get(traceurVersion+'/src/codegeneration/PureES6Transformer').PureES6Transformer;
var UniqueIdentifierGenerator = System.get(traceurVersion+'/src/codegeneration/UniqueIdentifierGenerator').UniqueIdentifierGenerator;
var _transform = PureES6Transformer.prototype.transform;
PureES6Transformer.prototype.transform = function() {
if (!this._patched) {
this._patched = true;
var self = this;
this.treeTransformers_.splice(0,0, function(tree) {
return new TypeToExpressionTransformer(new UniqueIdentifierGenerator(), self.reporter_, self.options_).transformAny(tree);
});
}
return _transform.apply(this, arguments);
};
}
// TODO(tbosch): Disable getter/setters for assertions until traceur has a flag
// that allows to disable them while keeping assertions and member fields enabled.
// see https://github.com/google/traceur-compiler/issues/1625
// Why:
// - traceur uses field names based on numbers, which can lead to collisions when creating a subclass in a separate compiler run.
// - this rename of fields makes debugging via the repl harder (e.g. via DevTools console)
// - this rename can break JSON conversion of instances
function disableGetterSetterAssertionPatch() {
var traceurVersion = System.map['traceur'];
var MemberVariableTransformer = System.get(traceurVersion+'/src/codegeneration/MemberVariableTransformer').MemberVariableTransformer;
var AnonBlock = System.get(traceurVersion+'/src/syntax/trees/ParseTrees.js').AnonBlock;
MemberVariableTransformer.prototype.transformPropertyVariableDeclaration = function(tree) {
return new AnonBlock(tree.location, []);
}
}
// TODO(tbosch): Get all types from `assert` module and not from `$traceurRuntime`.
// With this a transpile to ES6 does no more include the `$traceurRuntime`.
// see https://github.com/google/traceur-compiler/issues/1706
function useRttsAssertModuleForConvertingTypesToExpressions() {
var traceurVersion = System.map['traceur'];
var original = System.get(traceurVersion+'/src/codegeneration/TypeToExpressionTransformer').TypeToExpressionTransformer;
var patch = System.get('transpiler/src/patch/TypeToExpressionTransformer').TypeToExpressionTransformer;
for (var prop in patch.prototype) {
original.prototype[prop] = patch.prototype[prop];
}
var TypeAssertionTransformer = System.get(traceurVersion+'/src/codegeneration/TypeAssertionTransformer').TypeAssertionTransformer;
var createIdentifierExpression = System.get(traceurVersion+'/src/codegeneration/ParseTreeFactory').createIdentifierExpression;
var parseExpression = System.get(traceurVersion+'/src/codegeneration/PlaceholderParser.js').parseExpression;
TypeAssertionTransformer.prototype.transformBindingElementParameter_ = function(element, typeAnnotation) {
// Copied from https://github.com/google/traceur-compiler/commits/master/src/codegeneration/TypeAssertionTransformer.js
if (!element.binding.isPattern()) {
if (typeAnnotation) {
this.paramTypes_.atLeastOneParameterTyped = true;
} else {
// PATCH start
typeAnnotation = parseExpression(["assert.type.any"]);
// PATCH end
}
this.paramTypes_.arguments.push(
createIdentifierExpression(element.binding.identifierToken),
typeAnnotation);
return;
}
// NYI
}
}
// TODO(tbosch): patch exports for CommonJS to support `export * from ...`
// see https://github.com/google/traceur-compiler/issues/1042
function patchCommonJSModuleTransformerToSupportExportStar() {
var traceurVersion = System.map['traceur'];
var CommonJsModuleTransformer = System.get(traceurVersion+'/src/codegeneration/CommonJsModuleTransformer').CommonJsModuleTransformer;
var parseStatement = System.get(traceurVersion+'/src/codegeneration/PlaceholderParser.js').parseStatement;
var prependStatements = System.get(traceurVersion+"/src/codegeneration/PrependStatements.js").prependStatements;
var _wrapModule = CommonJsModuleTransformer.prototype.wrapModule;
CommonJsModuleTransformer.prototype.wrapModule = function(statements) {
if (this.hasStarExports()) {
var last = statements[statements.length - 1];
statements = statements.slice(0, -1);
var exportObject = last.expression;
if (exportObject.propertyNameAndValues) {
throw new Error('Don\'t support export * with named exports right now...');
}
statements.push(parseStatement(['module.exports = ', ';'], exportObject));
return statements;
} else {
return _wrapModule.apply(this, arguments);
}
}
}