/// <summary>
/// Initializes a new instance of the <see cref="MethodASTWalker"/> class.
/// </summary>
protected MethodASTWalker(CSharpSyntaxNode node)
{
var methodDeclarationSyntaxNode = node as MethodDeclarationSyntax;
if (methodDeclarationSyntaxNode == null)
{
throw new ArgumentException(
string.Format("Specified node is not of type {0}",
typeof(MethodDeclarationSyntax).Name));
}
this.node = node;
MethodDeclaration methodHelper = new MethodDeclaration(methodDeclarationSyntaxNode);
this.methodDeclaration = MethodDeclarationTranslationUnit.Create(
methodHelper.Visibility,
IdentifierTranslationUnit.Create(methodHelper.ReturnType),
IdentifierTranslationUnit.Create(methodHelper.Name));
foreach (TypedIdentifier parameter in methodHelper.Parameters)
{
this.methodDeclaration.AddArgument(ArgumentDefinitionTranslationUnit.Create(
IdentifierTranslationUnit.Create(parameter.TypeName),
IdentifierTranslationUnit.Create(parameter.IdentifierName)));
}
}
public void DecoratingClass()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
using System;
namespace Namespace1
{
[Obsolete]
public class Class1 { }
public class Class2 {
public Class1 Method1() { return null; }
}
}"
);
// Second class
var node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
// Loading MSCoreLib
var compilation = CSharpCompilation.Create("TestAssembly")
.AddReferences(
MetadataReference.CreateFromFile(
typeof(object).Assembly.Location))
.AddSyntaxTrees(tree);
var semanticModel = compilation.GetSemanticModel(tree);
var methodDeclarationNode = node as MethodDeclarationSyntax;
var helper = new MethodDeclaration(methodDeclarationNode, semanticModel).ReturnType;
var attributes = helper.Attributes;
Assert.IsNotNull(attributes);
Assert.AreNotEqual(0, attributes.Count(), "Expecting attributes!");
var attribute = attributes.First();
Assert.AreEqual("ObsoleteAttribute", attribute.AttributeClassName, "Wrong name!");
Assert.AreEqual("System.ObsoleteAttribute", attribute.AttributeClassFullName, "Wrong full name!");
Assert.IsNotNull(attribute.ConstructorArguments);
Assert.AreEqual(0, attribute.ConstructorArguments.Count(), "Expected no constructor arguments");
}
public void MethodParametersAreOfCorrectType()
{
var source = @"
class Class1 {
public void Method1(int param1) { }
public void Method2(int param1, string param2) { }
public void Method3(int param1, string param2, object param3) { }
public void Method4(int param1, string param2, object param3, bool param4) { }
}
";
var syntaxTree = CSharpSyntaxTree.ParseText(source);
var semanticModel = CSharpCompilation.Create("Class").AddReferences(
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)).AddSyntaxTrees(
syntaxTree).GetSemanticModel(syntaxTree);
IEnumerable<SyntaxNode> nodes = new NodeLocator(syntaxTree).LocateAll(
typeof(MethodDeclarationSyntax));
foreach (SyntaxNode node in nodes)
{
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax;
MethodDeclaration methodDeclaration = new MethodDeclaration(methodDeclarationNode);
foreach (var param in methodDeclaration.Parameters)
{
Assert.IsNotNull(param, "Parameter should not be null!");
Assert.IsInstanceOfType(param, typeof(Parameter), "Wrong parameter type!");
}
}
}
// When specifying `null` as expected return type, we intend `void`.
private static void TestRetrieveMethodReturnType(MethodDeclarationSyntax methodDeclarationNode, string expected = null)
{
Assert.IsNotNull(methodDeclarationNode, "Found node should be of type `{0}`!",
typeof(MethodDeclarationSyntax).Name);
MethodDeclaration methodDeclaration = new MethodDeclaration(methodDeclarationNode);
string typeName = methodDeclaration.ReturnType.Name;
Assert.IsNotNull(typeName, "Method name should not be null!");
Assert.AreNotEqual(string.Empty, typeName, "Method name should not be empty!");
Assert.AreEqual(expected ?? "void", typeName, "Method name is not the one in source!");
}
public void MethodWithParameters()
{
var source = @"
class Class1 {
public void Method1(int param1) { }
public void Method2(int param1, string param2) { }
public void Method3(int param1, string param2, object param3) { }
public void Method4(int param1, string param2, object param3, bool param4) { }
}
";
var syntaxTree = CSharpSyntaxTree.ParseText(source);
var semanticModel = CSharpCompilation.Create("Class").AddReferences(
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)).AddSyntaxTrees(
syntaxTree).GetSemanticModel(syntaxTree);
IEnumerable<SyntaxNode> nodes = new NodeLocator(syntaxTree).LocateAll(
typeof(MethodDeclarationSyntax));
foreach (SyntaxNode node in nodes)
{
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax;
MethodDeclaration methodDeclaration = new MethodDeclaration(methodDeclarationNode);
Assert.IsNotNull(methodDeclaration.Parameters, "Expecting list of parameters not to be null!");
Assert.IsTrue(methodDeclaration.Parameters.Count() > 0, "Expecting parameters!");
}
// 1 parameter
MethodDeclaration method1Declaration = new MethodDeclaration(nodes.ElementAt(0) as MethodDeclarationSyntax);
Assert.AreEqual(1, method1Declaration.Parameters.Count(), "Expecting different number of paramters!");
// 2 parameters
MethodDeclaration method2Declaration = new MethodDeclaration(nodes.ElementAt(1) as MethodDeclarationSyntax);
Assert.AreEqual(2, method2Declaration.Parameters.Count(), "Expecting different number of paramters!");
// 3 parameters
MethodDeclaration method3Declaration = new MethodDeclaration(nodes.ElementAt(2) as MethodDeclarationSyntax);
Assert.AreEqual(3, method3Declaration.Parameters.Count(), "Expecting different number of paramters!");
// 4 parameters
MethodDeclaration method4Declaration = new MethodDeclaration(nodes.ElementAt(3) as MethodDeclarationSyntax);
Assert.AreEqual(4, method4Declaration.Parameters.Count(), "Expecting different number of paramters!");
}
public void MethodWithNoParameters()
{
var source = @"
class Class1 {
public void Method1() { }
}
";
var syntaxTree = CSharpSyntaxTree.ParseText(source);
var semanticModel = CSharpCompilation.Create("Class").AddReferences(
MetadataReference.CreateFromFile(typeof(object).Assembly.Location)).AddSyntaxTrees(
syntaxTree).GetSemanticModel(syntaxTree);
SyntaxNode node = new NodeLocator(syntaxTree).LocateFirst(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax;
MethodDeclaration methodDeclaration = new MethodDeclaration(methodDeclarationNode);
Assert.IsNotNull(methodDeclaration.Parameters, "Expecting list of parameters not to be null!");
Assert.AreEqual(0, methodDeclaration.Parameters.Count(), "Expecting no parameters!");
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// We don't need to go further deeper in the tree by visiting the node.
/// </remarks>
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
// TODO: Use translation unit factories
var helper = new MethodDeclaration(node, this.semanticModel);
// Properties in TypeScript will be translated as methods as
// TypeScript does not support properties in interfaces
var translationUnit = MethodSignatureDeclarationTranslationUnit.Create(
helper.Visibility, TypeIdentifierTranslationUnit.Create(helper.ReturnType.Name), IdentifierTranslationUnit.Create(helper.Name));
this.interfaceDeclaration.AddSignature(translationUnit);
this.InvokePropertyDeclarationVisited(this, new WalkerEventArgs());
}
public void DetectVoidType()
{
var tree = CSharpSyntaxTree.ParseText(@"
using System;
public class MyClass {
public void Method1() { }
public int Method2() { }
}
");
// First method
var node = new NodeLocator(tree).LocateFirst(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
var methodDeclarationNode = node as MethodDeclarationSyntax;
var helper = new MethodDeclaration(methodDeclarationNode).ReturnType;
Assert.IsTrue(helper.IsVoid, "Expected void type!");
// Second method
node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
methodDeclarationNode = node as MethodDeclarationSyntax;
helper = new MethodDeclaration(methodDeclarationNode).ReturnType;
Assert.IsFalse(helper.IsVoid, "Void type not expected!");
}
public void RetrieveAttributesOnClassFromMethodViaSemantics()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
using System;
namespace Namespace1
{
[Obsolete]
public class Class1 { }
public class Class2 {
public Class1 Method1() { return null; }
}
}"
);
// Second class
var node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
// Loading MSCoreLib
var compilation = CSharpCompilation.Create("TestAssembly")
.AddReferences(
MetadataReference.CreateFromFile(
typeof(object).Assembly.Location))
.AddSyntaxTrees(tree);
var semanticModel = compilation.GetSemanticModel(tree);
var methodDeclarationNode = node as MethodDeclarationSyntax;
var helper = new MethodDeclaration(methodDeclarationNode, semanticModel).ReturnType;
var attributes = helper.Attributes;
Assert.IsNotNull(attributes);
Assert.AreEqual(1, attributes.Count(), "Expecting 1 attribute!");
Assert.IsTrue(attributes.First().AttributeClassName.Contains("ObsoleteAttribute"), "Attribute `Obsolete` expected!");
}
public void DetectVoidTypeWithSemanticModel()
{
var tree = CSharpSyntaxTree.ParseText(@"
using System;
public class MyClass {
public void Method1() { }
public int Method2() { }
}
");
// First method
var node = new NodeLocator(tree).LocateFirst(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
// Loading MSCoreLib
var compilation = CSharpCompilation.Create("TestAssembly")
.AddReferences(
MetadataReference.CreateFromFile(
typeof(object).Assembly.Location))
.AddSyntaxTrees(tree);
var semanticModel = compilation.GetSemanticModel(tree);
var methodDeclarationNode = node as MethodDeclarationSyntax;
var helper = new MethodDeclaration(methodDeclarationNode, semanticModel).ReturnType;
Assert.IsTrue(helper.IsVoid, "Expected void type!");
// Second method
node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax));
Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!",
typeof(MethodDeclarationSyntax).Name));
methodDeclarationNode = node as MethodDeclarationSyntax;
helper = new MethodDeclaration(methodDeclarationNode, semanticModel).ReturnType;
Assert.IsFalse(helper.IsVoid, "Void type not expected!");
}