public void MethodWithVariableDeclarations() { string source = @" public void Method() { string var1; int var2; } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Statements); Assert.IsTrue(astWalker.MethodDeclaration.Statements.Count() > 0); Assert.AreEqual(2, astWalker.MethodDeclaration.Statements.Count()); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Statements.ElementAt(0), typeof(StatementTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Statements.ElementAt(1), typeof(StatementTranslationUnit)); }
public void EmptyMethodWithNoParameters() { string source = @" public void Method() { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Arguments); Assert.AreEqual(0, astWalker.MethodDeclaration.Arguments.Count()); }
public void Properties() { string source = @" public interface MyInterface { int Property1 { get; set; } string Property2 { get; set; } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(InterfaceDeclarationSyntax)); InterfaceDeclarationSyntax interfaceDeclarationNode = node as InterfaceDeclarationSyntax; // Creating the walker var astWalker = MockedInterfaceASTWalker.Create(interfaceDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.InterfaceDeclaration); // Checking signatures Assert.IsNotNull(astWalker.InterfaceDeclaration.Signatures); Assert.IsTrue(astWalker.InterfaceDeclaration.Signatures.Count() > 0); Assert.AreEqual(2, astWalker.InterfaceDeclaration.Signatures.Count()); Assert.IsInstanceOfType(astWalker.InterfaceDeclaration.Signatures.ElementAt(0), typeof(MethodSignatureDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.InterfaceDeclaration.Signatures.ElementAt(1), typeof(MethodSignatureDeclarationTranslationUnit)); }
public void EmptyMethodWith3Parameters() { string source = @" public void Method(string param1, int param2, bool param3) { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Arguments); Assert.IsTrue(astWalker.MethodDeclaration.Arguments.Count() > 0); Assert.AreEqual(3, astWalker.MethodDeclaration.Arguments.Count()); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(0), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(1), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(2), typeof(ArgumentDefinitionTranslationUnit)); }
public void WalkASTDeep() { string source = @" namespace MyNamespaceA { public class MyClassA { } public class MyClassB { } namespace MyNamespaceB { public class MyClassC { } public class MyClassD { } } } "; int traversedClassesCount = 0; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); var node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)) as CSharpSyntaxNode; // Calling the walker var astWalker = new MultiPurposeASTWalker(node, syntaxNode => syntaxNode as ClassDeclarationSyntax != null, delegate { traversedClassesCount++; }, false); astWalker.Start(); // Checking Assert.AreEqual(4, traversedClassesCount, "Expected walker to deep traverse AST!"); }
public void Methods() { string source = @" public class MyClass { private void Method1() { } protected void Method2() { } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(ClassDeclarationSyntax)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; // Creating the walker var astWalker = MockedClassASTWalker.Create(classDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.ClassDeclaration); // Checking members Assert.IsNotNull(astWalker.ClassDeclaration.MethodDeclarations); Assert.IsTrue(astWalker.ClassDeclaration.MethodDeclarations.Count() > 0); Assert.AreEqual(2, astWalker.ClassDeclaration.MethodDeclarations.Count()); Assert.IsInstanceOfType(astWalker.ClassDeclaration.MethodDeclarations.ElementAt(0), typeof(MethodDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.ClassDeclaration.MethodDeclarations.ElementAt(1), typeof(MethodDeclarationTranslationUnit)); }
public void OneClass() { string source = @" public class Class1 { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)); CompilationUnitSyntax programNode = node as CompilationUnitSyntax; // Creating the walker var astWalker = MockedProgramASTWalker.Create(programNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.Program); // Checking members Assert.IsNotNull(astWalker.Program.Content); Assert.IsTrue(astWalker.Program.Content.Count() > 0); Assert.AreEqual(1, astWalker.Program.Content.Count()); Assert.IsInstanceOfType(astWalker.Program.Content.ElementAt(0), typeof(ClassDeclarationTranslationUnit)); }
private static void Test(string source) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(EnumDeclarationSyntax)); var enumDeclarationNode = node as EnumDeclarationSyntax; // Creating the walker var astWalker = MockedEnumASTWalker.Create(enumDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.EnumDeclaration); // Checking signatures Assert.IsNotNull(astWalker.EnumDeclaration.Members); Assert.IsTrue(astWalker.EnumDeclaration.Members.Count() > 0); Assert.AreEqual(3, astWalker.EnumDeclaration.Members.Count()); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(0), typeof(EnumMemberTranslationUnit)); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(1), typeof(EnumMemberTranslationUnit)); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(2), typeof(EnumMemberTranslationUnit)); }
public void EmptyMethodWith2Parameters() { string source = @" class Class1 { public Class1(string param1, int param2) { } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(ConstructorDeclarationSyntax)); ConstructorDeclarationSyntax constructorDeclarationNode = node as ConstructorDeclarationSyntax; // Creating the walker var astWalker = MockedConstructorASTWalker.Create(constructorDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.ConstructorDeclaration); // Checking members Assert.IsNotNull(astWalker.ConstructorDeclaration.Arguments); Assert.IsTrue(astWalker.ConstructorDeclaration.Arguments.Count() > 0); Assert.AreEqual(2, astWalker.ConstructorDeclaration.Arguments.Count()); Assert.IsInstanceOfType(astWalker.ConstructorDeclaration.Arguments.ElementAt(0), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.ConstructorDeclaration.Arguments.ElementAt(1), typeof(ArgumentDefinitionTranslationUnit)); }
private static MockedClassDefinitionASTWalker ParseClass(string source, bool generateTranslationUniOnProtectedMembers = false) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(ClassDeclarationSyntax)); var classDeclarationNode = node as ClassDeclarationSyntax; // Creating the walker var astWalker = MockedClassDefinitionASTWalker.Create(classDeclarationNode, generateTranslationUniOnProtectedMembers); // Getting the translation unit astWalker.Walk(); return(astWalker); }
private static string GetTranslation(string source) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)); CompilationUnitSyntax compilationUnitNode = node as CompilationUnitSyntax; // Creating the walker var astWalker = ProgramDefinitionASTWalker.Create(compilationUnitNode); // Getting the translation unit ITranslationUnit translationUnit = astWalker.Walk(); return(translationUnit.Translate()); }
private static string GetTranslation(string source) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(InterfaceDeclarationSyntax)); InterfaceDeclarationSyntax interfaceDeclarationNode = node as InterfaceDeclarationSyntax; // Creating the walker var astWalker = InterfaceASTWalker.Create(interfaceDeclarationNode); // Getting the translation unit ITranslationUnit translationUnit = astWalker.Walk(); return(translationUnit.Translate()); }
public void Empty2IfsElseStatementWithBlocks() { string source = @" public class Class1 { public void Method1() { if (true) { } else if (false) { } else { } } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(IfStatementSyntax)); IfStatementSyntax ifStatementNode = node as IfStatementSyntax; // Creating the walker var astWalker = MockedConditionalStatementASTWalker.Create(ifStatementNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.Statement); // Checking members Assert.IsNotNull(astWalker.Statement.Bodies); Assert.IsTrue(astWalker.Statement.Bodies.Count() > 0); Assert.AreEqual(2, astWalker.Statement.Bodies.Count()); Assert.IsInstanceOfType(astWalker.Statement.Bodies.ElementAt(0), typeof(StatementsGroupTranslationUnit)); Assert.IsInstanceOfType(astWalker.Statement.Bodies.ElementAt(1), typeof(StatementsGroupTranslationUnit)); Assert.IsNotNull(astWalker.Statement.TestExpressions); Assert.IsTrue(astWalker.Statement.TestExpressions.Count() > 0); Assert.AreEqual(2, astWalker.Statement.TestExpressions.Count()); Assert.IsInstanceOfType(astWalker.Statement.TestExpressions.ElementAt(0), typeof(LiteralTranslationUnit <bool>)); Assert.IsInstanceOfType(astWalker.Statement.TestExpressions.ElementAt(1), typeof(LiteralTranslationUnit <bool>)); Assert.IsNotNull(astWalker.Statement.LastBody); Assert.IsInstanceOfType(astWalker.Statement.LastBody, typeof(StatementsGroupTranslationUnit)); }
public void WalkASTOnlyRootLevel() { string source = @" namespace MyNamespaceA { public class MyClassA { } public class MyClassB { } namespace MyNamespaceB { public class MyClassC { } public class MyClassD { } } } namespace MyNamespaceC { } "; int traversedClassesCount = 0; int traversedNamespacesCount = 0; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); var node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)) as CSharpSyntaxNode; // Calling the walker var astClassWalker = new MultiPurposeASTWalker(node, syntaxNode => syntaxNode as ClassDeclarationSyntax != null, delegate { traversedClassesCount++; }, true); astClassWalker.Start(); //var astNamespaceWalker = new MultiPurposeASTWalker(node, // syntaxNode => syntaxNode as NamespaceDeclarationSyntax != null, // delegate // { // traversedNamespacesCount++; // }, // true); //astNamespaceWalker.Start(); // Checking Assert.AreEqual(0, traversedClassesCount, "Expected walker to root level traverse AST!"); //Assert.AreEqual(2, traversedNamespacesCount, "Expected walker to root level traverse AST!"); }
public string RenderSimpleEmptyClass() { var sourceInfo = SourceGenerator.Generate(SourceOptions.None); string source = sourceInfo.Key; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(ClassDeclarationSyntax)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; // Creating the walker var astWalker = ClassASTWalker.Create(classDeclarationNode); // Getting the translation unit ITranslationUnit translationUnit = astWalker.Walk(); return(translationUnit.Translate()); }
private static string GetTranslation(string source) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); var node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)) as CSharpSyntaxNode; // Transforming new ScriptNamespaceBasedASTTransformer().Transform(ref tree); var programNode = node as CompilationUnitSyntax; // Creating the walker var astWalker = ProgramDefinitionASTWalker.Create(programNode); // Getting the translation unit ITranslationUnit translationUnit = astWalker.Walk(); return(translationUnit.Translate()); }
public void ClassDeclarations() { string source = @" namespace MyNamespace { public class Class1 { } private class Class2 { } internal class Class3 { } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(NamespaceDeclarationSyntax)); NamespaceDeclarationSyntax namespaceNode = node as NamespaceDeclarationSyntax; // Creating the walker var astWalker = MockedNamespaceASTWalker.Create(namespaceNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.Module); // Checking members Assert.IsNotNull(astWalker.Module.Classes); Assert.IsTrue(astWalker.Module.Classes.Count() > 0); Assert.AreEqual(3, astWalker.Module.Classes.Count()); Assert.IsInstanceOfType(astWalker.Module.Classes.ElementAt(0), typeof(ClassDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.Module.Classes.ElementAt(1), typeof(ClassDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.Module.Classes.ElementAt(2), typeof(ClassDeclarationTranslationUnit)); }
protected override void InitializeCore() { // TODO: In order to target #41, add an option for using the reflector when requested // Getting the AST node this.tree = ASTExtractor.Extract(this.source); // Loading the semantic model CSharpCompilation compilation = null; if (this.assemblyPath != null) { compilation = this.GetCompilation(this.assemblyPath, this.tree); } IASTTransformer transformer = new ScriptNamespaceBasedASTTransformer(); if (compilation != null) { transformer.Transform(ref this.tree, ref compilation); this.semanticModel = SemanticUtils.RetrieveSemanticModel(compilation, this.tree); } else { transformer.Transform(ref this.tree); } // Creating the walker // If no semantic model was loaded, null will just be passed var node = this.tree.GetRoot(); this.walker = ProgramDefinitionASTWalker.Create(node, null, this.semanticModel); (this.walker as ProgramDefinitionASTWalker).Logger = this.Logger; // Translating this.output = this.walker.Walk().Translate(); }
private void Initialize() { // Getting the AST node this.tree = ASTExtractor.Extract(this.source); // Loading the semantic model CSharpCompilation compilation = null; if (this.assemblyPath != null) { compilation = this.GetCompilation(this.assemblyPath, this.tree); } IASTTransformer transformer = new ScriptNamespaceBasedASTTransformer(); if (compilation != null) { transformer.Transform(ref this.tree, ref compilation); this.semanticModel = SemanticUtils.RetrieveSemanticModel(compilation, this.tree); } else { transformer.Transform(ref this.tree); } // Creating the walker // If no semantic model was loaded, null will just be passed var node = this.tree.GetRoot(); this.walker = ProgramDefinitionASTWalker.Create(node, null, this.semanticModel); // Translating this.output = this.walker.Walk().Translate(); this.initialized = true; }