public void Analyze_Parentheses_ReturnsParenthesesNode()
{
Environment environment = new Environment();
environment.AddSymbol("x");
SyntaxNode root = new ParenthesesNode(new IdentifierNode("x"));
root = SemanticAnalyzer.Analyze(root, environment);
Assert.AreEqual("(x)", root.ToString());
}
private static SyntaxNode Analyze(SyntaxNode node)
{
switch (node.Type)
{
case SyntaxNodeType.Identifier:
return(AnalyzeIdentifier((IdentifierNode)node));
case SyntaxNodeType.AmbigiousFunctionOrShortHandMultiplication:
return(AnalyzeAmbiguousFunctionOrDistribution((FunctionOrDistributionNode)node));
case SyntaxNodeType.Number:
return(node);
case SyntaxNodeType.Parentheses:
ParenthesesNode parenthesesNode = (ParenthesesNode)node;
parenthesesNode.Expression = Analyze(parenthesesNode.Expression);
return(parenthesesNode);
case SyntaxNodeType.Operator:
OperatorNode operatorNode = (OperatorNode)node;
List <SyntaxNode> newOperands = new List <SyntaxNode>();
foreach (SyntaxNode operand in operatorNode.Operands)
{
newOperands.Add(Analyze(operand));
}
operatorNode.Operands = newOperands;
return(AnalyzeOperator(operatorNode));
case SyntaxNodeType.Function:
FunctionNode functionNode = (FunctionNode)node;
functionNode.Name = (IdentifierNode)Analyze(functionNode.Name);
List <SyntaxNode> newArguments = new List <SyntaxNode>();
foreach (SyntaxNode argument in functionNode.Arguments)
{
newArguments.Add(Analyze(argument));
}
functionNode.Arguments = newArguments;
return(functionNode);
default:
throw new System.ArgumentException($"Unknown syntax node type '{node.Type}'");
}
}
public void Analyze_Parentheses_ThrowsException()
{
ParenthesesNode node = new ParenthesesNode(new IdentifierNode("x"));
Assert.Throws <UndefinedSymbolException>(() => SemanticAnalyzer.Analyze(node, new Environment()));
}
