internal void Initialize(ClassDeclarationSyntax cds)
{
Name = cds.Identifier.ToString();
foreach (var mds in cds.DescendantNodes().OfType <MethodDeclarationSyntax>())
{
SyntaxToken publicToken = mds.ChildTokens().ToList().Find(token => token.ValueText == "public");
if (publicToken == default(SyntaxToken))
{
continue;
}
BaseMethodInfo miToAdd = new BaseMethodInfo();
miToAdd.Initialize(mds);
Methods.Add(miToAdd);
}
foreach (var ctor in cds.DescendantNodes().OfType <ConstructorDeclarationSyntax>())
{
SyntaxToken publicToken = cds.ChildTokens().ToList().Find(token => token.ValueText == "public");
if (publicToken == default(SyntaxToken))
{
continue;
}
BaseMethodInfo miToAdd = new BaseMethodInfo();
miToAdd.Initialize(ctor);
Constructors.Add(miToAdd);
}
}
public static IEnumerable <EntryPoint> GetPublicEntryPoints(this ClassDeclarationSyntax c)
{
List <EntryPoint> entryPoints = new List <EntryPoint>();
foreach (var m in c.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(m => m.Modifiers.Any(mod => mod.Text.Equals("public"))))
{
entryPoints.Add(new EntryPoint(m));
}
foreach (var m in c.DescendantNodes()
.OfType <ConstructorDeclarationSyntax>()
.Where(m => m.Modifiers.Any(mod => mod.Text.Equals("public"))))
{
entryPoints.Add(new EntryPoint(m));
}
foreach (var m in c.DescendantNodes()
.OfType <PropertyDeclarationSyntax>()
.Where(m => m.Modifiers.Any(mod => mod.Text.Equals("public"))))
{
foreach (var a in m.AccessorList.Accessors)
{
entryPoints.Add(new EntryPoint(a, m.Type.ToString(), m.Identifier.Text));
}
}
return(entryPoints);
}
public static ClassDeclarationSyntax AddProperty(this ClassDeclarationSyntax currentClass,
string name, INamedTypeSymbol type)
{
if (currentClass.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.Any(p => p.Identifier.Text == name))
{
// class already has the specified property
return(currentClass);
}
if (currentClass.DescendantNodes().OfType <PropertyDeclarationSyntax>().Count() > 128)
{
throw new Exception("Class already has too many properties");
}
var typeSentax = SyntaxFactory.ParseTypeName(type.Name);
var newProperty = SyntaxFactory.PropertyDeclaration(typeSentax, name)
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List(
new[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})));
return(currentClass.AddMembers(newProperty));
}
private void GenerateOrdinaryClass(ClassDeclarationSyntax classDeclaration, SemanticModel semanticModel, string outputPath)
{
INamedTypeSymbol typeInfo = semanticModel.GetDeclaredSymbol(classDeclaration);
var fullyQualifiedNameParts = SyntaxTreeHelper.GetFullyQualifiedNameParts(typeInfo);
var genericTypeParameters = typeInfo.TypeParameters;
var typeReferences = new HashSet <string>();
var propertyDeclarations = classDeclaration.DescendantNodes().OfType <PropertyDeclarationSyntax>();
var generatedProperties = GetProperties(semanticModel, typeReferences, propertyDeclarations, false);
var fieldsDeclarations = classDeclaration.DescendantNodes().OfType <FieldDeclarationSyntax>();
var generatedFields = GetFields(semanticModel, typeReferences, fieldsDeclarations);
var constructorDeclarations = classDeclaration.DescendantNodes().OfType <ConstructorDeclarationSyntax>();
var generatedConstructors = GetConstructors(semanticModel, typeReferences, constructorDeclarations);
var methodDeclarations = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>();
var generatedMethods = GetMethods(semanticModel, typeReferences, methodDeclarations);
var classSourceCode = TypeBuilder.BuildType(semanticModel,
fullyQualifiedNameParts, genericTypeParameters,
typeInfo.BaseType,
typeInfo.AllInterfaces,
generatedConstructors,
generatedFields,
generatedProperties,
generatedMethods);
WriteToOutputIfPathPresent(outputPath, fullyQualifiedNameParts, classSourceCode.MainPart);
}
private ClassDeclarationSyntax TranslateClass(ClassDeclarationSyntax classDeclaration)
{
for (int i = 0; i < classDeclaration.AttributeLists.Count; i++)
{
var attributeList = classDeclaration.AttributeLists.ToList()[i];
AttributeListSyntax newAttributeList = AttributeTranslator.TranslateClassAttributeList(attributeList);
classDeclaration = classDeclaration.ReplaceNode(attributeList, newAttributeList);
}
classDeclaration = AddClassAnnotationIfNotPresent(classDeclaration);
classDeclaration = AddPublicModifierIfNotPresent(classDeclaration);
//methods
List <MethodDeclarationSyntax> methods = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>().ToList();
for (int i = 0; i < classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>().Count(); i++)
{
methods[i] = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>().ToList()[i];
var methodDeclaration = methods[i];
if (IsTranslatable(methodDeclaration))
{
MethodDeclarationSyntax translatedMethod = TranslateMethod(methods[i]);
classDeclaration = classDeclaration.ReplaceNode(methods[i], translatedMethod);
}
else
{
classDeclaration = classDeclaration.ReplaceNode(methods[i], Comment(methodDeclaration));
classDeclaration = classDeclaration.RemoveNode(classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>().ToList()[i], SyntaxRemoveOptions.KeepExteriorTrivia);
i--;
}
}
return(classDeclaration);
}
public void TestGetSyntaxNodesFromIdentifierObjectCreation()
{
string code1 = "public class TestCLass{public void Main(){ClassA test = new ClassA(0);}} public class ClassA{ public ClassA(){} public ClassA(int param){}}";
SyntaxTree tree1 = CSharpSyntaxTree.ParseText(code1);
ObjectCreationExpressionSyntax node1 = tree1.GetRootAsync().Result.DescendantNodesAndSelf().OfType <ObjectCreationExpressionSyntax>().First();
ClassDeclarationSyntax node2 = tree1.GetRootAsync().Result.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>().Last();
ConstructorDeclarationSyntax node3 = node2.DescendantNodes().OfType <ConstructorDeclarationSyntax>().First();
ConstructorDeclarationSyntax node4 = node2.DescendantNodes().OfType <ConstructorDeclarationSyntax>().Last();
IdentifierNameSyntax node5 = node1.DescendantNodes().OfType <IdentifierNameSyntax>().Last();
List <SyntaxTree> trees1 = new List <SyntaxTree> {
tree1
};
Compilation comp1 = CSharpCompilation.Create("TestCompilation1", trees1);
ScriptAnalyzerSymbolHelper sHelper = new ScriptAnalyzerSymbolHelper(new Compilation[] { comp1 });
ScriptAnalyzerResourceHelper rHelper = new ScriptAnalyzerResourceHelper(sHelper);
List <SyntaxNode> result = rHelper.GetSyntaxNodes(node5);
Assert.IsNotNull(result, "Returns a list");
Assert.AreEqual(1, result.Count(), "List has one node");
CollectionAssert.Contains(result, node2, "Node is class");
}
public void Symbol_IsInterfaceImplementationOrMemberOverride()
{
var method = baseClassDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Method1");
var symbol = semanticModel.GetDeclaredSymbol(method);
symbol.GetInterfaceMember().Should().BeNull();
symbol.GetOverriddenMember().Should().BeNull();
var property = derivedClassDeclaration2.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Property");
symbol = semanticModel.GetDeclaredSymbol(property);
symbol.GetOverriddenMember().Should().NotBeNull();
property = derivedClassDeclaration2.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Property2");
symbol = semanticModel.GetDeclaredSymbol(property);
symbol.GetInterfaceMember().Should().NotBeNull();
method = derivedClassDeclaration2.DescendantNodes().OfType <MethodDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Method3");
symbol = semanticModel.GetDeclaredSymbol(method);
symbol.GetInterfaceMember().Should().NotBeNull();
}
public static int GetCount(ClassDeclarationSyntax classNode)
{
int methodDeclarations = classNode
.DescendantNodes()
.Count(x => x is MethodDeclarationSyntax || x is ConstructorDeclarationSyntax)
;
int methodInvocations = classNode
.DescendantNodes()
.Count(x => x is InvocationExpressionSyntax || x is ObjectCreationExpressionSyntax)
;
return(methodDeclarations + methodInvocations);
}
public void Symbol_IsPublicApi()
{
var method = baseClassDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Method1");
var symbol = semanticModel.GetDeclaredSymbol(method);
SymbolHelper.IsPubliclyAccessible(symbol).Should().BeTrue();
method = baseClassDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Method2");
symbol = semanticModel.GetDeclaredSymbol(method);
symbol.IsPubliclyAccessible().Should().BeTrue();
var property = baseClassDeclaration.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Property");
symbol = semanticModel.GetDeclaredSymbol(property);
symbol.IsPubliclyAccessible().Should().BeTrue();
property = interfaceDeclaration.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Property2");
symbol = semanticModel.GetDeclaredSymbol(property);
symbol.IsPubliclyAccessible().Should().BeTrue();
property = derivedClassDeclaration1.DescendantNodes().OfType <PropertyDeclarationSyntax>()
.First(m => m.Identifier.ValueText == "Property");
symbol = semanticModel.GetDeclaredSymbol(property);
symbol.IsPubliclyAccessible().Should().BeFalse();
}
static public Func <SyntaxNode, Scope, SyntaxNode> AddInitializers(StatementSyntax initializer)
{
return((node, scope) =>
{
ClassDeclarationSyntax decl = (ClassDeclarationSyntax)node;
var found = false;
var result = decl.ReplaceNodes(decl
.DescendantNodes()
.OfType <ConstructorDeclarationSyntax>(), (oldConstuctor, newConstuctor) =>
{
found = true;
return newConstuctor.WithBody(SyntaxFactory.Block().
WithStatements(SyntaxFactory.List(
newConstuctor.Body.Statements.Union(
new[] { initializer }))));
});
if (!found)
{
result = result.WithMembers(SyntaxFactory.List(
result.Members.Union(
new MemberDeclarationSyntax[] {
SyntaxFactory.ConstructorDeclaration(decl.Identifier.ToString()).
WithBody(SyntaxFactory.Block().
WithStatements(SyntaxFactory.List(new[] {
initializer
})))
})));
}
return result;
});
}
private void AssertGeneratedFileDesc(GeneratedFileDescription fileDesc, string fileName,
string namespaceName, string className, string[] methodNames)
{
Assert.True(fileDesc.Name == fileName);
SyntaxNode root = CSharpSyntaxTree.ParseText(fileDesc.Text).GetRoot();
ClassDeclarationSyntax[] classes = root.DescendantNodes().OfType <ClassDeclarationSyntax>().ToArray();
Assert.True(classes.Length == 1);
ClassDeclarationSyntax clazz = classes[0];
Assert.True(clazz.Identifier.ValueText == className);
Assert.True((clazz.Parent as NamespaceDeclarationSyntax)?.Name?.ToString() == namespaceName);
MethodDeclarationSyntax[] methods = clazz.DescendantNodes().OfType <MethodDeclarationSyntax>().ToArray();
Assert.True(methods.Length == methodNames.Length);
foreach (MethodDeclarationSyntax method in methods)
{
Assert.Contains(method.Identifier.ValueText, methodNames);
Assert.True(method.AttributeLists.Count == 1);
Assert.True(method.AttributeLists.First().Attributes.First().Name.ToString() == "Fact");
}
}
private void AnalyzeDacDeclaration(SyntaxNodeAnalysisContext syntaxContext, PXContext pxContext)
{
ClassDeclarationSyntax classDeclaration = (ClassDeclarationSyntax)syntaxContext.Node;
INamedTypeSymbol typeSymbol =
syntaxContext.SemanticModel.GetDeclaredSymbol(classDeclaration, syntaxContext.CancellationToken);
if (typeSymbol != null && typeSymbol.IsDacOrExtension(pxContext))
{
IEnumerable <INamedTypeSymbol> whiteList = GetWhitelist(pxContext);
foreach (SyntaxNode node in classDeclaration.DescendantNodes(
n => !(n is ClassDeclarationSyntax) || IsDacOrExtension(n, pxContext, syntaxContext.SemanticModel, syntaxContext.CancellationToken)))
{
syntaxContext.CancellationToken.ThrowIfCancellationRequested();
if (node is MethodDeclarationSyntax method)
{
AnalyzeMethodDeclarationInDac(method, syntaxContext, pxContext);
}
else if (node is PropertyDeclarationSyntax property)
{
AnalyzeMethodInvocationInDacProperty(property, whiteList, syntaxContext, pxContext);
}
}
}
}
private CompilationUnitSyntax GenerateTestClassFile(ClassDeclarationSyntax classDeclaration)
{
var methods = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(x => x.Modifiers.Any(y => y.ValueText == "public"));
string ns = (classDeclaration.Parent as NamespaceDeclarationSyntax)?.Name.ToString();
List <string> methodsNames = new List <string>();
foreach (MethodDeclarationSyntax method in methods)
{
string tempMethodName = GetMethodName(methodsNames, method.Identifier.ToString(), 0);
methodsNames.Add(tempMethodName);
}
CompilationUnitSyntax result = CompilationUnit();
result = result.WithUsings(GenerateUsingDirective());
string className = classDeclaration.Identifier.ValueText;
ClassDeclarationSyntax testClassDeclaration = ClassDeclaration(className + "Test");
var classAttribute = Attribute(IdentifierName("TestClass"));
var classAttributesList = SingletonList(AttributeList(SingletonSeparatedList(classAttribute)));
testClassDeclaration = testClassDeclaration.WithAttributeLists(classAttributesList);
testClassDeclaration = testClassDeclaration.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)));
testClassDeclaration = testClassDeclaration.WithMembers(GenerateMethodsList(methodsNames));
SyntaxList <MemberDeclarationSyntax> classes = SingletonList <MemberDeclarationSyntax>(testClassDeclaration);
NamespaceDeclarationSyntax namespaceDeclaration =
NamespaceDeclaration(QualifiedName(IdentifierName(ns), IdentifierName("Test")));
namespaceDeclaration = namespaceDeclaration.WithMembers(classes);
result = result.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclaration));
return(result);
}
ClassDeclarationSyntax Remove(ClassDeclarationSyntax classNode)
{
var thises = classNode.DescendantNodes().OfType <ThisExpressionSyntax>();
var newItems = new Dictionary <MemberAccessExpressionSyntax, SyntaxNode>();
foreach (var thisItem in thises)
{
if (thisItem.Parent is MemberAccessExpressionSyntax thisItemAsMemberAccessException)
{
var newAccess = GetMemberAccessWithoutThis(thisItemAsMemberAccessException);
if (newAccess != null)
{
newItems.Add(thisItemAsMemberAccessException, newAccess);
}
}
}
if (newItems.Any())
{
classNode = classNode.ReplaceNodes(newItems.Keys, (node1, node2) => newItems[node1]);
}
return(classNode);
}
public SyntaxNode GenerateTestsForClass(ClassDeclarationSyntax classDeclaration)
{
if (!(classDeclaration.Parent is NamespaceDeclarationSyntax))
{
return(null);
}
string sourceClassNamespace = (classDeclaration.Parent as NamespaceDeclarationSyntax).Name.ToString();
SyntaxNode result = CompilationUnit()
.WithUsings(
List <UsingDirectiveSyntax>(
new UsingDirectiveSyntax[] {
UsingDirective(
IdentifierName("System")),
UsingDirective(
IdentifierName("Microsoft.VisualStudio.TestTools.UnitTesting")),
UsingDirective(
IdentifierName(sourceClassNamespace))
}))
.WithMembers(
SingletonList <MemberDeclarationSyntax>(
NamespaceDeclaration(
QualifiedName(
IdentifierName(sourceClassNamespace),
IdentifierName("Test")))));
result = GenerateClassNode(result, classDeclaration);
result = GenerateTestMethods(result, classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>());
return(result.NormalizeWhitespace());
}
public void TestAnalyzeClass()
{
string code1 = @"class TestClass { public void TestMethod( int test = 0; test = 1;){}}";
SyntaxTree tree1 = CSharpSyntaxTree.ParseText(code1);
ClassDeclarationSyntax classNode = tree1.GetRootAsync().Result.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
List <SyntaxTree> trees1 = new List <SyntaxTree> {
tree1
};
Compilation comp1 = CSharpCompilation.Create("TestCompilation1", trees1);
ScriptAnalyzer analyzer = this.createAnalyzer(comp1);
TaggedSyntaxLibrary lib = analyzer.AnalyzeNode(classNode);
Assert.IsNotNull(lib, "Library defined");
Assert.AreEqual(1, lib.TaggedSyntaxTrees.Count(), "Has one tree");
TaggedSyntaxTree tree = lib.TaggedSyntaxTrees.First();
CollectionAssert.Contains(tree.TaggedNodes, classNode, "Tree contains class node");
IEnumerable <SyntaxNode> nodes = classNode.DescendantNodes();
foreach (SyntaxNode node in nodes)
{
CollectionAssert.DoesNotContain(tree.TaggedNodes, node, "SubNode is not added to tree");
}
}
private static IEnumerable <ParameterMetadata> GetClassDependencies(ClassDeclarationSyntax Class)
{
var constructors = Class.DescendantNodes()
.OfType <ConstructorDeclarationSyntax>()
.Where(method => method.Modifiers
.Any(modifier => modifier.ToString() == "public"));
foreach (var constructor in constructors)
{
var dependencies = constructor.ParameterList.Parameters.Where(param =>
param.Type.GetTypeName()
.StartsWith("I"));
if (!dependencies.Count().Equals(0))
{
return(dependencies.Select(param => new ParameterMetadata()
{
Name = param.Identifier.Value.ToString(),
Type = param.Type
}));
}
}
// no dependencies were found
return(null);
}
static ClassDeclarationSyntax ReplaceAddProperties(TableModel tableModel, ClassDeclarationSyntax newClass)
{
var columnsDict = tableModel.Columns.ToDictionary(c => c.Name);
var replacements = new Dictionary <PropertyDeclarationSyntax, PropertyDeclarationSyntax>();
foreach (var oldProperty in newClass.DescendantNodes()
.OfType <PropertyDeclarationSyntax>()
.Where(p => columnsDict.ContainsKey(p.Identifier.ValueText)))
{
var columnModel = columnsDict[oldProperty.Identifier.ValueText];
columnsDict.Remove(oldProperty.Identifier.ValueText);
var newProperty = GenerateColumnProperty(columnModel)
.WithAttributeLists(oldProperty.AttributeLists);
replacements.Add(oldProperty, newProperty);
}
newClass = newClass.ReplaceNodes(replacements.Keys, (o, _) => replacements[o]);
if (columnsDict.Count > 0)
{
newClass = newClass.AddMembers(tableModel
.Columns
.Where(c => columnsDict.ContainsKey(c.Name))
.Select(GenerateColumnProperty)
.Cast <MemberDeclarationSyntax>()
.ToArray());
}
return(newClass);
}
private IEnumerable <AnalysisResult> AnalyzeClassDeclaration(
ClassDeclarationSyntax syntax)
{
var result = new List <AnalysisResult>();
// Retrieve all class properties
var properties =
syntax.DescendantNodes().OfType <PropertyDeclarationSyntax>();
// Append all properties display/display name attributes
foreach (var prop in properties)
{
var displays =
prop.AttributeLists.SelectMany(p => p.Attributes)
.Select(AnalyzeAttribute)
.Where(r => r != null)
.ToArray();
if (displays.Length > 0)
{
// Append any display/display attribute
result.AddRange(displays);
continue;
}
// Append direct property name
result.Add(new AnalysisResult(prop.Identifier.ValueText,
CreateSource(prop)));
}
// Done
return(result);
}
private static List <AttributeSyntax> FindTestCaseSourceAttributes(ClassDeclarationSyntax node)
{
return(node.DescendantNodes()
.OfType <AttributeSyntax>()
.Where(attr => attr.Name.ToString() == "TestCaseSource")
.ToList());
}
public JavaClass Translate(ClassDeclarationSyntax declarationNode, CSharpSyntaxVisitor <IStmt> statementTranslator)
{
var symbol = semanticModel.GetDeclaredSymbol(declarationNode);
if (symbol == null)
{
throw new Exception("Cannot build semantic information for class type");
}
var descendantNodes = declarationNode.DescendantNodes().ToArray();
var methods = descendantNodes.OfType <MethodDeclarationSyntax>()
.Select(method => TranslatorHelper.TranslateMethod(semanticModel, method, statementTranslator)).ToArray();
var ctors = descendantNodes.OfType <ConstructorDeclarationSyntax>().Select(ctor => TranslateCtor(ctor, statementTranslator)).ToArray();
var fields = TranslatorHelper.GetFields(declarationNode)
.Select(node => TranslatorHelper.TranslateField(semanticModel, node, statementTranslator));
var props = TranslatorHelper.GetProperties(declarationNode)
.Select(node => TranslatorHelper.TranslateProp(semanticModel, node, statementTranslator));
var className = declarationNode.Identifier.ToString();
return(new JavaClass
{
Name = className,
Methods = ctors.Concat <IMethod>(methods).ToArray(),
Fields = props.Concat(fields).ToArray(),
TypeSymbol = symbol,
DeclaredAccessibility = symbol.DeclaredAccessibility,
IsAbstract = symbol.IsAbstract
});
}
public static IReadOnlyDictionary <string, ExpressionSyntax> Fields(this ClassDeclarationSyntax claz)
{
var fields = new Dictionary <string, ExpressionSyntax>();
if (claz == null)
{
return(fields);
}
var variables = claz.DescendantNodes <VariableDeclaratorSyntax>()
.Where(x => x.Initializer != null &&
x.Parent is VariableDeclarationSyntax parent &&
!parent.Type.ToString().Contains("[]") &&
x.Ancestors <FieldDeclarationSyntax>().Any());
foreach (VariableDeclaratorSyntax variable in variables)
{
var identifierText = variable.Identifier.Text;
if (!fields.ContainsKey(identifierText))
{
fields.Add(identifierText, variable.Initializer.Value);
}
}
return(fields);
}
protected override TypeSyntax GetTypeOfMemberDeclarationOrDefault(ClassDeclarationSyntax @class, string memberName)
{
return(@class
.DescendantNodes <PropertyDeclarationSyntax>()
.FirstOrDefault(pds => pds.Identifier.Text == memberName)
?.Type);
}
/// <summary>
/// 從程式碼讀出 class 的結構
/// </summary>
public static CsSchema.Class AnalysisClass(string programText)
{
CsSchema.Class csClass = new CsSchema.Class();
List <CsSchema.Property> csProperties = new List <CsSchema.Property>();
SyntaxTree tree = CSharpSyntaxTree.ParseText(programText);
CompilationUnitSyntax root = tree.GetRoot() as CompilationUnitSyntax;
ClassDeclarationSyntax classSyntax =
root.DescendantNodes().OfType <ClassDeclarationSyntax>().Single();
IEnumerable <PropertyDeclarationSyntax> propertiesSyntax =
classSyntax.DescendantNodes().OfType <PropertyDeclarationSyntax>();
foreach (var propertySyntax in propertiesSyntax)
{
PredefinedTypeSyntax typeSyntax =
propertySyntax.DescendantNodes().OfType <PredefinedTypeSyntax>().Single();
SyntaxToken type = typeSyntax.Keyword;
SyntaxToken property = propertySyntax.Identifier;
csProperties.Add(new CsSchema.Property()
{
Name = property.Text,
TypeName = type.Text
});
}
csClass.Name = classSyntax.Identifier.Text;
csClass.Properties = csProperties.ToArray();
return(csClass);
}
private static IEnumerable <ObjectCreationExpressionSyntax> GetObjectCreations(SyntaxNodeAnalysisContext context, ClassDeclarationSyntax classDeclaration, PropertyDeclarationSyntax propertyDeclarationSyntax, IPropertySymbol propertySymbol)
{
var objectCreations = classDeclaration.DescendantNodes()
.OfType <AssignmentExpressionSyntax>()
.Where(a => context.SemanticModel.GetSymbolInfo(a.Left).Symbol.Equals(propertySymbol) && a.Right is ObjectCreationExpressionSyntax)
.Select(a => a.Right as ObjectCreationExpressionSyntax).ToList();
var arrowExpressionClause = propertyDeclarationSyntax.DescendantNodes()
.OfType <ArrowExpressionClauseSyntax>()
.SingleOrDefault(a => a.Expression is ObjectCreationExpressionSyntax)
?.Expression as ObjectCreationExpressionSyntax;
if (arrowExpressionClause != null)
{
objectCreations.Add(arrowExpressionClause);
}
var getAcessorDeclararion = propertyDeclarationSyntax.DescendantNodes()
.OfType <AccessorDeclarationSyntax>()
.SingleOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
if (getAcessorDeclararion != null)
{
objectCreations.AddRange(getAcessorDeclararion.DescendantNodes()
.OfType <ObjectCreationExpressionSyntax>());
}
return(objectCreations);
}
private static SyntaxList <MemberDeclarationSyntax> GetTemplateMethods(ClassDeclarationSyntax clsInfo, SemanticModel model)
{
List <MemberDeclarationSyntax> classMethods = new List <MemberDeclarationSyntax>();
string templateAttribute = "Test";
//add setUp
var constructor = (ConstructorDeclarationSyntax)clsInfo.ChildNodes().FirstOrDefault(n => n.Kind() == SyntaxKind.ConstructorDeclaration);
if (constructor != null)
{
if (!clsInfo.Modifiers.Where(m => m.Kind().Equals(SyntaxKind.StaticKeyword)).Any())
{
var constructorMethod = AddSetUpMethod(clsInfo, model, constructor);
classMethods.Add(constructorMethod);
}
}
var publicMethods = clsInfo.DescendantNodes().OfType <MethodDeclarationSyntax>().Where(
method => method.Modifiers.Any(modifier => modifier.ValueText == "public"));
foreach (var method in publicMethods)
{
if (method != null)
{
string classname = char.ToLower(clsInfo.Identifier.ValueText[0]) + clsInfo.Identifier.ValueText.Substring(1);
var testMethod = AddMethod(classname, model, method, method.Identifier.ValueText + "Test", templateAttribute);
classMethods.Add(testMethod);
}
}
return(List(classMethods));
}
private List <MethodDescription> GetMethodWithParameter(ClassDeclarationSyntax classSyntax, SemanticModel model, string parameterType, string attributeType = null)
{
var filter = classSyntax.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(m => m.ParameterList.Parameters.Count == 1 && !m.Modifiers.Any(x => x.ValueText == "private"));
if (attributeType != null)
{
filter = filter.Where(m => m.AttributeLists.Any(a => a.Attributes.Any(x => x.Name.ToString() == attributeType)));
}
var result = filter.Select(method => new
{
Name = method.Identifier.ValueText,
ReturnType = model.GetTypeInfo(method.ReturnType).Type as INamedTypeSymbol,
Parameter = model.GetDeclaredSymbol(method.ParameterList.Parameters.FirstOrDefault()),
Attributes = method.AttributeLists.SelectMany(a => a.Attributes.Select(ax => new AttributeDescriptor
{
Name = ax.Name.ToString(),
Values = (ax?.ArgumentList?.Arguments.Select(x => x.Expression.ToFullString()) ?? Enumerable.Empty <string>()).ToList()
}))
}).Where(x => x.Parameter.Type.BaseType?.Name == parameterType || x.Parameter.Type.BaseType?.BaseType?.Name == parameterType || x.Parameter.Type.Name == parameterType)
.Select(c => new MethodDescription
{
MethodName = c.Name,
ParameterType = c.Parameter.Type.Name,
ReturnType = c.ReturnType.Name,
ReturnTypeGenericArgument = c.ReturnType.TypeArguments.FirstOrDefault()?.ToString(),
Attributes = c.Attributes.ToList()
// TODO write recursive base type check
}).ToList();
return(result);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var attributeRemover = new AttributeRemover(node.AttributeLists, "TestFixture");
if (attributeRemover.IsHavingAttribute)
{
if (!node.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword)))
{
var publicKeyword = SyntaxFactory.Token(SyntaxKind.PublicKeyword)
.WithTrailingTrivia(SyntaxTriviaList.Create(SyntaxFactory.Space));
node = node.WithModifiers(node.Modifiers.Add(publicKeyword));
}
node = node.WithAttributeLists(attributeRemover.Remove());
}
if (node.DescendantNodes().Any(n => n is MethodDeclarationSyntax m &&
m.AttributeLists.Contains("TearDown")))
{
node = node.AddBaseListTypes(
SyntaxFactory.SimpleBaseType(
SyntaxFactory.IdentifierName("IDisposable")).WithoutTrivia());
node = node.WithIdentifier(node.Identifier.WithoutTrivia());
}
return(base.VisitClassDeclaration(node));
}
public void GetTemplateTest()
{
testClassTemplate = templateGenerator.GetTemplate(sourceCode);
Assert.IsNotNull(testClassTemplate);
generatedRoot = CSharpSyntaxTree.ParseText(testClassTemplate.InnerText).GetRoot();
List <ClassDeclarationSyntax> generatedClasses = new List <ClassDeclarationSyntax>(generatedRoot.DescendantNodes().OfType <ClassDeclarationSyntax>());
List <ClassDeclarationSyntax> sourceClasses = new List <ClassDeclarationSyntax>(sourceRoot.DescendantNodes().OfType <ClassDeclarationSyntax>());
Assert.AreEqual(sourceClasses.Count, generatedClasses.Count);
for (int i = 0; i < sourceClasses.Count; i++)
{
ClassDeclarationSyntax sourceClass = sourceClasses[i];
ClassDeclarationSyntax generatedClass = generatedClasses[i];
List <MethodDeclarationSyntax> sourceMethods = new List <MethodDeclarationSyntax>(
sourceClass.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(method => method.Modifiers.
Any(modifer => modifer.ToString() == "public")));
List <MethodDeclarationSyntax> generatedMethods = new List <MethodDeclarationSyntax>(
generatedClass.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(method => method.Modifiers.
Any(modifer => modifer.ToString() == "public")));
Assert.AreEqual(sourceMethods.Count, generatedMethods.Count);
for (int j = 0; j < sourceMethods.Count; j++)
{
MethodDeclarationSyntax sourceMethod = sourceMethods[j];
MethodDeclarationSyntax generatedMethod = generatedMethods[j];
Assert.IsTrue(generatedMethod.Identifier.ToString().Contains(sourceMethod.Identifier.ToString()));
}
}
}
public static SyntaxNode InsertPropInTopOfClass(SyntaxNode rootNode, string className, PropertyDeclarationSyntax property)
{
ClassDeclarationSyntax classNode = rootNode
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.FirstOrDefault(n => n.Identifier.ValueText == className);
PropertyDeclarationSyntax firstProp = classNode
.DescendantNodes()
.OfType <PropertyDeclarationSyntax>()
.FirstOrDefault();
// Если в классе есть свойство, новое добавляется перед ним
if (firstProp != null)
{
rootNode = rootNode.InsertNodesBefore(
firstProp,
new List <PropertyDeclarationSyntax>()
{
property.WithTrailingTrivia(property.GetTrailingTrivia())
});
}
else
{
rootNode = rootNode.ReplaceNode(
classNode,
classNode.WithMembers(List(
new List <MemberDeclarationSyntax>()
{
property
})));
}
return(rootNode);
}