59 lines
1.7 KiB
TypeScript
59 lines
1.7 KiB
TypeScript
import ParseNode from '/imports/parser/parseTree/ParseNode';
|
|
import ResolveFunction from '/imports/parser/types/ResolveFunction';
|
|
import TraverseFunction from '/imports/parser/types/TraverseFunction';
|
|
import MapFunction from '/imports/parser/types/MapFunction';
|
|
import ToStringFunction from '/imports/parser/types/ToStringFunction';
|
|
|
|
export type ParenthesisNode = {
|
|
parseType: 'parenthesis';
|
|
content: ParseNode;
|
|
}
|
|
|
|
type ParenthesisFactory = {
|
|
create(node: Partial<ParenthesisNode>): ParenthesisNode;
|
|
resolve: ResolveFunction<ParenthesisNode>;
|
|
toString: ToStringFunction<ParenthesisNode>;
|
|
traverse: TraverseFunction<ParenthesisNode>;
|
|
map: MapFunction<ParenthesisNode>;
|
|
}
|
|
|
|
const parenthesis: ParenthesisFactory = {
|
|
create({ content }: { content: ParseNode }) {
|
|
return {
|
|
parseType: 'parenthesis',
|
|
content,
|
|
};
|
|
},
|
|
async resolve(fn, node, scope, context, inputProvider, resolveOthers) {
|
|
const { result: content } = await resolveOthers(fn, node.content, scope, context, inputProvider);
|
|
if (
|
|
fn === 'reduce' ||
|
|
content.parseType === 'constant' ||
|
|
content.parseType === 'error'
|
|
) {
|
|
return { result: content, context };
|
|
} else {
|
|
return {
|
|
result: parenthesis.create({ content }),
|
|
context
|
|
};
|
|
}
|
|
},
|
|
toString(node, stringOthers) {
|
|
return `(${stringOthers(node.content)})`;
|
|
},
|
|
traverse(node, fn, traverseOthers) {
|
|
fn(node);
|
|
traverseOthers(node.content, fn);
|
|
},
|
|
async map(node, fn, mapOthers) {
|
|
const resultingNode = await fn(node);
|
|
if (resultingNode === node) {
|
|
node.content = await mapOthers(node.content, fn);
|
|
}
|
|
return resultingNode;
|
|
},
|
|
}
|
|
|
|
export default parenthesis;
|