@bitloops/bl-transpiler/lib/esm/src/Transpiler.js

The one and only Bitloops Language transpiler

import { isIntermediateASTValidationErrors, isOriginalParserOrIntermediateASTError, } from './ast/core/guards/index.js';
import { isParserErrors } from './parser/core/guards/index.js';
import { isTargetGeneratorError } from './target/typescript-nest/guards/index.js';
import { SemanticAnalyzer } from './semantic-analysis/IntermediateASTValidator.js';
export default class Transpiler {
    parser;
    originalLanguageASTToIntermediateModelTransformer;
    intermediateASTModelToTargetLanguageGenerator;
    constructor(parser, originalLanguageASTToIntermediateModelTransformer, intermediateASTModelToTargetLanguageGenerator) {
        this.parser = parser;
        this.originalLanguageASTToIntermediateModelTransformer = originalLanguageASTToIntermediateModelTransformer;
        this.intermediateASTModelToTargetLanguageGenerator = intermediateASTModelToTargetLanguageGenerator;
    }
    transpile(transpileInputData, options) {
        const intermediateModel = this.bitloopsCodeToIntermediateModel(transpileInputData);
        if (isOriginalParserOrIntermediateASTError(intermediateModel)) {
            return intermediateModel;
        }
        const completedIntermediateModel = this.completeIntermediateModel(intermediateModel);
        const targetCode = this.intermediateASTModelToTargetLanguage(completedIntermediateModel, options);
        return targetCode;
    }
    bitloopsCodeToIntermediateModel(transpileInputData) {
        const originalAST = this.bitloopsCodeToOriginalAST(transpileInputData);
        if (isParserErrors(originalAST)) {
            return originalAST;
        }
        const intermediateModel = this.originalASTToIntermediateModel(originalAST);
        const validatedIntermediateModel = this.validateIntermediateModel(intermediateModel);
        return validatedIntermediateModel;
    }
    getSymbolTable(inputData) {
        const originalAST = this.bitloopsCodeToOriginalAST(inputData);
        if (isParserErrors(originalAST)) {
            return originalAST;
        }
        const ast = this.originalASTToIntermediateModel(originalAST);
        const validator = new SemanticAnalyzer();
        return validator.getSymbolTable(ast);
    }
    bitloopsCodeToOriginalAST(parseInputData) {
        return this.parser.parse(parseInputData);
    }
    originalASTToIntermediateModel(originalLanguageAST) {
        return this.originalLanguageASTToIntermediateModelTransformer.parse(originalLanguageAST);
    }
    intermediateASTModelToTargetLanguage(ASTModel, options) {
        return this.intermediateASTModelToTargetLanguageGenerator.generate(ASTModel, options);
    }
    validateIntermediateModel(intermediateModel) {
        const validator = new SemanticAnalyzer();
        const validationResult = validator.validate(intermediateModel);
        if (isIntermediateASTValidationErrors(validationResult)) {
            return validationResult;
        }
        return intermediateModel;
    }
    completeIntermediateModel(intermediateModel) {
        return this.originalLanguageASTToIntermediateModelTransformer.complete(intermediateModel);
    }
    // TODO: remove duplication of transpile errors
    static isTranspileError(value) {
        if (!isParserErrors(value) &&
            !isIntermediateASTValidationErrors(value) &&
            !isTargetGeneratorError(value)) {
            return false;
        }
        return true;
    }
    static isTranspilerError(value) {
        return Array.isArray(value) && value.every((v) => v instanceof Error);
    }
}
//# sourceMappingURL=Transpiler.js.map