public void TestAnalyzeNameSpace() { string code1 = @"namespace Test{class TestClass { public void TestMethod( int test = 0; test = 1;){}}}"; SyntaxTree tree1 = CSharpSyntaxTree.ParseText(code1); NamespaceDeclarationSyntax nsNode = tree1.GetRootAsync().Result.DescendantNodes().OfType <NamespaceDeclarationSyntax>().First(); List <SyntaxTree> trees1 = new List <SyntaxTree> { tree1 }; Compilation comp1 = CSharpCompilation.Create("TestCompilation1", trees1); ScriptAnalyzer analyzer = this.createAnalyzer(comp1); TaggedSyntaxLibrary lib = analyzer.AnalyzeNode(nsNode); Assert.IsNotNull(lib, "Library defined"); Assert.AreEqual(1, lib.TaggedSyntaxTrees.Count(), "Has one tree"); TaggedSyntaxTree tree = lib.TaggedSyntaxTrees.First(); CollectionAssert.Contains(tree.TaggedNodes, nsNode, "Tree contains class node"); IEnumerable <SyntaxNode> nodes = nsNode.DescendantNodes(); foreach (SyntaxNode node in nodes) { CollectionAssert.DoesNotContain(tree.TaggedNodes, node, "SubNode is not added to tree"); } }
//protected override void VisitInvocationExpression(InvocationExpressionSyntax node) //{ //} public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { foreach (var type in node.DescendantNodes().OfType <ClassDeclarationSyntax>()) { Visit(type); } }
/// <summary> /// Takes a namespace declaration and returns a new namespace declaration containing only /// the ServiceContract interfaces, converted to an asynchronous version /// </summary> /// <param name="originalNamespace">The namespace declaration to replace</param> /// <returns></returns> private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace) { var serviceContractInterfaces = originalNamespace.DescendantNodes().OfType<InterfaceDeclarationSyntax>().Where( i => i.GetAttribute<ServiceContractAttribute>() != null); return originalNamespace.WithMembers(Syntax.List<MemberDeclarationSyntax>(serviceContractInterfaces.Select(ComputeNewServiceContractInterfaceNode))); }
/// <summary> /// Takes a namespace declaration and returns a new namespace declaration containing only /// the ServiceContract interfaces, converted to an asynchronous version /// </summary> /// <param name="originalNamespace">The namespace declaration to replace</param> /// <returns></returns> private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace) { var serviceContractInterfaces = originalNamespace.DescendantNodes().OfType <InterfaceDeclarationSyntax>().Where( i => i.GetAttribute <ServiceContractAttribute>() != null); return(originalNamespace.WithMembers(Syntax.List <MemberDeclarationSyntax>(serviceContractInterfaces.Select(ComputeNewServiceContractInterfaceNode)))); }
internal void Initialize(NamespaceDeclarationSyntax nds) { Name = nds.Name.ToString(); foreach (ClassDeclarationSyntax cds in nds.DescendantNodes().OfType <ClassDeclarationSyntax>()) { ClassInfo ciToAdd = new ClassInfo(); ciToAdd.Initialize(cds); Classes.Add(ciToAdd); } }
private string GetMethodName(NamespaceDeclarationSyntax node) { var methodName = node.DescendantNodes().OfType <MethodDeclarationSyntax>().FirstOrDefault()?.Identifier.ValueText; if (string.IsNullOrEmpty(methodName)) { throw new ArgumentException(this.messageManager.GetMessage("MethodNotFoundInClass")); } return(methodName); }
public void Initialize(NamespaceDeclarationSyntax namespaceDeclaration) { Name = namespaceDeclaration.Name.ToString(); foreach (var cds in namespaceDeclaration.DescendantNodes() .OfType <ClassDeclarationSyntax>()) { var classInfoToAdd = new TestableClassInfo(); classInfoToAdd.Initialize(cds); Classes.Add(classInfoToAdd); } }
public SourceNamespace(NamespaceDeclarationSyntax namespaceInfo) { this.namespaceInfo = namespaceInfo; this.name = namespaceInfo.Name.ToString(); foreach (ClassDeclarationSyntax classInfo in namespaceInfo.DescendantNodes().OfType <ClassDeclarationSyntax>()) { //fork classes.Add(new SourceClass(classInfo)); } //join }
private ClassDeclarationSyntax GetParentClass(NamespaceDeclarationSyntax namespaceDeclaration, ClassDeclarationSyntax classDeclaration) { var maybeBaseType = classDeclaration.DescendantNodes() .Where(c => c.Kind() == SyntaxKind.SimpleBaseType) .FirstOrDefault(); if (maybeBaseType is not SimpleBaseTypeSyntax simpleBaseType) { return(null); } var maybeParentClass = namespaceDeclaration.DescendantNodes() .OfType <ClassDeclarationSyntax>() .Where(n => n.Identifier.ValueText == maybeBaseType.ToString()) .FirstOrDefault(); return(maybeParentClass); }
private static NamespaceDeclarationSyntax AddTypeToTargetNamespace(TypeDeclarationSyntax originalTargetType, NamespaceDeclarationSyntax targetNamespace, TypeDeclarationSyntax targetType) { if (originalTargetType != null) { targetNamespace = targetNamespace.RemoveNode(originalTargetType, SyntaxRemoveOptions.KeepNoTrivia); } else { var type = targetNamespace.DescendantNodes().OfType <TypeDeclarationSyntax>().FirstOrDefault(x => x.Identifier.ValueText == targetType.Identifier.ValueText); if (type != null) { targetNamespace = targetNamespace.RemoveNode(type, SyntaxRemoveOptions.KeepNoTrivia); } } targetNamespace = targetNamespace.AddMembers(targetType); return(targetNamespace); }
private void ParseNamespace(Bindings result, NamespaceDeclarationSyntax ns) { var classNode = ns.DescendantNodes() .OfType <ClassDeclarationSyntax>() .FirstOrDefault(); result.Target = new Target() { ClassFullname = $"{ns.Name.GetText().ToString().Trim()}.{classNode.Identifier.Text}", Bindings = new System.Collections.Generic.List <Property>(), }; var method = classNode.DescendantNodes() .OfType <MethodDeclarationSyntax>() .FirstOrDefault(x => x.AttributeLists.Any(l => l.Attributes.Any(a => a.Name.ToString() == "Bindings"))); this.ParseMethod(result, method); }
private static NamespaceDeclarationSyntax AddTypeParameterAliases(ClassModel classModel, HashSet <string> typeParametersEmitted, NamespaceDeclarationSyntax targetNamespace) { foreach (var parameter in classModel.Declaration.TypeParameterList?.Parameters ?? Enumerable.Empty <TypeParameterSyntax>()) { var aliasedName = parameter.Identifier.ToString(); if (targetNamespace.DescendantNodes().OfType <UsingDirectiveSyntax>().Any(node => string.Equals(node.Alias?.Name?.ToString(), aliasedName, StringComparison.OrdinalIgnoreCase))) { continue; } if (typeParametersEmitted.Add(parameter.Identifier.ValueText)) { targetNamespace = targetNamespace.AddUsings( SyntaxFactory.UsingDirective(SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName(Strings.UnitTestGenerator_AddUsingStatements_System), SyntaxFactory.IdentifierName("String"))) .WithAlias(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(parameter.Identifier)))); } } return(targetNamespace); }
private string GetEntryPoint(CompilationUnitSyntax rootnode) { string result = ""; if (rootnode.Members.Count == 0) { throw new ApplicationException("Error parsing soure code"); } if (!(rootnode.Members[0] is NamespaceDeclarationSyntax)) { throw new ApplicationException("Error parsing soure code"); } NamespaceDeclarationSyntax rootNameSpace = (NamespaceDeclarationSyntax)rootnode.Members[0]; if (rootNameSpace is null) { return(result); } var entryPointMethod = rootNameSpace.DescendantNodes().OfType <MethodDeclarationSyntax>().Where(n => n.Identifier.Text.Equals("Main")).FirstOrDefault(); if (entryPointMethod is null) { return(result); } var entryType = entryPointMethod.Ancestors().OfType <ClassDeclarationSyntax>().FirstOrDefault(); if (entryType is null) { return(result); } IdentifierNameSyntax name = (IdentifierNameSyntax)rootNameSpace.Name; result = String.Concat(name.Identifier.Text, ".", entryType.Identifier.Text); return(result); }
/// <summary> /// Takes a namespace declaration and returns a new namespace declaration containing only /// the ServiceContract interfaces, converted to an asynchronous version /// </summary> /// <param name="originalNamespace">The namespace declaration to replace</param> /// <param name="semanticModel"></param> /// <returns></returns> private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace, SemanticModel semanticModel, IBindingModelSyntaxGenerator generator) { var classDeclarations = originalNamespace.DescendantNodes().OfType <ClassDeclarationSyntax>(); var newNamespaceDeclaration = originalNamespace.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>()); foreach (var classDeclaration in classDeclarations) { var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration); var modelDefinition = ModelDefinition.GetModelDefinition(classSymbol); if (modelDefinition == null) { continue; } var newClassDeclaration = SyntaxFactory.ClassDeclaration(classDeclaration.Identifier.Text).WithModifiers(SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PartialKeyword))); newClassDeclaration = newClassDeclaration.AddMembers(GetProtectedFillEntityMethodDeclaration(modelDefinition)); var toEntityMethodDeclaration = GetPublicToEntityMethodDeclaration(modelDefinition); if (toEntityMethodDeclaration != null) { newClassDeclaration = newClassDeclaration.AddMembers(toEntityMethodDeclaration); } if (!modelDefinition.IsAbstract) { newClassDeclaration = newClassDeclaration.AddMembers( GetToBindingModelMethodDeclaration(modelDefinition, generator)); } newNamespaceDeclaration = newNamespaceDeclaration.AddMembers(newClassDeclaration); } return(newNamespaceDeclaration); }
public static NamespaceDeclarationSyntax AppendUsing( this NamespaceDeclarationSyntax node, params string[] usingDirectives) { List <string> list = node.DescendantNodes((Func <SyntaxNode, bool>)(p => !(p is ClassDeclarationSyntax)), false).OfType <UsingDirectiveSyntax>().Select <UsingDirectiveSyntax, string>((Func <UsingDirectiveSyntax, string>)(p => p.Name.ToString())).ToList <string>(); foreach (string usingDirective in usingDirectives) { if (usingDirective != null && !list.Contains(usingDirective)) { list.Add(usingDirective); } } list.Sort(); SyntaxList <UsingDirectiveSyntax> usings = node.Usings; while (usings.Count > 0) { usings = usings.RemoveAt(0); } usings = usings.AddRange(list.Select <string, UsingDirectiveSyntax>((Func <string, UsingDirectiveSyntax>)(u => u.ToUsing()))); return(node.WithUsings(usings)); }
private string GetFullClassName(NamespaceDeclarationSyntax node) { var cls = node.DescendantNodes().OfType <ClassDeclarationSyntax>().FirstOrDefault(); if (cls == null) { throw new ArgumentException(this.messageManager.GetMessage("ClassNotFoundInNamespace")); } string clsName = cls.Identifier.ValueText; string namespaceName = string.Empty; if (node.Parent is NamespaceDeclarationSyntax) { namespaceName = String.Format("{0}.{1}", GetFullClassName((NamespaceDeclarationSyntax)node.Parent), ((IdentifierNameSyntax)node.Name).Identifier.ToString()); } else { namespaceName = ((IdentifierNameSyntax)node.Name).Identifier.ToString(); } return(string.Format("{0}.{1}", namespaceName, clsName)); }
internal Namespace(NamespaceDeclarationSyntax namespaceDeclaration) { Name = namespaceDeclaration.Name.ToString(); Classes = namespaceDeclaration.DescendantNodes().OfType <ClassDeclarationSyntax>().Where(cl => cl.TypeParameterList == null).Select(cl => new Class(cl)).ToArray(); }
/// <summary> /// Gets the immediate descendants of the namespace. /// </summary> /// <param name="node">The node.</param> /// <returns></returns> internal static IEnumerable <SyntaxNode> DescendantNodesImmediate(this NamespaceDeclarationSyntax node) => node .DescendantNodes(descendIntoChildren: n => n is NamespaceDeclarationSyntax);
// returns all classes in a given namespace public List <ClassDeclarationSyntax> GetAllClasses(NamespaceDeclarationSyntax namespaceDecl) { return(namespaceDecl.DescendantNodes().OfType <ClassDeclarationSyntax>().ToList()); }