roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/rewriter/coverage-macro/src/templates.rs

@@ -0,0 +1,192 @@
+//! JS source templates for each AST node type.
+//!
+//! Each template is a string with named holes like `{BODY}` that get filled
+//! by the witness composer. Templates are kept minimal — the goal is to
+//! produce a tiny program that exhibits the missed rewrite.
+//!
+//! Templates use a single hole `{X}` whose name matches a field/variant name
+//! in the AST table. The composer substitutes either:
+//! - the chosen path's next node (for the field/variant on the path), or
+//! - the `placeholder()` for the field's type (for all other holes).
+
+pub fn template(node: &str) -> &'static str {
+    match node {
+        "Program" => "{body}",
+        "Statement" => "{variant}",
+        "ExpressionStatement" => "{expression};",
+        "Expression" => "{variant}",
+        "IdentifierReference" => "location",
+        "ThisExpression" => "this",
+        "Super" => "super",
+        "ArrayExpression" => "[{elements}]",
+        "ArrayExpressionElement" => "{variant}",
+        "Elision" => "",
+        "SpreadElement" => "...{argument}",
+        "ObjectExpression" => "({{{properties}}})",
+        "ObjectPropertyKind" => "{variant}",
+        "ObjectProperty" => "{key}: {value}",
+        "PropertyKey" => "{variant}",
+        "StaticIdentifier" => "k",
+        "IdentifierName" => "k",
+        "BindingIdentifier" => "x",
+        "StringLiteral" => "\"s\"",
+        "NumericLiteral" => "0",
+        "BigIntLiteral" => "0n",
+        "RegExpLiteral" => "/r/",
+        "BooleanLiteral" => "true",
+        "NullLiteral" => "null",
+        "Directive" => "\"use strict\";",
+        "PrivateIdentifier" => "#p",
+        "TemplateElement" => "",
+
+        "FunctionExpression" => "(function(){body}}",
+        "Function" => "function f({params}){body}",
+        "FunctionDeclaration" => "function f({params}){body}",
+        "ArrowFunctionExpression" => "(({params}) => {body})",
+        "FormalParameters" => "{items}",
+        "FormalParameter" => "{pattern}",
+        "BindingRestElement" => "...{argument}",
+        "FunctionBody" => "{{{statements}}}",
+        "ClassExpression" => "(class{body})",
+        "ClassDeclaration" => "class C{body}",
+        "ClassBody" => "{{{body}}}",
+        "ClassElement" => "{variant}",
+        "MethodDefinition" => "{key}(){{}}",
+        "PropertyDefinition" => "{key}={value};",
+        "StaticBlock" => "static{{{body}}}",
+        "AccessorProperty" => "accessor {key}={value};",
+
+        "UnaryExpression" => "(!{argument})",
+        "UpdateExpression" => "({argument}++)",
+        "BinaryExpression" => "({left}+{right})",
+        "LogicalExpression" => "({left}||{right})",
+        "ConditionalExpression" => "({test}?{consequent}:{alternate})",
+        "SequenceExpression" => "({expressions})",
+        "ParenthesizedExpression" => "({expression})",
+        "AwaitExpression" => "(await {argument})",
+        "YieldExpression" => "(yield {argument})",
+        "ChainExpression" => "({expression})",
+        "ChainElement" => "{variant}",
+        "TemplateLiteral" => "`{quasis}{expressions}`",
+        "TaggedTemplateExpression" => "{tag}{quasi}",
+
+        "CallExpression" => "{callee}({arguments})",
+        "NewExpression" => "(new {callee}({arguments}))",
+        "Argument" => "{variant}",
+        "MemberExpression" => "{variant}",
+        "StaticMemberExpression" => "{object}.{property}",
+        "ComputedMemberExpression" => "{object}[{expression}]",
+        "PrivateFieldExpression" => "{object}.{field}",
+        "ImportExpression" => "import({source}{options})",
+        "MetaProperty" => "{meta}.{property}",
+        "AssignmentExpression" => "({left}={right})",
+
+        "AssignmentTarget" => "{variant}",
+        "AssignmentTargetIdentifier" => "x",
+        "SimpleAssignmentTarget" => "{variant}",
+        "ObjectAssignmentTarget" => "({{{properties}}})",
+        "ArrayAssignmentTarget" => "[{elements}]",
+        "AssignmentTargetRest" => "...{target}",
+        "AssignmentTargetMaybeDefault" => "{variant}",
+        "AssignmentTargetWithDefault" => "{binding}={init}",
+        "AssignmentTargetProperty" => "{variant}",
+        "AssignmentTargetPropertyIdentifier" => "x={init}",
+        "AssignmentTargetPropertyProperty" => "{name}:{binding}",
+
+        "BindingPattern" => "{kind}",
+        "BindingPatternKind" => "{variant}",
+        "ObjectPattern" => "{{{properties}}}",
+        "ArrayPattern" => "[{elements}]",
+        "AssignmentPattern" => "{left}={right}",
+        "BindingProperty" => "{key}:{value}",
+
+        "BlockStatement" => "{{{body}}}",
+        "BreakStatement" => "break;",
+        "ContinueStatement" => "continue;",
+        "DebuggerStatement" => "debugger;",
+        "EmptyStatement" => ";",
+        "IfStatement" => "if({test}){consequent}",
+        "DoWhileStatement" => "do{body}while({test});",
+        "WhileStatement" => "while({test}){body}",
+        "ForStatement" => "for({init};{test};{update}){body}",
+        "ForStatementInit" => "{variant}",
+        "ForInStatement" => "for({left} in {right}){body}",
+        "ForOfStatement" => "for({left} of {right}){body}",
+        "ForStatementLeft" => "{variant}",
+        "LabeledStatement" => "L:{body}",
+        "ReturnStatement" => "return {argument};",
+        "SwitchStatement" => "switch({discriminant}){{{cases}}}",
+        "SwitchCase" => "case {test}:{consequent}",
+        "ThrowStatement" => "throw {argument};",
+        "TryStatement" => "try{block}{handler}",
+        "CatchClause" => "catch({param}){body}",
+        "CatchParameter" => "{pattern}",
+        "WithStatement" => "with({object}){body}",
+        "VariableDeclaration" => "var {declarations};",
+        "VariableDeclarator" => "{id}={init}",
+        "ImportDeclaration" => "import {specifiers} from {source};",
+        "ImportDeclarationSpecifier" => "{variant}",
+        "ImportSpecifier" => "{{{local}}}",
+        "ImportDefaultSpecifier" => "{local}",
+        "ImportNamespaceSpecifier" => "* as {local}",
+        "ExportAllDeclaration" => "export * from {source};",
+        "ExportDefaultDeclaration" => "export default {declaration};",
+        "ExportDefaultDeclarationKind" => "{variant}",
+        "ExportNamedDeclaration" => "export {{{specifiers}}};",
+        "Declaration" => "{variant}",
+        "ExportSpecifier" => "{local} as {exported}",
+        "ModuleExportName" => "{variant}",
+
+        _ => "/* ?? */",
+    }
+}
+
+/// A minimal stub for a node type when we don't care about its contents
+/// (it's an off-path sibling of the witness chain).
+pub fn placeholder(node: &str) -> &'static str {
+    match node {
+        "Expression" => "0",
+        "Statement" => ";",
+        "Argument" => "0",
+        "ArrayExpressionElement" => "0",
+        "ObjectPropertyKind" => "k:0",
+        "ObjectProperty" => "k:0",
+        "PropertyKey" => "k",
+        "StaticIdentifier" => "k",
+        "IdentifierName" => "k",
+        "BindingIdentifier" => "x",
+        "AssignmentTarget" => "x",
+        "AssignmentTargetIdentifier" => "x",
+        "SimpleAssignmentTarget" => "x",
+        "AssignmentTargetMaybeDefault" => "x",
+        "AssignmentTargetProperty" => "k:x",
+        "BindingPattern" => "x",
+        "BindingPatternKind" => "x",
+        "BindingProperty" => "k:x",
+        "FormalParameters" => "",
+        "FormalParameter" => "x",
+        "FunctionBody" => "{}",
+        "BlockStatement" => "{}",
+        "StringLiteral" => "\"\"",
+        "NumericLiteral" => "0",
+        "BindingRestElement" => "...r",
+        "PrivateIdentifier" => "#p",
+        "TemplateElement" => "",
+        "Directive" => "",
+        "ImportDeclarationSpecifier" => "x",
+        "ImportSpecifier" => "{x}",
+        "ExportSpecifier" => "x",
+        "ExportDefaultDeclarationKind" => "0",
+        "Declaration" => "var x;",
+        "ModuleExportName" => "x",
+        "AssignmentTargetRest" => "...x",
+        "CatchClause" => "catch(e){}",
+        "CatchParameter" => "e",
+        "SwitchCase" => "default:",
+        "ChainElement" => "f()",
+        "MemberExpression" => "o.p",
+        "ClassBody" => "{}",
+        "ClassElement" => "",
+        _ => "",
+    }
+}