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