/// <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))); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { VisitMembers(node.Members); //base.VisitNamespaceDeclaration(node); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { CheckForInvalid(node); base.VisitNamespaceDeclaration(node); }
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ImmutableArray <OrderingTrait> elementOrder, SyntaxNode syntaxRoot, IndentationSettings indentationSettings) { return(OrderMember(memberOrder, namespaceDeclaration.Members, elementOrder, syntaxRoot, indentationSettings)); }
public void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); WriteLeadingTrivia(node); _writer.WriteIndent(); _writer.WriteKeyword(PrinterKeyword.Namespace); _writer.WriteSpace(); node.Name.Accept(this); _writer.PushBraceFormatting(_writer.Configuration.BracesLayout.TypeAndNamespaceDeclaration); if (!node.ChildNodes().Any()) { _writer.EmptyBlock(_writer.Configuration.BlankLines.InsideNamespace); } else { _writer.BeginBlock(); _writer.WriteLine(_writer.Configuration.BlankLines.InsideNamespace); WriteGlobalNodes( node.Usings, node.Externs, node.Members, null ); _writer.WriteLine(_writer.Configuration.BlankLines.InsideNamespace); _writer.EndBlock(); } _writer.PopBraceFormatting(); WriteTrailingTrivia(node); }
private SyntaxNode RegisterNamespaceDeclarationCodeFix(SyntaxNode syntaxRoot, NamespaceDeclarationSyntax node, IndentationOptions indentationOptions) { return(this.ReformatElement(syntaxRoot, node, node.OpenBraceToken, node.CloseBraceToken, indentationOptions)); }
private static string InternalGetNodeName(NamespaceDeclarationSyntax node) => node.Name.ToString();
private void CleanUp() { _class = null; _namespace = null; _syntaxFactory = null; }
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) => VisitBaseNamespaceDeclaration((BaseNamespaceDeclarationSyntax?)base.VisitNamespaceDeclaration(node));
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { NamespaceDeclaration.Create(cx, node, (NamespaceDeclaration)parent); }
public static CompilationUnitSyntax CompilationUnit(NamespaceDeclarationSyntax member, params string[] usings) { return(SyntaxFactory.CompilationUnit() .WithUsings(usings.Select(u => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(u))).ToSyntaxList()) .WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(member))); }
public static async Task <Solution> MoveTypeToFileAsync(this Document document, ClassDeclarationSyntax typeDecl, CancellationToken cancellationToken = default(CancellationToken)) { CompilationUnitSyntax compilationUnitSyntax = (CompilationUnitSyntax)(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)); IEnumerable <MemberDeclarationSyntax> arg_B5_0 = compilationUnitSyntax.Members; Func <MemberDeclarationSyntax, bool> arg_B5_1; if ((arg_B5_1 = MoveTypeToFileFunction) == null) { arg_B5_1 = (MoveTypeToFileFunction = new Func <MemberDeclarationSyntax, bool>(m => Microsoft.CodeAnalysis.CSharpExtensions.IsKind(m, SyntaxKind.NamespaceDeclaration))); } var semanticModel = await document.GetSemanticModelAsync(cancellationToken); MethodDeclarationSyntax initializeComponentMethod = typeDecl.DescendantNodes().OfType <MethodDeclarationSyntax>().Single(m => m.Identifier.ValueText == "InitializeComponent" && m.ParameterList.Parameters.Count == 0); var localVars = typeDecl.DescendantNodes().OfType <FieldDeclarationSyntax>().ToDictionary(fds => fds.DescendantNodes().OfType <VariableDeclaratorSyntax>().Single().Identifier.Text); var simpleAssigns = initializeComponentMethod.Body.DescendantNodes().OfType <MemberAccessExpressionSyntax>().Where(mea => mea.Kind() == SyntaxKind.SimpleMemberAccessExpression && mea.ChildNodes().OfType <ThisExpressionSyntax>().Any()).SelectMany(id => id.DescendantNodes().OfType <IdentifierNameSyntax>()).Select(i => i.Identifier.Text).Distinct().ToList(); NamespaceDeclarationSyntax namespaceDeclarationSyntax = (NamespaceDeclarationSyntax)arg_B5_0.Single(arg_B5_1); Solution solution = document.Project.Solution; DocumentId documentId = DocumentId.CreateNewId(document.Project.Id, null); List <SyntaxNode> toBeDeleted = new List <SyntaxNode>(); toBeDeleted.Add(initializeComponentMethod); foreach (var item in localVars) { if (simpleAssigns.Contains(item.Key)) { toBeDeleted.Add(item.Value); } } var oldType = SyntaxNodeExtensions.RemoveNodes(typeDecl, toBeDeleted, SyntaxRemoveOptions.KeepDirectives).AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); solution = document.ReplaceFromDocumentAsync(typeDecl, oldType, cancellationToken).Result.Project.Solution; var modifiers = SyntaxFactory.TokenList(new SyntaxToken[] { SyntaxFactory.Token(SyntaxKind.PartialKeyword) }); var newType = SyntaxFactory.ClassDeclaration(typeDecl.Identifier).WithModifiers(modifiers); var method1 = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), "InitializeComponent"); method1 = method1.WithBody(initializeComponentMethod.Body); newType = newType.AddMembers(method1); foreach (var item in localVars) { if (simpleAssigns.Contains(item.Key)) { var varMod = SyntaxFactory.TokenList(item.Value.Modifiers.Select(t => SyntaxFactory.Token(t.Kind())).ToArray()); newType = newType.AddMembers(SyntaxFactory.FieldDeclaration(item.Value.AttributeLists, varMod, item.Value.Declaration)); } } solution = solution.AddDocument(documentId, Path.GetFileNameWithoutExtension(document.Name) + ".designer" + Path.GetExtension(document.Name), newType.GetText(), document.Folders, null, true); CompilationUnitSyntax compilationUnitSyntax2 = SyntaxFactory.CompilationUnit().AddUsings(compilationUnitSyntax.Usings.ToArray()).AddMembers(new MemberDeclarationSyntax[] { SyntaxNodeExtensions.WithLeadingTrivia(SyntaxNodeExtensions.NormalizeWhitespace(SyntaxFactory.NamespaceDeclaration(namespaceDeclarationSyntax.Name), " ", false), new SyntaxTrivia[] { SyntaxFactory.Whitespace("\r\n") }).AddMembers(new MemberDeclarationSyntax[] { newType }) }); return(solution.WithDocumentSyntaxRoot(documentId, compilationUnitSyntax2, 0)); }
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { node = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node); return(node.WithMembers(SortMembers(node.Members))); }
/// <summary> /// Returns true if the given identifier is a machine. /// Returns false if it is not. /// </summary> /// <param name="identifier">Identifier</param> /// <param name="model">SemanticModel</param> /// <returns>Boolean value</returns> internal bool IsMachineType(IdentifierNameSyntax identifier, SemanticModel model) { TypeInfo typeInfo; try { typeInfo = model.GetTypeInfo(identifier); } catch { return(false); } if (typeInfo.Type != null && typeInfo.Type.ToString().Equals("Microsoft.PSharp.Machine")) { return(true); } else { var symbol = model.GetSymbolInfo(identifier).Symbol; var definition = SymbolFinder.FindSourceDefinitionAsync(symbol, this.Solution).Result; if (definition != null) { var machineNode = definition.DeclaringSyntaxReferences.First().GetSyntax(); if (machineNode is ClassDeclarationSyntax) { NamespaceDeclarationSyntax machineNamespace = null; this.TryGetNamespaceDeclarationOfSyntaxNode( machineNode, out machineNamespace); string machineName = machineNamespace.Name + "." + (machineNode as ClassDeclarationSyntax).Identifier.ValueText; foreach (var knownMachine in this.Machines) { NamespaceDeclarationSyntax knownMachineNamespace = null; this.TryGetNamespaceDeclarationOfSyntaxNode( knownMachine, out knownMachineNamespace); string knownMachineName = knownMachineNamespace.Name + "." + (knownMachine as ClassDeclarationSyntax).Identifier.ValueText; if (machineName.Equals(knownMachineName)) { return(true); } } return(false); } else if (machineNode is VariableDeclaratorSyntax) { if (machineNode.FirstAncestorOrSelf <FieldDeclarationSyntax>() == null) { IdentifierNameSyntax machine = null; if ((machineNode as VariableDeclaratorSyntax).Initializer == null) { machine = machineNode.Parent.DescendantNodesAndSelf(). OfType <IdentifierNameSyntax>().First(); } else { machine = (machineNode as VariableDeclaratorSyntax).Initializer.Value. DescendantNodesAndSelf().OfType <IdentifierNameSyntax>().First(); } var s = model.GetSymbolInfo(machine).Symbol; return(s.ToString().Equals("Microsoft.PSharp.MachineState.Machine")); } } } return(false); } }
public static bool IsTopLevel(this NamespaceDeclarationSyntax namespaceDeclaration) => !namespaceDeclaration.Ancestors().OfType <NamespaceDeclarationSyntax>().Any();
protected override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { return node; }
/// <summary> /// Given a namespace declaration, get the corresponding namespace symbol. /// </summary> public NamespaceSymbol GetNamespaceFromDeclaration(NamespaceDeclarationSyntax declarationSyntax) { var outer = GetEnclosingContext(declarationSyntax); return outer.BindNamespace(declarationSyntax.Name, outer); }
private Doc PrintNamespaceDeclarationSyntax( NamespaceDeclarationSyntax node) { var parts = new Parts(); parts.Push(this.PrintExtraNewLines(node)); parts.Push(this.PrintAttributeLists(node, node.AttributeLists)); parts.Push(this.PrintModifiers(node.Modifiers)); parts.Push(this.PrintSyntaxToken(node.NamespaceKeyword), " "); parts.Push(this.Print(node.Name)); var innerParts = new Parts(); var hasMembers = node.Members.Count > 0; var hasUsing = node.Usings.Count > 0; var hasExterns = node.Externs.Count > 0; if (hasMembers || hasUsing || hasExterns) { innerParts.Push(HardLine); if (hasExterns) { innerParts.Push( Join( HardLine, node.Externs.Select( this.PrintExternAliasDirectiveSyntax ) ), HardLine ); } if (hasUsing) { innerParts.Push( Join( HardLine, node.Usings.Select(this.PrintUsingDirectiveSyntax) ), HardLine ); } if (hasMembers) { innerParts.Push( Join(HardLine, node.Members.Select(this.Print)), HardLine ); } innerParts.RemoveAt(innerParts.Count - 1); } else { innerParts.Push(" "); } parts.Push( Group( Line, this.PrintSyntaxToken(node.OpenBraceToken), Indent(Concat(innerParts)), hasMembers || hasUsing || hasExterns ? HardLine : Doc.Null, this.PrintSyntaxToken(node.CloseBraceToken), this.PrintSyntaxToken(node.SemicolonToken) ) ); return(Concat(parts)); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { base.VisitNamespaceDeclaration(node); }
private void HandleUsingDirectiveSyntax(SyntaxNodeAnalysisContext context) { UsingDirectiveSyntax syntax = context.Node as UsingDirectiveSyntax; if (syntax.Alias != null) { return; } SemanticModel semanticModel = context.SemanticModel; INamespaceSymbol namespaceSymbol; string topLevelNamespace = GetTopLevelNamespace(semanticModel, syntax, out namespaceSymbol, context.CancellationToken); if (namespaceSymbol == null) { return; } bool systemNamespace = "System".Equals(topLevelNamespace, StringComparison.Ordinal); string fullyQualifiedNamespace = namespaceSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); CompilationUnitSyntax compilationUnit = syntax.Parent as CompilationUnitSyntax; SyntaxList <UsingDirectiveSyntax>?usingDirectives = compilationUnit?.Usings; if (!usingDirectives.HasValue) { NamespaceDeclarationSyntax namespaceDeclaration = syntax.Parent as NamespaceDeclarationSyntax; usingDirectives = namespaceDeclaration?.Usings; } if (!usingDirectives.HasValue) { return; } foreach (var usingDirective in usingDirectives) { // we are only interested in nodes before the current node if (usingDirective == syntax) { break; } // ignore using alias directives, since they are handled by SA1209 if (usingDirective.Alias != null) { continue; } INamespaceSymbol precedingNamespaceSymbol; string precedingTopLevelNamespace = GetTopLevelNamespace(semanticModel, usingDirective, out precedingNamespaceSymbol, context.CancellationToken); if (precedingTopLevelNamespace == null || precedingNamespaceSymbol == null) { continue; } // compare System namespaces to each other, and non-System namespaces to each other if ("System".Equals(precedingTopLevelNamespace, StringComparison.Ordinal) != systemNamespace) { continue; } string precedingFullyQualifiedNamespace = precedingNamespaceSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); if (string.Compare(fullyQualifiedNamespace, precedingFullyQualifiedNamespace, StringComparison.OrdinalIgnoreCase) >= 0) { continue; } string @namespace = namespaceSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat); string precedingNamespace = precedingNamespaceSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat); // Using directive for '{namespace}' must appear before directive for '{precedingNamespace}' context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), @namespace, precedingNamespace)); break; } }
private async Task <TestGenerationContext> CollectTestGenerationContextAsync( ProjectItemSummary selectedFile, string targetProjectNamespace, TestFramework testFramework, MockFramework mockFramework) { Microsoft.CodeAnalysis.Solution solution = CreateUnitTestBoilerplateCommandPackage.VisualStudioWorkspace.CurrentSolution; DocumentId documentId = solution.GetDocumentIdsWithFilePath(selectedFile.FilePath).FirstOrDefault(); if (documentId == null) { throw new InvalidOperationException("Could not find document in solution with file path " + selectedFile.FilePath); } var document = solution.GetDocument(documentId); SyntaxNode root = await document.GetSyntaxRootAsync(); SemanticModel semanticModel = await document.GetSemanticModelAsync(); SyntaxNode firstClassDeclaration = root.DescendantNodes().FirstOrDefault(node => node.Kind() == SyntaxKind.ClassDeclaration); if (firstClassDeclaration == null) { throw new InvalidOperationException("Could not find class declaration."); } if (firstClassDeclaration.ChildTokens().Any(node => node.Kind() == SyntaxKind.AbstractKeyword)) { throw new InvalidOperationException("Cannot unit test an abstract class."); } SyntaxToken classIdentifierToken = firstClassDeclaration.ChildTokens().FirstOrDefault(n => n.Kind() == SyntaxKind.IdentifierToken); if (classIdentifierToken == default(SyntaxToken)) { throw new InvalidOperationException("Could not find class identifier."); } NamespaceDeclarationSyntax namespaceDeclarationSyntax = null; if (!TypeUtilities.TryGetParentSyntax(firstClassDeclaration, out namespaceDeclarationSyntax)) { throw new InvalidOperationException("Could not find class namespace."); } // Find property injection types var injectableProperties = new List <InjectableProperty>(); string classFullName = namespaceDeclarationSyntax.Name + "." + classIdentifierToken; INamedTypeSymbol classType = semanticModel.Compilation.GetTypeByMetadataName(classFullName); foreach (ISymbol member in classType.GetBaseTypesAndThis().SelectMany(n => n.GetMembers())) { if (member.Kind == SymbolKind.Property) { IPropertySymbol property = (IPropertySymbol)member; foreach (AttributeData attribute in property.GetAttributes()) { if (PropertyInjectionAttributeNames.Contains(attribute.AttributeClass.ToString())) { var injectableProperty = InjectableProperty.TryCreateInjectableProperty(property.Name, property.Type.ToString(), mockFramework); if (injectableProperty != null) { injectableProperties.Add(injectableProperty); } } } } } string className = classIdentifierToken.ToString(); // Find constructor injection types var constructorInjectionTypes = new List <InjectableType>(); SyntaxNode constructorDeclaration = firstClassDeclaration.ChildNodes().FirstOrDefault(n => n.Kind() == SyntaxKind.ConstructorDeclaration); if (constructorDeclaration != null) { SyntaxNode parameterListNode = constructorDeclaration.ChildNodes().First(n => n.Kind() == SyntaxKind.ParameterList); var parameterNodes = parameterListNode.ChildNodes().Where(n => n.Kind() == SyntaxKind.Parameter); foreach (SyntaxNode node in parameterNodes) { constructorInjectionTypes.Add(InjectableType.TryCreateInjectableTypeFromParameterNode(node, semanticModel, mockFramework)); } } string unitTestNamespace; string relativePath = this.GetRelativePath(selectedFile); if (string.IsNullOrEmpty(relativePath)) { unitTestNamespace = targetProjectNamespace; } else { List <string> defaultNamespaceParts = targetProjectNamespace.Split('.').ToList(); List <string> unitTestNamespaceParts = new List <string>(defaultNamespaceParts); unitTestNamespaceParts.AddRange(relativePath.Split('\\')); unitTestNamespace = string.Join(".", unitTestNamespaceParts); } List <InjectableType> injectedTypes = new List <InjectableType>(injectableProperties); injectedTypes.AddRange(constructorInjectionTypes.Where(t => t != null)); GenerateMockNames(injectedTypes); return(new TestGenerationContext( mockFramework, testFramework, unitTestNamespace, className, namespaceDeclarationSyntax.Name.ToString(), injectableProperties, constructorInjectionTypes, injectedTypes)); }
/// <summary> /// Creates a new <see cref="Syntax.MemberDeclarationListInfo"/> from the specified declaration. /// </summary> /// <param name="declaration"></param> public static MemberDeclarationListInfo MemberDeclarationListInfo(NamespaceDeclarationSyntax declaration) { return(Syntax.MemberDeclarationListInfo.Create(declaration)); }
public TameNamespaceDeclarationSyntax(NamespaceDeclarationSyntax node) { Node = node; AddChildren(); }
public static NamespaceDeclaration Create(Context cx, NamespaceDeclarationSyntax decl, NamespaceDeclaration parent) => new NamespaceDeclaration(cx, decl, parent);
private static NamespaceDeclarationSyntax NewNameSpaceFactory(NamespaceDeclarationSyntax OldNameSpace, ClassDeclarationSyntax OldClass, MethodDeclarationSyntax OldMethod) { var newNameSpace = OldNameSpace; var className = "NewClass\{OldMethod.Identifier.Text}";
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { return(base.VisitNamespaceDeclaration( node.WithUsings(this.SortUsings(node.Usings)) )); }
static void ParseNamespace(MemberDeclarationSyntax member, XmlWriter xml, Options o) { NamespaceDeclarationSyntax nameSpace = (NamespaceDeclarationSyntax)member; ParseMembers(nameSpace.Members, xml, o); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { _namespaces.Add(node); }
void ExportInterface(InterfaceDeclarationSyntax c) { string name = ""; string nameSpace = ""; NamespaceDeclarationSyntax namespaceDeclarationSyntax = c.Parent as NamespaceDeclarationSyntax; if (namespaceDeclarationSyntax != null) { nameSpace = namespaceDeclarationSyntax.Name.ToString(); } else { nameSpace = ModelData.GloableNamespaceName; } name = c.Identifier.Text; if (step == ECompilerStet.ScanType) { type_list.Add(new ULTypeInfo()); types.Push(type_list[type_list.Count - 1]); currentType.Namespace = nameSpace; currentType.Name = name; currentType.IsInterface = true; ModelData.UpdateType(currentType); } else { types.Push(ModelData.FindTypeByFullName(nameSpace + "." + name)); } ////导出所有变量 //var virableNodes = c.ChildNodes().OfType<BaseFieldDeclarationSyntax>(); //foreach (var v in virableNodes) //{ // ExportVariable(v); //} //导出所有属性 var propertyNodes = c.ChildNodes().OfType <BasePropertyDeclarationSyntax>(); foreach (var v in propertyNodes) { ExportProperty(v); } //导出所有方法 var funcNodes = c.ChildNodes().OfType <BaseMethodDeclarationSyntax>(); foreach (var f in funcNodes) { ExportMethod(f); } var operatorNodes = c.ChildNodes().OfType <OperatorDeclarationSyntax>(); foreach (var f in operatorNodes) { //ExportOperator(f, type); } var conversion_operatorNodes = c.ChildNodes().OfType <ConversionOperatorDeclarationSyntax>(); foreach (var f in conversion_operatorNodes) { //ExportConversionOperator(f, type); } types.Pop(); }
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { return(node.WithMembers(ReplaceMembers(node.Members))); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { NamespacesInternal.Add(node); }
private static void EminNamespaceDeclaratioText(CodeWriter writer, NamespaceDeclarationSyntax ns) { writer.Append("namespace "); writer.AppendLine(ns.Name.ToString()); }
public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { base.VisitNamespaceDeclaration(node); }
public static CMGotoResult main(bool is_visitor, bool is_enter, Workspaces.Document document, int pos) { string main_suffix = Path.GetExtension(document.FullPath); bool in_grammar = main_suffix == ".g4" || main_suffix == ".g3" || main_suffix == ".g2" || main_suffix == ".g" || main_suffix == ".ebnf" ; bool in_cs = main_suffix == ".cs"; if (in_grammar) { string g4_file_path = document.FullPath; string current_dir = Path.GetDirectoryName(g4_file_path); if (current_dir == null) { return(null); } DocumentSymbol sym = new Module().GetDocumentSymbol(pos, document); if (sym == null) { return(null); } // Get the symbol name as a string. string symbol_name = sym.name; string capitalized_symbol_name = Capitalized(symbol_name); // Parse all the C# files in the current directory. Dictionary <string, SyntaxTree> trees = new Dictionary <string, SyntaxTree>(); foreach (string f in Directory.EnumerateFiles(current_dir)) { if (Path.GetExtension(f).ToLower() != ".cs") { continue; } string file_name = f; string suffix = Path.GetExtension(file_name); if (suffix != ".cs") { continue; } try { string ffn = file_name; StreamReader sr = new StreamReader(ffn); string code = sr.ReadToEnd(); SyntaxTree tree = CSharpSyntaxTree.ParseText(code); trees[ffn] = tree; } catch (Exception) { } } // Get name of base class for listener and visitor. These are generated by Antlr, // constructed from the name of the file. string grammar_name = Path.GetFileName(g4_file_path); grammar_name = Path.GetFileNameWithoutExtension(grammar_name); string listener_baseclass_name = is_visitor ? (grammar_name + "BaseVisitor") : (grammar_name + "BaseListener"); string listener_class_name = is_visitor ? ("My" + grammar_name + "Visitor") : ("My" + grammar_name + "Listener"); // Find all occurrences of visitor class. List <ClassDeclarationSyntax> found_class = new List <ClassDeclarationSyntax>(); string class_file_path = null; try { foreach (KeyValuePair <string, SyntaxTree> kvp in trees) { string file_name = kvp.Key; SyntaxTree tree = kvp.Value; // Look for IParseTreeListener or IParseTreeVisitor classes. CompilationUnitSyntax root = (CompilationUnitSyntax)tree.GetRoot(); if (root == null) { continue; } foreach (MemberDeclarationSyntax nm in root.Members) { NamespaceDeclarationSyntax namespace_member = nm as NamespaceDeclarationSyntax; if (namespace_member == null) { continue; } foreach (MemberDeclarationSyntax cm in namespace_member.Members) { ClassDeclarationSyntax class_member = cm as ClassDeclarationSyntax; if (class_member == null) { continue; } BaseListSyntax bls = class_member.BaseList; if (bls == null) { continue; } SeparatedSyntaxList <BaseTypeSyntax> types = bls.Types; Regex reg = new Regex("[<].+[>]"); foreach (BaseTypeSyntax type in types) { string s = type.ToString(); s = reg.Replace(s, ""); if (s.ToString() == listener_baseclass_name) { // Found the right class. found_class.Add(class_member); class_file_path = file_name; throw new Exception(); } } } } } } catch { } if (found_class.Count == 0) { if (!Options.Option.GetBoolean("GenerateVisitorListener")) { return(null); } // Look in grammar directory for any C# files. string name_space = null; string ffn = Path.GetFullPath(g4_file_path); ffn = Path.GetDirectoryName(ffn); foreach (string f in Directory.EnumerateFiles(current_dir)) { if (Path.GetExtension(f).ToLower() != ".cs") { continue; } string file_name = f; try { // Look for namespace. SyntaxTree t = trees[file_name]; if (t == null) { continue; } CompilationUnitSyntax root = t.GetCompilationUnitRoot(); foreach (MemberDeclarationSyntax nm in root.Members) { NamespaceDeclarationSyntax namespace_member = nm as NamespaceDeclarationSyntax; if (namespace_member == null) { continue; } name_space = namespace_member.Name.ToString(); break; } } catch (Exception) { } } if (name_space == null) { name_space = "Generated"; } // Create class. string clazz = is_visitor ? $@" using System; using System.Collections.Generic; using System.Text; namespace {name_space} {{ class {listener_class_name}<Result> : {listener_baseclass_name}<Result> {{ //public override Result VisitA([NotNull] A3Parser.AContext context) //{{ // return VisitChildren(context); //}} }} }} " : $@" using System; using System.Collections.Generic; using System.Text; namespace {name_space} {{ class {listener_class_name} : {listener_baseclass_name} {{ //public override void EnterA(A3Parser.AContext context) //{{ // base.EnterA(context); //}} //public override void ExitA(A3Parser.AContext context) //{{ // base.ExitA(context); //}} }} }} "; class_file_path = ffn + Path.DirectorySeparatorChar + listener_class_name + ".cs"; System.IO.File.WriteAllText(class_file_path, clazz); // Redo parse. try { StreamReader sr = new StreamReader(class_file_path); string code = sr.ReadToEnd(); SyntaxTree tree = CSharpSyntaxTree.ParseText(code); trees[class_file_path] = tree; } catch (Exception) { } // Redo find class. try { SyntaxTree tree = trees[class_file_path]; // Look for IParseTreeListener or IParseTreeVisitor classes. CompilationUnitSyntax root = (CompilationUnitSyntax)tree.GetRoot(); foreach (MemberDeclarationSyntax nm in root.Members) { NamespaceDeclarationSyntax namespace_member = nm as NamespaceDeclarationSyntax; if (namespace_member == null) { continue; } foreach (MemberDeclarationSyntax cm in namespace_member.Members) { ClassDeclarationSyntax class_member = cm as ClassDeclarationSyntax; if (class_member == null) { continue; } BaseListSyntax bls = class_member.BaseList; if (bls == null) { continue; } SeparatedSyntaxList <BaseTypeSyntax> types = bls.Types; Regex reg = new Regex("[<].+[>]"); foreach (BaseTypeSyntax type in types) { string s = type.ToString(); s = reg.Replace(s, ""); if (s.ToString() == listener_baseclass_name) { // Found the right class. found_class.Add(class_member); throw new Exception(); } } } } } catch { } } // Look for enter or exit method for symbol. MethodDeclarationSyntax found_member = null; string capitalized_member_name = ""; if (is_visitor) { capitalized_member_name = "Visit" + capitalized_symbol_name; } else if (is_enter) { capitalized_member_name = "Enter" + capitalized_symbol_name; } else { capitalized_member_name = "Exit" + capitalized_symbol_name; } string capitalized_grammar_name = Capitalized(grammar_name); try { foreach (ClassDeclarationSyntax fc in found_class) { foreach (MemberDeclarationSyntax me in fc.Members) { MethodDeclarationSyntax method_member = me as MethodDeclarationSyntax; if (method_member == null) { continue; } if (method_member.Identifier.ValueText.ToLower() == capitalized_member_name.ToLower()) { found_member = method_member; throw new Exception(); } } } } catch { } if (found_member == null) { if (!Options.Option.GetBoolean("GenerateVisitorListener")) { return(null); } // Find point for edit. ClassDeclarationSyntax fc = found_class.First(); SyntaxToken here = fc.OpenBraceToken; Microsoft.CodeAnalysis.Text.TextSpan spn = here.FullSpan; int end = spn.End; StreamReader sr = new StreamReader(class_file_path); string code = sr.ReadToEnd(); // Create class. string member = is_visitor ? $@" public override Result {capitalized_member_name}([NotNull] {capitalized_grammar_name}Parser.{capitalized_symbol_name}Context context) {{ return VisitChildren(context); }} " : $@" public override void {capitalized_member_name}({capitalized_grammar_name}Parser.{capitalized_symbol_name}Context context) {{ base.{capitalized_member_name}(context); }} "; code = code.Insert(end, member); // Redo parse. try { SyntaxTree tree = CSharpSyntaxTree.ParseText(code); trees[class_file_path] = tree; } catch (Exception) { } // Redo find class. try { SyntaxTree tree = trees[class_file_path]; // Look for IParseTreeListener or IParseTreeVisitor classes. CompilationUnitSyntax root = (CompilationUnitSyntax)tree.GetRoot(); foreach (MemberDeclarationSyntax nm in root.Members) { NamespaceDeclarationSyntax namespace_member = nm as NamespaceDeclarationSyntax; if (namespace_member == null) { continue; } foreach (MemberDeclarationSyntax cm in namespace_member.Members) { ClassDeclarationSyntax class_member = cm as ClassDeclarationSyntax; if (class_member == null) { continue; } BaseListSyntax bls = class_member.BaseList; if (bls == null) { continue; } SeparatedSyntaxList <BaseTypeSyntax> types = bls.Types; Regex reg = new Regex("[<].+[>]"); foreach (BaseTypeSyntax type in types) { string s = type.ToString(); s = reg.Replace(s, ""); if (s.ToString() == listener_baseclass_name) { // Found the right class. found_class.Add(class_member); throw new Exception(); } } } } } catch { } try { foreach (ClassDeclarationSyntax fcc in found_class) { foreach (MemberDeclarationSyntax me in fcc.Members) { MethodDeclarationSyntax method_member = me as MethodDeclarationSyntax; if (method_member == null) { continue; } if (method_member.Identifier.ValueText.ToLower() == capitalized_member_name.ToLower()) { found_member = method_member; throw new Exception(); } } } } catch { } } CMGotoResult result = new CMGotoResult { TextDocument = new Uri(class_file_path), Start = found_member.Identifier.SpanStart }; return(result); } else if (in_cs) { } return(null); }
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { return base.VisitNamespaceDeclaration(node); }
private static string GetNamespaceName(NamespaceDeclarationSyntax namespaceSyntax) { return(namespaceSyntax.Name.ToFullString().Trim()); }