js语法树转js

//js语法树节点类型－babel-eslint9
const typeMap= {
    'File':function (node) {
        return [node.program];
    },
    'Program':function (node) {
        return [node.body]
    },
    'Block':function (node) {
        return [
            '/*',
            node.value,
            '*/'
        ]
    },
    'CommentBlock':function (node) {
        return [
            '/*',
            node.value,
            '*/'
        ]
    },
    'Line':function (node) {
        return [
            '//',
            node.value
        ]
    },
    'CommentLine':function (node) {
        return [
            '//',
            node.value
        ]
    },
    'VariableDeclaration':function (node) {
        return [
            node.kind+' ',
            node.declarations,
        ];
    },
    'VariableDeclarator':function (node) {
        if(node.init===null){
            return [
                node.id,
                ';'
            ];
        }
        return [
            node.id,
            '=',
            node.init,
            ';'
        ];
    },
    'Identifier':function (node) {
        return node.name;
    },
    'CallExpression':function (node) {
        return [
            node.callee,
            '(',
            joinSymbol(node.arguments,','),
            ')'
        ];
    },
    'FunctionDeclaration':function (node) {
        return [
            node.async?'async ':'',
            node.generator?'function* ':'function ',
            node.id,
            '(',
            joinSymbol(node.params,','),
            ')',
            node.body,
        ];

    },
    'BlockStatement':function (node) {
        return [
            '{',
            node.body,
            '}',
        ];
    },
    'ReturnStatement':function (node) {
        return [
            'return ',
            node.argument||'',
            ';'
        ]
    },
    'Literal':function (node) {
        return node.raw;
    },
    'ExpressionStatement':function (node) {
        return [
            node.expression,
            ';'
        ]
    },
    'Property':function (node) {
        if(node.kind==='get'||node.kind==='set'){
            return [
                node.kind+' ',
                node.key,
                AstToString(node.value).replace('function','')
            ];
        }
        if(node.method){
            return [
                node.value.async?'async ':'',
                node.key,
                AstToString(node.value).replace('function','')
            ];
        }
        if(node.shorthand){
            return [
                node.value
            ];
        }

        return [
            node.key,
            ':',
            node.value
        ];
    },
    'DirectiveLiteral':function (node) {},
    'Directive':function (node) {},

    'Decorator':function (node) {
        return [
            '@',
            node.expression
        ];
    },
    'BreakStatement':function (node) {
        return [
            'break',
            node.label?[' ',node.label]:'',
            ';'
        ]
    },
    'ContinueStatement':function (node) {
        return 'continue;'
    },
    'DebuggerStatement':function (node) {
        return 'debugger;'
    },
    'DoWhileStatement':function (node) {
        return [
            'do',
            node.body,
            'while(',
            node.test,
            ')'
        ];
    },

    'IfStatement':function (node) {
        return [
            'if(',
            node.test,
            ')',
            node.consequent,
            node.alternate?[node.alternate.type==='IfStatement'?'else ':'else',node.alternate]:'',

        ];
    },

    'SwitchCase':function (node) {
        return [
            node.test?[
                'case ',
                node.test,
                ':'
            ]:'default:',

            node.consequent
        ];
    },
    'SwitchStatement':function (node) {
        return [
            'switch (',
            node.discriminant,
            '){',
            node.cases,
            '}'
        ];
    },
    'ThrowStatement':function (node) {
        return [
            'throw ',
            node.argument,
            ';'
        ];
    },
    'CatchClause':function (node) {
        return [
            'catch(',
            node.param,
            ')',
            node.body
        ];
    },
    'TryStatement':function (node) {
        return [
            'try',
            node.block,
            node.handler,
            node.finalizer?'finally':'',
            node.finalizer||'',
        ];
    },
    'WhileStatement':function (node) {
        return [
            'while(',
            node.test,
            ')',
            node.body
        ];
    },
    'WithStatement':function (node) {},
    'EmptyStatement':function (node) {return '';},
    'LabeledStatement':function (node) {
        return [
            node.label,
            ':',
            node.body,
        ];
    },

    'ForStatement':function (node) {
        return [
            'for(',
            AstToString(node.init).replace(';',''),
            ';',
            node.test,
            ';',
            node.update,
            ')',
            node.body,
        ];
    },
    'ForInStatement':function (node) {
        return [
            'for(',
            AstToString(node.left).replace(';',''),
            ' in ',
            node.right,
            ')',
            node.body,
        ];
    },

    'FunctionExpression':function (node) {
        return [
            'function(',
            joinSymbol(node.params,','),
            ')',
            node.body,
        ]
    },
    'ClassDeclaration':function (node) {
        return [
            node.decorators,
            'class ',
            node.id,
            node.superClass===null?'':[' extends ',node.superClass],
            node.body,

        ]
    },
    'ClassExpression':function (node) {
        return [
            'class ',
            node.id,
            node.superClass?['extends ',node.superClass]:'',
            node.body,
        ]
    },
    'ClassBody':function (node) {
        return [
            '{',
            node.body,
            '}'
        ];
    },
    'ClassProperty':function (node) {
        return [
            node.static?'static ':'',
            node.key,
            '=',
            node.value,
            ';'
        ]
    },
    'ClassMethod':function (node) {
        return [
            node.decorators,
            node.static?'static ':'',
            node.async?'async ':'',
            node.key,
            '(',
            joinSymbol(node.params,','),
            ')',
            node.body
        ]
    },
    'ExportNamespaceSpecifier':function (node) {},
    'ExportAllDeclaration':function (node) {},
    'ExportDefaultSpecifier':function (node) {},
    'ExportDefaultDeclaration':function (node) {
        return [
            'export default ',
            node.declaration,
            ';'
        ]
    },
    'ExportNamedDeclaration':function (node) {
        return [
            'export ',
            node.specifiers?joinSymbol(node.specifiers):'',
            node.declaration||"",
            ';'
        ]
    },
    'ExportSpecifier':function (node) {
        return [
            '{',
            node.exported,
            '}'
        ];
    },
    'ImportDeclaration':function (node) {
        const arr1=[]
        const arr2=[]

        node.specifiers.forEach(function (item,i) {
            if(item.type==='ImportSpecifier'){
                arr2.push(item);
            }else{
                arr1.push(item);
            }
        })

        return [
            'import ',
            node.specifiers.length?[
                    arr1,
                    arr2.length?[arr1.length>0?',':'','{',joinSymbol(arr2,','),'}']:'',
                    ' from ',
                ]:'',
            node.source,
            ';'
        ];
    },
    'ImportNamespaceSpecifier':function (node) {
        return [
            '* as',
            node.local
        ];
    },
    'ImportSpecifier':function (node) {
        if(node.imported.name===node.local.name){
            return [
                node.imported,
            ];
        }
        return [
            node.imported,
            ' as ',
            node.local,
        ];
    },
    'ImportDefaultSpecifier':function (node) {
        return [node.local]
    },
    'SpreadElement':function (node) {
        return [
            '...',
            node.argument
        ]
    },
    'RestElement':function (node) {
        return ['...',node.argument];
    },
    'ArrayPattern':function (node) {
        return [
            '[',
            joinSymbol(node.elements,','),
            ']'
        ];
    },
    'AssignmentPattern':function (node) {
        return [
            node.left,
            '=',
            node.right
        ];
    },
    'SequenceExpression':function (node) {
        return [
            joinSymbol(node.expressions,',')
        ];
    },
    'AssignmentExpression':function (node) {
        return [
            node.left,
            node.operator,
            node.right,
        ]
    },
    'ConditionalExpression':function (node) {
        return [
            node.test,
            '?',
            node.consequent,
            ':',
            node.alternate
        ]
    },
    'LogicalExpression':function (node) {
        return [
            node.left,
            node.operator,
            node.right,
        ]
    },
    'BinaryExpression':function (node) {
        return [
            node.extra && node.extra.parenthesized?'(':'',
            node.left,
            node.operator,
            node.right,
            node.extra && node.extra.parenthesized?')':'',
        ]
    },
    'UpdateExpression':function (node) {
        if(node.prefix){
            return [
                node.operator,
                node.argument,
            ]
        }else{
            return [
                node.argument,
                node.operator,
            ]
        }

    },
    'UnaryExpression':function (node) {
        if(node.prefix){
            return [
                node.operator,
                node.argument,
            ]
        }
    },
    'BindExpression':function (node) {},
    'MemberExpression':function (node) {
        if(node.computed){
            return [
                node.object,
                '[',
                node.property,
                ']'
            ];
        }
        return [
            node.object,
            '.',
            node.property,
        ];
    },

    'TaggedTemplateExpression':function (node) {
        return [
            node.tag,
            node.quasi,
        ];
    },
    'Super':function (node) {
        return 'Super'
    },
    'Import':function (node) {},
    'ThisExpression':function (node) {
        return 'this';
    },
    'DoExpression':function (node) {
        return [
            'do',
            node.body
        ]
    },
    'NullLiteral':function (node) {
        return 'null';
    },
    'BooleanLiteral':function (node) {
        return ''+node.value;
    },
    'ArrayExpression':function (node) {
        return [
            '[',
            joinSymbol(node.elements,','),
            ']'
        ]
    },
    'StringLiteral':function (node) {
        return node.extra.raw;
    },
    'NumericLiteral':function (node) {
        return node.extra.raw;
    },
    'RegExpLiteral':function (node) {
        return node.extra.raw;
    },
    'MetaProperty':function (node) {},
    'NewExpression':function (node) {
        return [
            'new ',
            node.callee,
            '(',
            joinSymbol(node.arguments,','),
            ')'
        ];
    },
    'TemplateElement':function (node) {
        return node.value.raw;
    },
    'TemplateLiteral':function (node) {
        const arr=[]
        arr.push('`');
        node.expressions.forEach(function (item,i) {
            arr.push(node.quasis[i])
            arr.push(['${',item,'}'])
        })
        arr.push(node.quasis[node.expressions.length])
        arr.push('`');
        return arr;
    },
    'ObjectPattern':function (node) {
        return [
            '{',
            joinSymbol(node.properties,','),
            '}',
        ];
    },
    'ObjectExpression':function (node) {
        return [
            '{',
            joinSymbol(node.properties,','),
            '}',
        ];
    },
    'ObjectMethod':function (node) {
        return [
            node.async?'async ':'',
            node.key,
            '(',
            joinSymbol(node.params,','),
            ')',
            node.body,
        ];
    },
    'ObjectProperty':function (node) {
        if(node.shorthand){
            return [node.value];
        }
        return [
            node.key,
            ':',
            node.value
        ]
    },
    'ArrowFunctionExpression':function (node) {
        return [
            node.async?'async ':'',
            '(',
            joinSymbol(node.params,','),
            ')=>',
            node.body,
        ];
    },
    'AwaitExpression':function (node) {
        return [
            'await ',
            node.argument
        ];
    },
    'YieldExpression':function (node) {
        return [
            node.delegate?'yield* ':'yield ',
            node.argument
        ]
    },
    'MethodDefinition':function (node) {
        return [
            node.decorators,
            node.static?'static ':'',
            node.kind==='method'&&node.value.async?'async ':'',
            node.key,
            AstToString(node.value).replace('function','')
        ]
    },
    'DeclaredPredicate':function (node) {},
    'InferredPredicate':function (node) {},
    'DeclareClass':function (node) {},
    'TypeAnnotation':function (node) {},
    'DeclareFunction':function (node) {},
    'DeclareExportDeclaration':function (node) {},
    'DeclareVariable':function (node) {},
    'DeclareModule':function (node) {},
    'DeclareModuleExports':function (node) {},
    'DeclareTypeAlias':function (node) {},
    'DeclareOpaqueType':function (node) {},
    'DeclareInterface':function (node) {},
    'InterfaceExtends':function (node) {},
    'InterfaceDeclaration':function (node) {},
    'TypeAlias':function (node) {},
    'OpaqueType':function (node) {},
    'TypeParameterDeclaration':function (node) {},
    'TypeParameterInstantiation':function (node) {},
    'ObjectTypeIndexer':function (node) {},
    'ObjectTypeProperty':function (node) {},
    'ObjectTypeCallProperty':function (node) {},
    'ObjectTypeSpreadProperty':function (node) {},
    'ObjectTypeAnnotation':function (node) {},
    'QualifiedTypeIdentifier':function (node) {},
    'GenericTypeAnnotation':function (node) {},
    'TypeofTypeAnnotation':function (node) {},
    'TupleTypeAnnotation':function (node) {},
    'FunctionTypeParam':function (node) {},
    'AnyTypeAnnotation':function (node) {},
    'VoidTypeAnnotation':function (node) {},
    'BooleanTypeAnnotation':function (node) {},
    'MixedTypeAnnotation':function (node) {},
    'EmptyTypeAnnotation':function (node) {},
    'NumberTypeAnnotation':function (node) {},
    'StringTypeAnnotation':function (node) {},
    'FunctionTypeAnnotation':function (node) {},
    'StringLiteralTypeAnnotation':function (node) {},
    'BooleanLiteralTypeAnnotation':function (node) {},
    'NullLiteralTypeAnnotation':function (node) {},
    'NumericLiteralTypeAnnotation':function (node) {},
    'ThisTypeAnnotation':function (node) {},
    'ExistentialTypeParam':function (node) {},
    'ArrayTypeAnnotation':function (node) {},
    'NullableTypeAnnotation':function (node) {},
    'IntersectionTypeAnnotation':function (node) {},
    'UnionTypeAnnotation':function (node) {},
    'TypeCastExpression':function (node) {},
    'ClassImplements':function (node) {},
    'ExperimentalRestProperty':function (node) {
        return [
            '...',
            node.argument
        ]
    },


    'JSXEmptyExpression':function (node) {
        return '';
    },
    'JSXSpreadChild':function (node) {},
    'JSXExpressionContainer':function (node) {
        return [
            '{',
            node.expression,
            '}',
        ];
    },
    'JSXSpreadAttribute':function (node) {
        return [
            '{...',
            node.argument,
            '}'
        ];
    },
    'JSXAttribute':function (node) {
        return [
            node.name,
            '=',
            node.value,
        ];
    },
    'JSXIdentifier':function (node) {
        return node.name;
    },
    'JSXNamespacedName':function (node) {},
    'JSXMemberExpression':function (node) {},
    'JSXOpeningElement':function (node) {
        return [
            '<',
            node.name,
            node.attributes.length?[' ',joinSymbol(node.attributes,' ')]:'',
            node.selfClosing?' /':'',
            '>'
        ];
    },
    'JSXClosingElement':function (node) {
        return [
            '</',
            node.name,
            '>'
        ];
    },
    'JSXElement':function (node) {
        return [
            node.extra && node.extra.parenthesized?'(':'',
            node.openingElement,
            node.children,
            node.closingElement||'',
            node.extra && node.extra.parenthesized?')':'',
        ];
    },
}
//语法树转string
function AstChildToString(children) {
    let str='';
    children.forEach(function (node) {
        str+=AstToString(node)
    })
    return str;
}
//元素之间添加符号
function joinSymbol(oriArr,symbol,pre) {
    if(oriArr.length===0){return '';}
    const arr=[];
    if(pre){
        arr.push(pre)
    }
    oriArr.forEach(function (node,i) {
        arr.push(node);
        if(i<oriArr.length-1){
            arr.push(symbol);
        }
    })
    if(pre){
        arr.push(pre)
    }
    return arr;
}
//语法树转string
function AstToString(ast){
    if(Object.prototype.toString.call(ast)==='[object Array]'){
        return AstChildToString(ast);
    }else if(Object.prototype.toString.call(ast)==='[object String]'){
        return ast;
    }else if(ast===null){
        return '';
    }
    let code=typeMap[ast.type](ast);

    if(Object.prototype.toString.call(code)==='[object Array]'){
        const arr=code.map(function(obj){
            if(Object.prototype.toString.call(obj)==='[object Object]'){
                return AstToString(obj);
            }else if(Object.prototype.toString.call(obj)==='[object Array]'){
                return AstToString(obj);
            }
            return obj;
        })
        return arr.join('');
    }else{
        return code;
    }

}
module.exports=AstToString;