public static string ToText(AstNode node) { var stringWriter = new StringWriter(); var output = new CSharpOutputVisitor(stringWriter, FormattingOptionsFactory.CreateSharpDevelop()); node.AcceptVisitor(output); return stringWriter.GetStringBuilder().ToString(); }
public static IDictionary<AstNode, ISegment> WriteNode(StringWriter writer, AstNode node, CSharpFormattingOptions policy, ICSharpCode.AvalonEdit.TextEditorOptions options) { var formatter = new SegmentTrackingOutputFormatter(writer); formatter.IndentationString = options.IndentationString; var visitor = new CSharpOutputVisitor(formatter, policy); node.AcceptVisitor(visitor); return formatter.Segments; }
public static CSharpMethodBodyStatistics GetBodyStatistics(this MethodDeclaration declaration) { using (var writer = new StringWriter()) { var visitor = new CSharpOutputVisitor(writer, FormattingOptionsFactory.CreateAllman()); declaration.AcceptVisitor(visitor); var bodyAsString = writer.ToString(); return new CSharpMethodBodyStatistics( bodyAsString.Split(new[] {Environment.NewLine}, StringSplitOptions.None).Length, bodyAsString.Length, bodyAsString.GetHashCode()); } }
public static string GenerateText(TypeDeclaration type, OrderedPartCollection<AbstractDynamicCompilationExtension> extensions, HashSet<string> namespaces = null) { var unit = new SyntaxTree(); if (namespaces == null) { namespaces = new HashSet<string> { typeof (SystemTime).Namespace, typeof (AbstractViewGenerator).Namespace, typeof (Enumerable).Namespace, typeof (IEnumerable<>).Namespace, typeof (IEnumerable).Namespace, typeof (int).Namespace, typeof (LinqOnDynamic).Namespace, typeof (Field).Namespace, typeof (CultureInfo).Namespace, typeof (Regex).Namespace }; } foreach (var extension in extensions) { foreach (var ns in extension.Value.GetNamespacesToImport()) { namespaces.Add(ns); } } foreach (var ns in namespaces) { unit.Members.Add(new UsingDeclaration(ns)); } unit.Members.Add(new WindowsNewLine()); unit.Members.Add(type); var stringWriter = new StringWriter(); var output = new CSharpOutputVisitor(stringWriter, FormattingOptionsFactory.CreateSharpDevelop()); unit.AcceptVisitor(output); return stringWriter.GetStringBuilder().ToString(); }
static string GetPartialMethodSignature(MethodDeclaration declaration) { if(declaration.Parameters.Count > 0) { using (var writer = new StringWriter()) { var visitor = new CSharpOutputVisitor(writer, FormattingOptionsFactory.CreateAllman()); var parameterIndex = 0; foreach (var parameter in declaration.Parameters) { if (parameterIndex > 0) writer.Write(","); parameter.AcceptVisitor(visitor); parameterIndex++; } return string.Format("{0}({1})", GetNameWithTypeParameters(declaration), writer); } } return string.Format("{0}()", GetNameWithTypeParameters(declaration)); }
public string BuildExpression(Dictionary<string, Expression> selectExpressions) { var anonymousTypeCreateExpression = new AnonymousTypeCreateExpression(); var crrv = new ChangeRootReferenceVisitor(FromIdentifier); foreach (var curExpr in selectExpressions.OrderBy(x => x.Key)) { curExpr.Value.AcceptVisitor(crrv); anonymousTypeCreateExpression.Initializers.Add( new AssignmentExpression(new IdentifierExpression(curExpr.Key), curExpr.Value.Clone())); } if (FromExpression == null) FromExpression = new IdentifierExpression(); var queryExpr = new QueryExpression { Clauses = { new QueryFromClause { Identifier = "doc", Expression = FromExpression.Clone() }, new QuerySelectClause { Expression = anonymousTypeCreateExpression.Clone() } } }; FromIdentifier = "doc"; var printer = new StringWriter(); var printerVisitor = new CSharpOutputVisitor(printer, FormattingOptionsFactory.CreateSharpDevelop()); queryExpr.AcceptVisitor(printerVisitor); var format = printer.GetStringBuilder().ToString(); if (format.Substring(0, 3) == "\r\n\t") { format = format.Remove(0, 3); } format = format.Replace("\r\n\t", "\n"); return format; }
public override async void Execute(EditorRefactoringContext context) { SyntaxTree st = await context.GetSyntaxTreeAsync().ConfigureAwait(false); ICompilation compilation = await context.GetCompilationAsync().ConfigureAwait(false); CSharpFullParseInformation info = await context.GetParseInformationAsync().ConfigureAwait(false) as CSharpFullParseInformation; EntityDeclaration node = (EntityDeclaration)st.GetNodeAt(context.CaretLocation, n => n is TypeDeclaration || n is DelegateDeclaration); IDocument document = context.Editor.Document; FileName newFileName = FileName.Create(Path.Combine(Path.GetDirectoryName(context.FileName), MakeValidFileName(node.Name))); string header = CopyFileHeader(document, info); string footer = CopyFileEnd(document, info); AstNode newNode = node.Clone(); foreach (var ns in node.Ancestors.OfType<NamespaceDeclaration>()) { var newNS = new NamespaceDeclaration(ns.Name); newNS.Members.AddRange(ns.Children.Where(ch => ch is UsingDeclaration || ch is UsingAliasDeclaration || ch is ExternAliasDeclaration).Select(usingDecl => usingDecl.Clone())); newNS.AddMember(newNode); newNode = newNS; } var topLevelUsings = st.Children.Where(ch => ch is UsingDeclaration || ch is UsingAliasDeclaration || ch is ExternAliasDeclaration); StringBuilder newCode = new StringBuilder(header); CSharpOutputVisitor visitor = new CSharpOutputVisitor(new StringWriter(newCode), FormattingOptionsFactory.CreateSharpDevelop()); foreach (var topLevelUsing in topLevelUsings) topLevelUsing.AcceptVisitor(visitor); newNode.AcceptVisitor(visitor); newCode.AppendLine(footer); IViewContent viewContent = FileService.NewFile(newFileName, newCode.ToString()); viewContent.PrimaryFile.SaveToDisk(newFileName); // now that the code is saved in the other file, remove it from the original document RemoveExtractedNode(context, node); IProject project = (IProject)compilation.GetProject(); if (project != null) { FileProjectItem projectItem = new FileProjectItem(project, ItemType.Compile); projectItem.FileName = newFileName; ProjectService.AddProjectItem(project, projectItem); FileService.FireFileCreated(newFileName, false); project.Save(); ProjectBrowserPad.RefreshViewAsync(); } }
void WriteCommaSeparatedList(IEnumerable<AstNode> parameters) { if (parameters.Any()) { var last = parameters.Last(); foreach (AstNode node in parameters) { if (_includePlaceholders) { _writer.WriteToken(Roles.Text, "$"); _writer.WriteToken(Roles.Text, "{"); _writer.WriteToken(Roles.Text, _counter.ToString()); _writer.WriteToken(Roles.Text, ":"); } var outputVisitor = new CSharpOutputVisitor(_writer, _policy); node.AcceptVisitor(outputVisitor); if (_includePlaceholders) { _writer.WriteToken(Roles.Text, "}"); } if (node != last) { this.Comma(node); } _counter++; } } }
void AppendReturnType (StringBuilder result, CodeGenerationOptions options, IType type) { if (type == null) throw new ArgumentNullException ("type"); var implementingType = options.Part; var loc = implementingType.Region.End; var pf = implementingType.UnresolvedFile; var file = pf as CSharpUnresolvedFile; var resolved = type; if (resolved.Kind == TypeKind.Unknown) { result.Append (type.FullName); return; } var def = type.GetDefinition (); if (def != null) { using (var stringWriter = new System.IO.StringWriter ()) { var formatter = new TextWriterOutputFormatter (stringWriter); stringWriter.NewLine = EolMarker; var visitor = new CSharpOutputVisitor (formatter, FormattingOptionsFactory.CreateMono ()); var shortType = CreateShortType (def.Compilation, file, loc, resolved); shortType.AcceptVisitor (visitor); var typeString = stringWriter.ToString (); if (typeString.StartsWith ("global::")) typeString = typeString.Substring ("global::".Length); result.Append (typeString); } } else { result.Append (new ICSharpCode.NRefactory.CSharp.CSharpAmbience ().ConvertType (type)); } }
void CSharpGenerateCodeButtonClick(object sender, EventArgs e) { var w = new StringWriter(); var output = new CSharpOutputVisitor (w, new CSharpFormattingOptions()); unit.AcceptVisitor (output, null); editor.Text = w.ToString(); }
void CSharpGenerateCodeButtonClick(object sender, EventArgs e) { StringWriter w = new StringWriter(); CSharpOutputVisitor output = new CSharpOutputVisitor(w, new CSharpFormattingOptions()); compilationUnit.AcceptVisitor(output, null); csharpCodeTextBox.Text = w.ToString(); }
public void AddFieldsToFile(string targetProjectPath, string relativeFilePath, List<TargetField> list) { CompilationUnit compilationUnit; bool anyChanges = false; string filePath = Path.Combine(Path.GetDirectoryName(targetProjectPath), relativeFilePath); using(StreamReader reader = new StreamReader(filePath)) { CSharpParser parser = new CSharpParser(); compilationUnit = parser.Parse(reader, Path.GetFileName(filePath)); } string typeName; string typeNamespace; DotNetParserHelper.SplitType(this.TargetClassFullName, out typeName, out typeNamespace); var typeDeclarationList = compilationUnit.Descendants.Where(i => i is TypeDeclaration); var classObject = (TypeDeclaration)compilationUnit.Descendants.Single(i=>i is TypeDeclaration && ((TypeDeclaration)i).Name == typeName); foreach(var field in list) { switch(field.SourceClassFullName) { //case "System.Web.UI.WebControls.Literal": // TargetControlGenerator.AddLiteralControl(classObject, field); // anyChanges = true; // break; case "System.Web.UI.WebControls.HyperLink": TargetControlGenerator.AddHyperLinkControl(classObject, field, field.SourceClassFullName); anyChanges = true; break; } } if(anyChanges) { using(StreamWriter writer = new StreamWriter(filePath)) { CSharpOutputVisitor visitor = new CSharpOutputVisitor(writer, new CSharpFormattingOptions()); compilationUnit.AcceptVisitor(visitor); } } }
private void CreateDesignerWebPageFile(TargetClassComparisonResult targetClass, string designerFilePath) { string typeName; string typeNamespace; DotNetParserHelper.SplitType(targetClass.TargetClassFullName, out typeName, out typeNamespace); StringBuilder sb = new StringBuilder(); sb.AppendLine("using System;"); sb.AppendLine("using System.Collections.Generic;"); sb.AppendLine("using System.Linq;"); sb.AppendLine("using System.Text;"); sb.AppendLine("using MMDB.UITest.Core;"); sb.AppendLine("using WatiN.Core;"); sb.AppendLine(); sb.AppendLine(string.Format("namespace {0}", typeNamespace)); sb.AppendLine("{"); //sb.AppendLine(string.Format("[{0}(sourceClassFullName:\"{1}\",expectedUrlList: new string[] {{\"{2}\"}})]", typeof(UIClientPageAttribute).FullName, targetClass.SourceClassFullName, targetClass.ExpectedUrl)); sb.AppendLine(string.Format("[{0}(sourceClassFullName:\"{1}\")]", typeof(UIClientPageAttribute).FullName, targetClass.SourceClassFullName)); sb.AppendLine(string.Format("partial class {0} : {1}", typeName, typeof(BasePageClient).FullName)); sb.AppendLine("{"); sb.AppendLine(); sb.AppendLine(string.Format("public {0} (Browser browser) : base(browser) {{}}", typeName)); sb.AppendLine(); sb.AppendLine(string.Format("protected override IEnumerable<string> ExpectedUrlList {{ get {{ return new string[] {{ \"{0}\" }}; }} }}", targetClass.ExpectedUrl)); sb.AppendLine("}"); sb.AppendLine("}"); CSharpParser parser = new CSharpParser(); var compilationUnit = parser.Parse(sb.ToString(), Path.GetFileName(designerFilePath)); if (!Directory.Exists(Path.GetDirectoryName(designerFilePath))) { Directory.CreateDirectory(Path.GetDirectoryName(designerFilePath)); } using (StreamWriter writer = new StreamWriter(designerFilePath)) { CSharpOutputVisitor outputVistor = new CSharpOutputVisitor(writer, new CSharpFormattingOptions()); compilationUnit.AcceptVisitor(outputVistor, null); } }
protected override string GenerateCode(ITypeDefinition currentClass) { List<PropertyOrFieldWrapper> filtered = parameterList .Where(p => p.IsIncluded) .OrderBy(p => p.Index) .ToList(); var test = refactoringContext.GetNode(); var insertedConstructor = refactoringContext.GetNode().PrevSibling as ConstructorDeclaration; if (insertedConstructor == null) { // We are not inside of a constructor declaration return null; } using (Script script = refactoringContext.StartScript()) { BlockStatement originalCtorBody = insertedConstructor.Body; foreach (PropertyOrFieldWrapper w in filtered) { if (w.AddCheckForNull) { // true = reference, null = generic or unknown if (w.Type.IsReferenceType != false) script.AddTo(originalCtorBody, new IfElseStatement( new BinaryOperatorExpression(new IdentifierExpression(w.ParameterName), BinaryOperatorType.Equality, new PrimitiveExpression(null)), new ThrowStatement(new ObjectCreateExpression(new SimpleType("ArgumentNullException"), new List<Expression>() { new PrimitiveExpression(w.ParameterName, '"' + w.ParameterName + '"') })) ) ); else script.AddTo(originalCtorBody, new IfElseStatement( new UnaryOperatorExpression(UnaryOperatorType.Not, new MemberReferenceExpression(new IdentifierExpression(w.MemberName), "HasValue")), new ThrowStatement(new ObjectCreateExpression(new SimpleType("ArgumentNullException"), new List<Expression>() { new PrimitiveExpression(w.ParameterName, '"' + w.ParameterName + '"') })) ) ); } if (w.AddRangeCheck) { script.AddTo(originalCtorBody, new IfElseStatement( new BinaryOperatorExpression( new BinaryOperatorExpression(new IdentifierExpression(w.ParameterName), BinaryOperatorType.LessThan, new IdentifierExpression("lower")), BinaryOperatorType.ConditionalOr, new BinaryOperatorExpression(new IdentifierExpression(w.ParameterName), BinaryOperatorType.GreaterThan, new IdentifierExpression("upper")) ), new ThrowStatement( new ObjectCreateExpression( new SimpleType("ArgumentOutOfRangeException"), new List<Expression>() { new PrimitiveExpression(w.ParameterName, '"' + w.ParameterName + '"'), new IdentifierExpression(w.ParameterName), new BinaryOperatorExpression(new PrimitiveExpression("Value must be between "), BinaryOperatorType.Add, new BinaryOperatorExpression(new IdentifierExpression("lower"), BinaryOperatorType.Add, new BinaryOperatorExpression(new PrimitiveExpression(" and "), BinaryOperatorType.Add, new IdentifierExpression("upper")))) } ) ) ) ); } } foreach (PropertyOrFieldWrapper w in filtered) { script.AddTo(originalCtorBody, new ExpressionStatement(new AssignmentExpression(new MemberReferenceExpression(new ThisReferenceExpression(), w.MemberName), AssignmentOperatorType.Assign, new IdentifierExpression(w.ParameterName))) ); } } AnchorElement parameterListElement = insertionContext.ActiveElements .OfType<AnchorElement>() .FirstOrDefault(item => item.Name.Equals("parameterList", StringComparison.OrdinalIgnoreCase)); if (parameterListElement != null) { StringBuilder pList = new StringBuilder(); var parameters = filtered .Select(p => new ParameterDeclaration(refactoringContext.CreateShortType(p.Type), p.ParameterName)) .ToList(); using (StringWriter textWriter = new StringWriter(pList)) { // Output parameter list as string var formattingOptions = FormattingOptionsFactory.CreateMono(); CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor(textWriter, formattingOptions); for (int i = 0; i < parameters.Count; i++) { if (i > 0) textWriter.Write(","); outputVisitor.VisitParameterDeclaration(parameters[i]); } } parameterListElement.Text = pList.ToString(); } return null; }
public static BraceHelper LeftBrace(CSharpOutputVisitor owner, CodeBracesRangeFlags flags) { var bh = new BraceHelper(owner, flags); owner.WriteToken(Roles.LBrace, BoxedTextColor.Punctuation); bh.leftEnd = owner.writer.GetLocation() ?? 0; return bh; }
BraceHelper(CSharpOutputVisitor owner, CodeBracesRangeFlags flags) { this.owner = owner; this.leftStart = owner.writer.GetLocation() ?? 0; this.leftEnd = 0; this.flags = flags; }
private void FormatDocument_Click( object sender, RoutedEventArgs e ) { CSharpFormattingOptions policy = FormattingOptionsFactory.CreateAllman(); CSharpParser parser = new CSharpParser(); SyntaxTree tree = parser.Parse( scriptTextBox.Text ); StringWriter writer = new StringWriter(); CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor( writer, policy ); outputVisitor.VisitSyntaxTree( tree ); scriptTextBox.Text = writer.ToString(); }
private void CreateUserFile(string userFilePath) { string typeName; string typeNamespace; DotNetParserHelper.SplitType(this.TargetClassFullName, out typeName, out typeNamespace); StringBuilder sb = new StringBuilder(); sb.AppendLine("using System;"); sb.AppendLine("using System.Collections.Generic;"); sb.AppendLine("using System.Linq;"); sb.AppendLine("using System.Text;"); sb.AppendLine("using MMDB.UITest.Core;"); sb.AppendLine("using WatiN.Core;"); sb.AppendLine(); sb.AppendLine(string.Format("namespace {0}", typeNamespace)); sb.AppendLine("{"); sb.AppendLine(string.Format("\tpublic partial class {0}", typeName)); sb.AppendLine("\t{"); sb.AppendLine(); sb.AppendLine("\t}"); sb.AppendLine("}"); CSharpParser parser = new CSharpParser(); var compilationUnit = parser.Parse(sb.ToString(), Path.GetFileName(userFilePath)); if(!Directory.Exists(Path.GetDirectoryName(userFilePath))) { Directory.CreateDirectory(Path.GetDirectoryName(userFilePath)); } using(StreamWriter writer = new StreamWriter(userFilePath)) { CSharpOutputVisitor outputVistor = new CSharpOutputVisitor(writer, new CSharpFormattingOptions()); compilationUnit.AcceptVisitor(outputVistor, null); } }
void WriteMemberDeclarationName(IMember member, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) { ConvertType(member.DeclaringType, formatter, formattingPolicy); formatter.WriteToken("."); } switch (member.EntityType) { case EntityType.Indexer: formatter.WriteKeyword("this"); break; case EntityType.Constructor: formatter.WriteIdentifier(member.DeclaringType.Name); break; case EntityType.Destructor: formatter.WriteToken("~"); formatter.WriteIdentifier(member.DeclaringType.Name); break; case EntityType.Operator: switch (member.Name) { case "op_Implicit": formatter.WriteKeyword("implicit"); formatter.Space(); formatter.WriteKeyword("operator"); formatter.Space(); ConvertType(member.ReturnType, formatter, formattingPolicy); break; case "op_Explicit": formatter.WriteKeyword("explicit"); formatter.Space(); formatter.WriteKeyword("operator"); formatter.Space(); ConvertType(member.ReturnType, formatter, formattingPolicy); break; default: formatter.WriteKeyword("operator"); formatter.Space(); var operatorType = OperatorDeclaration.GetOperatorType(member.Name); if (operatorType.HasValue) formatter.WriteToken(OperatorDeclaration.GetToken(operatorType.Value)); else formatter.WriteIdentifier(member.Name); break; } break; default: formatter.WriteIdentifier(member.Name); break; } if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.EntityType == EntityType.Method) { var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy); outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(member).GetChildrenByRole(Roles.TypeParameter)); } }
public string OutputNode (AstNode node) { using (var stringWriter = new System.IO.StringWriter ()) { var formatter = new TextWriterTokenWriter (stringWriter); // formatter.Indentation = indentLevel; stringWriter.NewLine = Document.Editor.EolMarker; var visitor = new CSharpOutputVisitor (formatter, FormattingOptionsFactory.CreateMono ()); node.AcceptVisitor (visitor); return stringWriter.ToString (); } }
private void CreateDesignerMasterPageFile(string designerFilePath) { string typeName; string typeNamespace; DotNetParserHelper.SplitType(this.TargetClassFullName, out typeName, out typeNamespace); StringBuilder sb = new StringBuilder(); sb.AppendLine("using System;"); sb.AppendLine("using System.Collections.Generic;"); sb.AppendLine("using System.Linq;"); sb.AppendLine("using System.Text;"); sb.AppendLine("using MMDB.UITest.Core;"); sb.AppendLine("using WatiN.Core;"); sb.AppendLine(); sb.AppendLine(string.Format("namespace {0}", typeNamespace)); sb.AppendLine("{"); sb.AppendLine(string.Format("[{0}(\"{1}\")]", typeof(UIClientPageAttribute).FullName, this.SourceClassFullName)); sb.AppendLine(string.Format("partial class {0} : {1}", typeName, typeof(BaseMasterPageClient).FullName)); sb.AppendLine("{"); sb.AppendLine(); sb.AppendLine(string.Format("public {0} (Browser browser) : base(browser) {{}}", typeName)); sb.AppendLine(); sb.AppendLine("}"); sb.AppendLine("}"); CSharpParser parser = new CSharpParser(); var compilationUnit = parser.Parse(sb.ToString(), Path.GetFileName(designerFilePath)); if (!Directory.Exists(Path.GetDirectoryName(designerFilePath))) { Directory.CreateDirectory(Path.GetDirectoryName(designerFilePath)); } using (StreamWriter writer = new StreamWriter(designerFilePath)) { CSharpOutputVisitor outputVistor = new CSharpOutputVisitor(writer, new CSharpFormattingOptions()); compilationUnit.AcceptVisitor(outputVistor, null); } }
void WriteTypeDeclarationName(ITypeDefinition typeDef, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); if (typeDef.DeclaringTypeDefinition != null) { WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, formatter, formattingPolicy); formatter.WriteToken("."); } else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) == ConversionFlags.UseFullyQualifiedTypeNames) { formatter.WriteIdentifier(typeDef.Namespace); formatter.WriteToken("."); } formatter.WriteIdentifier(typeDef.Name); if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList) { var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy); outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(typeDef).GetChildrenByRole(Roles.TypeParameter)); } }
internal static void Print (AstNode node) { var v = new CSharpOutputVisitor (Console.Out, FormattingOptionsFactory.CreateMono ()); node.AcceptVisitor (v); }
public static string PrintPrimitiveValue(object val) { StringWriter writer = new StringWriter(); CSharpOutputVisitor visitor = new CSharpOutputVisitor(writer, new CSharpFormattingOptions()); visitor.WritePrimitiveValue(val); return writer.ToString(); }
void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(typeDef); if (typeDef.DeclaringTypeDefinition != null) { WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy); writer.WriteToken(Roles.Dot, "."); } else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) == ConversionFlags.UseFullyQualifiedTypeNames) { WriteQualifiedName(typeDef.Namespace, writer, formattingPolicy); writer.WriteToken(Roles.Dot, "."); } writer.WriteIdentifier(node.NameToken); if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList) { var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy); outputVisitor.WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter)); } }
static string OutputNode (MonoDevelop.Ide.Gui.Document doc, AstNode node) { using (var stringWriter = new System.IO.StringWriter ()) { // formatter.Indentation = indentLevel; var formatter = new TextWriterOutputFormatter (stringWriter); stringWriter.NewLine = doc.Editor.EolMarker; var visitor = new CSharpOutputVisitor (formatter, doc.GetFormattingOptions ()); node.AcceptVisitor (visitor); return stringWriter.ToString (); } }
void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(member); if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) { ConvertType(member.DeclaringType, writer, formattingPolicy); writer.WriteToken(Roles.Dot, "."); } switch (member.SymbolKind) { case SymbolKind.Indexer: writer.WriteKeyword(Roles.Identifier, "this"); break; case SymbolKind.Constructor: WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); break; case SymbolKind.Destructor: writer.WriteToken(DestructorDeclaration.TildeRole, "~"); WriteQualifiedName(member.DeclaringType.Name, writer, formattingPolicy); break; case SymbolKind.Operator: switch (member.Name) { case "op_Implicit": writer.WriteKeyword(OperatorDeclaration.ImplicitRole, "implicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; case "op_Explicit": writer.WriteKeyword(OperatorDeclaration.ExplicitRole, "explicit"); writer.Space(); writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); ConvertType(member.ReturnType, writer, formattingPolicy); break; default: writer.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator"); writer.Space(); var operatorType = OperatorDeclaration.GetOperatorType(member.Name); if (operatorType.HasValue) writer.WriteToken(OperatorDeclaration.GetRole(operatorType.Value), OperatorDeclaration.GetToken(operatorType.Value)); else writer.WriteIdentifier(node.NameToken); break; } break; default: writer.WriteIdentifier(Identifier.Create(member.Name)); break; } if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.SymbolKind == SymbolKind.Method) { var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy); outputVisitor.WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter)); } }
void WriteQualifiedName(string name, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { var node = AstType.Create(name); var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy); node.AcceptVisitor(outputVisitor); }
void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy) { TypeSystemAstBuilder astBuilder = CreateAstBuilder(); EntityDeclaration node = astBuilder.ConvertEntity(typeDef); if (typeDef.DeclaringTypeDefinition != null) { WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy); writer.WriteTokenOperator(Roles.Dot, "."); } else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) == ConversionFlags.UseFullyQualifiedEntityNames) { if (!string.IsNullOrEmpty(typeDef.Namespace)) { WriteQualifiedName(typeDef.Namespace, writer, formattingPolicy); writer.WriteTokenOperator(Roles.Dot, "."); } } writer.WriteIdentifier(node.NameToken, BoxedTextColor.Text); if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList) { var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy); outputVisitor.WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter), CodeBracesRangeFlags.AngleBrackets); } }