public void New_ListOfMyClassChild()
{
var target = TestSuite.GetGrammar();
var result = target.Statements.Parse(@"new List<MyClass.Child>();");
result.Should().MatchAst(
new NewNode
{
Type = new TypeNode
{
Name = new IdentifierNode("List"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode
{
Name = new IdentifierNode("MyClass"),
Child = new TypeNode("Child")
}
}
},
Arguments = ListNode <AstNode> .Default()
}
);
}
public void ParseMethod_Const()
{
var target = TestSuite.GetGrammar();
var result = target.ClassMembers.Parse(@"
public int TestMethod()
{
const int myValue = 5;
return myValue;
}");
result.Should().MatchAst(
new MethodNode
{
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode("int"),
Name = new IdentifierNode("TestMethod"),
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ConstNode
{
Type = new TypeNode("int"),
Name = new IdentifierNode("myValue"),
Value = new IntegerNode(5)
},
new ReturnNode
{
Expression = new IdentifierNode("myValue")
}
}
}
);
}
public void Constructor_Named()
{
var target = TestSuite.GetGrammar().WithNamedConstructors();
var result = target.Classes.Parse(@"
public class MyClass
{
public MyClass:Test() { }
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new ConstructorNode
{
AccessModifier = new KeywordNode("public"),
ClassName = new IdentifierNode("MyClass"),
Name = new IdentifierNode("Test"),
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
}
}
}
);
}
public void ParseMethod_NewListOfMyClass()
{
var target = TestSuite.GetGrammar();
var result = target.ClassMembers.Parse(@"
public List<int[]> GetListOfIntArrays()
{
return new List<int[]>();
}");
result.Should().MatchAst(
new MethodNode
{
Name = new IdentifierNode("GetListOfIntArrays"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("List"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode
{
Name = new IdentifierNode("int"),
ArrayTypes = new ListNode <ArrayTypeNode> {
new ArrayTypeNode()
}
}
}
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new NewNode
{
Type = new TypeNode
{
Name = new IdentifierNode("List"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode
{
Name = new IdentifierNode("int"),
ArrayTypes = new ListNode <ArrayTypeNode> {
new ArrayTypeNode()
}
}
}
},
Arguments = ListNode <AstNode> .Default()
}
}
}
}
);
}
public void ParseClass_GenericClassAndMethod()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass<TA>
{
public TB MyMethod<TB, TC>()
{
return default(TB);
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TA")
},
Members = new ListNode <AstNode>
{
new MethodNode
{
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode("TB"),
Name = new IdentifierNode("MyMethod"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TB"),
[1] = new IdentifierNode("TC")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new InvokeNode
{
Instance = new IdentifierNode("default"),
Arguments = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TB")
}
}
}
}
}
}
}
);
}
public void Attribute_OnClassMethod()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
[MyAttrA]
[return: MyAttrB]
public int MyMethod()
{
return 5;
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new MethodNode
{
Attributes = new ListNode <AttributeNode>
{
new AttributeNode
{
Type = new TypeNode("MyAttrA")
},
new AttributeNode
{
Target = new KeywordNode("return"),
Type = new TypeNode("MyAttrB")
}
},
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("int")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new IntegerNode(5)
}
}
}
}
}
);
}
public void ParseClass_MethodDeclareThenAssignReturn()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
public int MyMethod()
{
var value;
value = 4;
return value;
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("int")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new VariableDeclareNode
{
Type = new TypeNode("var"),
Name = new IdentifierNode("value")
},
new InfixOperationNode {
Left = new IdentifierNode("value"),
Operator = new OperatorNode("="),
Right = new IntegerNode(4)
},
new ReturnNode
{
Expression = new IdentifierNode("value")
}
}
}
}
}
);
}
public void Attribute_NoArgsParens()
{
var target = TestSuite.GetGrammar();
var result = target.Attributes.Parse(@"[MyAttr()]").First();
result.Should().MatchAst(
new AttributeNode
{
Type = new TypeNode("MyAttr"),
Arguments = ListNode <AstNode> .Default()
}
);
}
public void ParseClass_MethodIntegerMethod()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
public string MyMethod()
{
return 5.ToString();
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("string")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new IntegerNode(5),
MemberName = new IdentifierNode("ToString"),
Operator = new OperatorNode(".")
},
Arguments = ListNode <AstNode> .Default()
}
}
}
}
}
}
);
}
public void Enum_Empty()
{
var target = TestSuite.GetGrammar();
var result = target.Enums.Parse("public enum MyEnum { }");
result.Should().MatchAst(
new EnumNode
{
AccessModifier = new KeywordNode("public"),
Name = new IdentifierNode("MyEnum"),
Members = ListNode <EnumMemberNode> .Default()
}
);
}
public void ParseClass_CtorAndMethod()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
// default parameterless constructor
public MyClass() { }
// Simple void() method
public void MyMethod() { }
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new ConstructorNode
{
ClassName = new IdentifierNode("MyClass"),
AccessModifier = new KeywordNode("public"),
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
},
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("void")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
}
}
}
);
}
public void Lambda_ParameterlessExpression()
{
var target = TestSuite.GetGrammar();
var result = target.Expressions.Parse(@"() => 5");
result.Should().MatchAst(
new LambdaNode
{
Parameters = ListNode <IdentifierNode> .Default(),
Statements = new ListNode <AstNode>
{
new IntegerNode(5)
}
}
);
}
public void New_MyClass()
{
var target = TestSuite.GetGrammar();
var result = target.Statements.Parse(@"new MyClass();");
result.Should().MatchAst(
new NewNode
{
Type = new TypeNode
{
Name = new IdentifierNode("MyClass")
},
Arguments = ListNode <AstNode> .Default()
}
);
}
public void ParseMethod_UsingStatementAssignment()
{
var target = TestSuite.GetGrammar();
var result = target.ClassMembers.Parse(@"
public void MyMethod()
{
using (var x = new Disposable())
x.DoWork();
}");
result.Should().MatchAst(
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode("void"),
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new UsingStatementNode
{
Disposable = new VariableDeclareNode
{
Type = new TypeNode("var"),
Name = new IdentifierNode("x"),
Value = new NewNode
{
Type = new TypeNode("Disposable"),
Arguments = ListNode <AstNode> .Default()
}
},
Statement = new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new IdentifierNode("x"),
MemberName = new IdentifierNode("DoWork"),
Operator = new OperatorNode(".")
},
Arguments = ListNode <AstNode> .Default()
}
}
}
}
);
}
public void ParseClass_MethodStringLiteralProperty()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
public int MyMethod()
{
return ""test"".Length;
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("int")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new MemberAccessNode
{
Instance = new StringNode("\"test\""),
MemberName = new IdentifierNode("Length"),
Operator = new OperatorNode(".")
}
}
}
}
}
}
);
}
public void MemberInvoke_GenericMethodChain()
{
var target = TestSuite.GetGrammar();
var result = target.Expressions.Parse(@"e.First<List<int>>().First<int>()");
result.Should().MatchAst(
new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new IdentifierNode("e"),
MemberName = new IdentifierNode("First"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode
{
Name = new IdentifierNode("List"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("int")
}
}
},
Operator = new OperatorNode(".")
},
Arguments = ListNode <AstNode> .Default()
},
MemberName = new IdentifierNode("First"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("int")
},
Operator = new OperatorNode(".")
},
Arguments = ListNode <AstNode> .Default()
}
);
}
public void InvokeMethod_NullInvoke()
{
var target = TestSuite.GetGrammar();
var result = target.Statements.Parse(@"myObj?.Method();");
result.Should().MatchAst(
new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new IdentifierNode("myObj"),
MemberName = new IdentifierNode("Method"),
Operator = new OperatorNode("?.")
},
Arguments = ListNode <AstNode> .Default()
}
);
}
public void New_ComplexType()
{
var target = TestSuite.GetGrammar();
var result = target.Statements.Parse(@"new A<B>.C<D.E<F>>();");
result.Should().MatchAst(
new NewNode
{
Arguments = ListNode <AstNode> .Default(),
Type = new TypeNode
{
Name = new IdentifierNode("A"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("B")
},
Child = new TypeNode
{
Name = new IdentifierNode("C"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode
{
Name = new IdentifierNode("D"),
Child = new TypeNode
{
Name = new IdentifierNode("E"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("F")
}
}
}
}
}
}
}
);
}
public void Attribute_OnEnum()
{
var target = TestSuite.GetGrammar();
var result = target.Enums.Parse("[MyAttr] public enum MyEnum { }");
result.Should().MatchAst(
new EnumNode
{
Attributes = new ListNode <AttributeNode>
{
new AttributeNode
{
Type = new TypeNode("MyAttr")
}
},
AccessModifier = new KeywordNode("public"),
Name = new IdentifierNode("MyEnum"),
Members = ListNode <EnumMemberNode> .Default()
}
);
}
public void CoalesceOperator_Throw()
{
var target = TestSuite.GetGrammar();
var result = target.Expressions.Parse(@"a ?? throw new Exception()");
result.Should().MatchAst(
new InfixOperationNode
{
Left = new IdentifierNode("a"),
Operator = new OperatorNode("??"),
Right = new PrefixOperationNode
{
Operator = new OperatorNode("throw"),
Right = new NewNode
{
Type = new TypeNode("Exception"),
Arguments = ListNode <AstNode> .Default()
}
}
}
);
}
public void ParseInterface_MethodDeclares()
{
var target = TestSuite.GetGrammar();
var result = target.Interfaces.Parse(@"
public interface MyInterface
{
int Method1();
string Method2();
}");
result.Should().MatchAst(
new InterfaceNode
{
AccessModifier = new KeywordNode("public"),
Name = new IdentifierNode("MyInterface"),
Members = new ListNode <MethodDeclareNode>
{
new MethodDeclareNode
{
Name = new IdentifierNode("Method1"),
Parameters = ListNode <ParameterNode> .Default(),
ReturnType = new TypeNode
{
Name = new IdentifierNode("int")
}
},
new MethodDeclareNode
{
Name = new IdentifierNode("Method2"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("string")
},
Parameters = ListNode <ParameterNode> .Default()
}
}
}
);
}
public void ParseInterface_GenericInterfaceAndMethod()
{
var target = TestSuite.GetGrammar();
var result = target.Interfaces.Parse(@"
public interface MyInterface<TA>
{
TB MyMethod<TB>();
}");
result.Should().MatchAst(
new InterfaceNode
{
AccessModifier = new KeywordNode("public"),
Name = new IdentifierNode("MyInterface"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TA")
},
Members = new ListNode <MethodDeclareNode>
{
new MethodDeclareNode
{
ReturnType = new TypeNode
{
Name = new IdentifierNode("TB")
},
Name = new IdentifierNode("MyMethod"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TB")
},
Parameters = ListNode <ParameterNode> .Default()
}
}
}
);
}
public void ParseClass_LambdaMethodReturnNumber()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
public int MyMethod() => 5;
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new MethodNode
{
Name = new IdentifierNode("MyMethod"),
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode
{
Name = new IdentifierNode("int")
},
Parameters = ListNode <ParameterNode> .Default(),
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new IntegerNode(5)
}
}
}
}
}
);
}
public void MemberInvoke_GenericArguments()
{
var target = TestSuite.GetGrammar();
var result = target.Expressions.Parse(@"a.b<c>()");
result.Should().MatchAst(
new InvokeNode
{
Instance = new MemberAccessNode
{
Instance = new IdentifierNode("a"),
MemberName = new IdentifierNode("b"),
GenericArguments = new ListNode <TypeNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("c")
},
Operator = new OperatorNode(".")
},
Arguments = ListNode <AstNode> .Default()
}
);
}
public void ParseClass_GenericClassAndMethodConstraints()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass<TA>
where TA : class, new()
{
public TB MyMethod<TB, TC>()
where TB : IMyInterface, new()
where TC : class, IMyInterface
{
return new TB();
}
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TA")
},
TypeConstraints = new ListNode <TypeConstraintNode>
{
new TypeConstraintNode
{
Type = new IdentifierNode("TA"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new KeywordNode("class"),
[1] = new KeywordNode("new()")
}
}
},
Members = new ListNode <AstNode>
{
new MethodNode
{
AccessModifier = new KeywordNode("public"),
ReturnType = new TypeNode("TB"),
Name = new IdentifierNode("MyMethod"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TB"),
[1] = new IdentifierNode("TC")
},
Parameters = ListNode <ParameterNode> .Default(),
TypeConstraints = new ListNode <TypeConstraintNode>
{
new TypeConstraintNode
{
Type = new IdentifierNode("TB"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("IMyInterface"),
[1] = new KeywordNode("new()")
}
},
new TypeConstraintNode
{
Type = new IdentifierNode("TC"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new KeywordNode("class"),
[1] = new TypeNode("IMyInterface")
}
}
},
Statements = new ListNode <AstNode>
{
new ReturnNode
{
Expression = new NewNode
{
Type = new TypeNode("TB"),
Arguments = ListNode <AstNode> .Default()
}
}
}
}
}
}
);
}
public void ParseInterface_GenericInterfaceAndMethodConstraints()
{
var target = TestSuite.GetGrammar();
var result = target.Interfaces.Parse(@"
public interface MyInterface<TA>
where TA : class, new()
{
TB MyMethod<TB, TC>()
where TB : IMyInterface, new()
where TC : class, IMyInterface;
}");
result.Should().MatchAst(
new InterfaceNode
{
AccessModifier = new KeywordNode("public"),
Name = new IdentifierNode("MyInterface"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TA")
},
TypeConstraints = new ListNode <TypeConstraintNode>
{
new TypeConstraintNode
{
Type = new IdentifierNode("TA"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new KeywordNode("class"),
[1] = new KeywordNode("new()")
}
}
},
Members = new ListNode <MethodDeclareNode>
{
new MethodDeclareNode
{
ReturnType = new TypeNode("TB"),
Name = new IdentifierNode("MyMethod"),
GenericTypeParameters = new ListNode <IdentifierNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("TB"),
[1] = new IdentifierNode("TC")
},
Parameters = ListNode <ParameterNode> .Default(),
TypeConstraints = new ListNode <TypeConstraintNode>
{
new TypeConstraintNode
{
Type = new IdentifierNode("TB"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new TypeNode("IMyInterface"),
[1] = new KeywordNode("new()")
}
},
new TypeConstraintNode
{
Type = new IdentifierNode("TC"),
Constraints = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new KeywordNode("class"),
[1] = new TypeNode("IMyInterface")
}
}
}
}
}
}
);
}
public void ParseClass_CtorThis()
{
var target = TestSuite.GetGrammar();
var result = target.Classes.Parse(@"
public class MyClass
{
public MyClass() : this(1) { }
public MyClass(int a) : this(a, ""test"") { }
public MyClass(int a, string b) { }
}");
result.Should().MatchAst(
new ClassNode
{
AccessModifier = new KeywordNode("public"),
Type = new KeywordNode("class"),
Name = new IdentifierNode("MyClass"),
Members = new ListNode <AstNode>
{
new ConstructorNode
{
ClassName = new IdentifierNode("MyClass"),
AccessModifier = new KeywordNode("public"),
Parameters = ListNode <ParameterNode> .Default(),
ThisArgs = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new IntegerNode(1)
},
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
},
new ConstructorNode
{
ClassName = new IdentifierNode("MyClass"),
AccessModifier = new KeywordNode("public"),
Parameters = new ListNode <ParameterNode>
{
Separator = new OperatorNode(","),
[0] = new ParameterNode
{
Type = new TypeNode("int"),
Name = new IdentifierNode("a")
}
},
ThisArgs = new ListNode <AstNode>
{
Separator = new OperatorNode(","),
[0] = new IdentifierNode("a"),
[1] = new StringNode("\"test\"")
},
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
},
new ConstructorNode
{
ClassName = new IdentifierNode("MyClass"),
AccessModifier = new KeywordNode("public"),
Parameters = new ListNode <ParameterNode>
{
Separator = new OperatorNode(","),
[0] = new ParameterNode
{
Type = new TypeNode("int"),
Name = new IdentifierNode("a")
},
[1] = new ParameterNode
{
Type = new TypeNode("string"),
Name = new IdentifierNode("b")
}
},
Statements = new ListNode <AstNode>
{
Items = new List <AstNode>()
}
}
}
}
);
}
