/// <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());
}
