Exemplo n.º 1
0
        public static ILSpyUnresolvedFile Create(DecompiledTypeReference name, AstBuilder builder)
        {
            var writer = new StringWriter();
            var target = new TextWriterTokenWriter(writer)
            {
                IndentationString = "\t"
            };
            var output = new DebugInfoTokenWriterDecorator(TokenWriter.WrapInWriterThatSetsLocationsInAST(target));

            builder.RunTransformations();
            var syntaxTree = builder.SyntaxTree;

            syntaxTree.AcceptVisitor(new InsertParenthesesVisitor {
                InsertParenthesesForReadability = true
            });
            syntaxTree.AcceptVisitor(new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop()));
            ILSpyUnresolvedFile file = new ILSpyUnresolvedFile(name);
            var v = new TypeSystemConvertVisitor(file);

            syntaxTree.AcceptVisitor(v);

            file.MemberLocations = output.MemberLocations;
            file.DebugSymbols    = output.DebugSymbols;
            file.output          = writer.ToString();

            return(file);
        }
Exemplo n.º 2
0
            public void ConvertType(IType type, TextWriterTokenWriter formatter, CSharpFormattingOptions formattingPolicy)
            {
                TypeSystemAstBuilder astBuilder = CreateAstBuilder();
                AstType astType = astBuilder.ConvertType(type);

                astType.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
            }
Exemplo n.º 3
0
        static string CleanUpVariableName(string name)
        {
            // remove the backtick (generics)
            int pos = name.IndexOf('`');

            if (pos >= 0)
            {
                name = name.Substring(0, pos);
            }

            // remove field prefix:
            if (name.Length > 2 && name.StartsWith("m_", StringComparison.Ordinal))
            {
                name = name.Substring(2);
            }
            else if (name.Length > 1 && name[0] == '_' && (char.IsLetter(name[1]) || name[1] == '_'))
            {
                name = name.Substring(1);
            }

            if (TextWriterTokenWriter.ContainsNonPrintableIdentifierChar(name))
            {
                return(null);
            }

            if (name.Length == 0)
            {
                return("obj");
            }
            else
            {
                return(char.ToLower(name[0]) + name.Substring(1));
            }
        }
Exemplo n.º 4
0
        public override void WriteIdentifier(Identifier identifier)
        {
            if (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier))
            {
                output.Write('@');
            }

            var    definition = GetCurrentDefinition();
            string name       = TextWriterTokenWriter.EscapeIdentifier(identifier.Name);

            switch (definition)
            {
            case IType t:
                output.WriteReference(t, name, true);
                return;

            case IMember m:
                output.WriteReference(m, name, true);
                return;
            }

            var member = GetCurrentMemberReference();

            switch (member)
            {
            case IType t:
                output.WriteReference(t, name, false);
                return;

            case IMember m:
                output.WriteReference(m, name, false);
                return;
            }

            var localDefinition = GetCurrentLocalDefinition();

            if (localDefinition != null)
            {
                output.WriteLocalReference(name, localDefinition, isDefinition: true);
                return;
            }

            var localRef = GetCurrentLocalReference();

            if (localRef != null)
            {
                output.WriteLocalReference(name, localRef);
                return;
            }

            if (firstUsingDeclaration && !lastUsingDeclaration)
            {
                output.MarkFoldStart(defaultCollapsed: !settings.ExpandUsingDeclarations);
                firstUsingDeclaration = false;
            }

            output.Write(name);
        }
Exemplo n.º 5
0
        static void WriteCode(TextWriter output, DecompilerSettings settings, SyntaxTree syntaxTree, IDecompilerTypeSystem typeSystem)
        {
            syntaxTree.AcceptVisitor(new InsertParenthesesVisitor {
                InsertParenthesesForReadability = true
            });
            TokenWriter tokenWriter = new TextWriterTokenWriter(output);

            tokenWriter = TokenWriter.WrapInWriterThatSetsLocationsInAST(tokenWriter);
            syntaxTree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, settings.CSharpFormattingOptions));
        }
Exemplo n.º 6
0
 public static string FormatValue(Thread evalThread, Value val)
 {
     if (val.IsNull)
     {
         return("null");
     }
     else if (val.Type.Kind == TypeKind.Array)
     {
         StringBuilder sb = new StringBuilder();
         sb.Append(new CSharpAmbience().ConvertType(val.Type));
         sb.Append(" {");
         bool first = true;
         int  size  = val.ArrayLength;
         for (int i = 0; i < size; i++)
         {
             if (!first)
             {
                 sb.Append(", ");
             }
             first = false;
             sb.Append(FormatValue(evalThread, val.GetElementAtPosition(i)));
         }
         sb.Append("}");
         return(sb.ToString());
     }
     else if (val.Type.GetAllBaseTypeDefinitions().Any(def => def.IsKnownType(KnownTypeCode.ICollection)))
     {
         StringBuilder sb = new StringBuilder();
         sb.Append(new CSharpAmbience().ConvertType(val.Type));
         sb.Append(" {");
         val = val.GetPermanentReference(evalThread);
         var countProp = val.Type.GetProperties(p => p.Name == "Count" && !p.IsExplicitInterfaceImplementation).Single();
         int count     = (int)val.GetMemberValue(evalThread, countProp).PrimitiveValue;
         for (int i = 0; i < count; i++)
         {
             if (i > 0)
             {
                 sb.Append(", ");
             }
             var   itemProperty = val.Type.GetProperties(p => p.IsIndexer && p.Name == "Item" && !p.IsExplicitInterfaceImplementation).Single();
             Value item         = val.GetPropertyValue(evalThread, itemProperty, Eval.CreateValue(evalThread, i));
             sb.Append(FormatValue(evalThread, item));
         }
         sb.Append("}");
         return(sb.ToString());
     }
     else if (val.Type.IsKnownType(KnownTypeCode.String) || val.Type.IsPrimitiveType())
     {
         return(TextWriterTokenWriter.PrintPrimitiveValue(val.PrimitiveValue));
     }
     else
     {
         return(val.InvokeToString(evalThread));
     }
 }
Exemplo n.º 7
0
 void PrintModifiers(Modifiers modifiers, TextWriterTokenWriter formatter)
 {
     foreach (var m in CSharpModifierToken.AllModifiers)
     {
         if ((modifiers & m) == m)
         {
             formatter.WriteToken(TypeDeclaration.ModifierRole, CSharpModifierToken.GetModifierName(m));
             formatter.Space();
         }
     }
 }
        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());
            }
        }
Exemplo n.º 9
0
        static string OutputNode(MonoDevelop.Ide.Gui.Document doc, AstNode node)
        {
            using (var stringWriter = new System.IO.StringWriter()) {
//				formatter.Indentation = indentLevel;
                var formatter = new TextWriterTokenWriter(stringWriter);
                stringWriter.NewLine = doc.Editor.EolMarker;

                var visitor = new CSharpOutputVisitor(formatter, doc.GetFormattingOptions());
                node.AcceptVisitor(visitor);
                return(stringWriter.ToString());
            }
        }
Exemplo n.º 10
0
        public override RichText GetRichTextTooltip(IEntity entity)
        {
            var flags           = ConversionFlags.All & ~(ConversionFlags.ShowBody | ConversionFlags.PlaceReturnTypeAfterParameterList);
            var output          = new StringWriter();
            var decoratedWriter = new TextWriterTokenWriter(output);
            var writer          = new CSharpHighlightingTokenWriter(TokenWriter.InsertRequiredSpaces(decoratedWriter), locatable: decoratedWriter);

            new CSharpAmbience()
            {
                ConversionFlags = flags
            }.ConvertSymbol(entity, writer, new DecompilerSettings().CSharpFormattingOptions);
            return(new RichText(output.ToString(), writer.HighlightingModel));
        }
Exemplo n.º 11
0
        public string Generate(ISymbol symbol)
        {
            if (symbol == null)
            {
                throw new ArgumentNullException("symbol");
            }

            StringWriter writer = new StringWriter();

            _writer = new TextWriterTokenWriter(writer);
            _policy = FormattingOptionsFactory.CreateMono();

            TypeSystemAstBuilder astBuilder = CreateAstBuilder();

            astBuilder.AlwaysUseShortTypeNames = true;
            AstNode node = astBuilder.ConvertSymbol(symbol);

            if (symbol is ITypeDefinition)
            {
                WriteTypeDeclarationName((ITypeDefinition)symbol, _writer, _policy);
            }
            else if (symbol is IMember)
            {
                WriteMemberDeclarationName((IMember)symbol, _writer, _policy);
            }
            else
            {
                _writer.WriteIdentifier(Identifier.Create(symbol.Name));
            }


            if (HasParameters(symbol))
            {
                _writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, symbol.SymbolKind == SymbolKind.Indexer ? "[" : "(");
                IEnumerable <ParameterDeclaration> parameters = new List <ParameterDeclaration>(node.GetChildrenByRole(Roles.Parameter));
                if (symbol is IMethod && ((IMethod)symbol).IsExtensionMethod)
                {
                    parameters = parameters.Skip(1);
                }

                WriteCommaSeparatedList(parameters);
                _writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.RBracket : Roles.RPar, symbol.SymbolKind == SymbolKind.Indexer ? "]" : ")");
            }
            if (_includePlaceholders)
            {
                _writer.WriteToken(Roles.Text, "$0");
            }
            return(writer.ToString());
        }
Exemplo n.º 12
0
 static string ToString(object val)
 {
     if (val == null)
     {
         return("null");
     }
     else if (val is string)
     {
         return("\"" + TextWriterTokenWriter.ConvertString((string)val) + "\"");
     }
     else if (val is char)
     {
         return("'" + TextWriterTokenWriter.ConvertChar((char)val) + "'");
     }
     else
     {
         return(val.ToString());
     }
 }
Exemplo n.º 13
0
        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 TextWriterTokenWriter(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));
            }
        }
Exemplo n.º 14
0
            void WriteTypeDeclarationName(ITypeDefinition typeDef, TextWriterTokenWriter formatter, CSharpFormattingOptions formattingPolicy)
            {
                TypeSystemAstBuilder astBuilder = CreateAstBuilder();

                if (typeDef.DeclaringTypeDefinition != null)
                {
                    WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, formatter, formattingPolicy);
                    formatter.WriteToken(Roles.Dot, ".");
                }
                else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) == ConversionFlags.UseFullyQualifiedTypeNames)
                {
                    formatter.WriteIdentifier(Identifier.Create(typeDef.Namespace));
                    formatter.WriteToken(Roles.Dot, ".");
                }
                formatter.WriteIdentifier(Identifier.Create(typeDef.Name));
                if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList)
                {
                    var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
                    outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(typeDef).GetChildrenByRole(Roles.TypeParameter));
                }
            }
Exemplo n.º 15
0
        private void TestCreateSequencePoints(string code, params string[] expectedSequencePoints)
        {
            var decompiler = Tester.GetDecompilerForSnippet(code);

            var firstType = decompiler.TypeSystem.Compilation.GetTopLevelTypeDefinitions().First(t => code.Contains(t.Name));
            var tree      = decompiler.DecompileType(firstType.FullTypeName);

            var output = new StringWriter();

            tree.AcceptVisitor(new InsertParenthesesVisitor {
                InsertParenthesesForReadability = true
            });
            TokenWriter tokenWriter = new TextWriterTokenWriter(output);

            tokenWriter = new InsertMissingTokensDecorator(tokenWriter, (ILocatable)tokenWriter);
            var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop();

            tree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, formattingOptions));

            var functionsWithSequencePoints = decompiler.CreateSequencePoints(tree);
            var finalText = output.ToString();

            var lines = finalText.Split(new[] { output.NewLine }, StringSplitOptions.None);

            var actualSequencePoints = new List <string>();

            foreach (var sequencePoint in functionsWithSequencePoints.Values.First())
            {
                if (sequencePoint.IsHidden)
                {
                    continue;
                }

                var line = lines[sequencePoint.StartLine - 1];
                var text = line.Substring(sequencePoint.StartColumn - 1, sequencePoint.EndColumn - sequencePoint.StartColumn);
                actualSequencePoints.Add(text);
            }

            Assert.True(Enumerable.SequenceEqual(expectedSequencePoints, actualSequencePoints));
        }
Exemplo n.º 16
0
        public string ConvertSymbol(ISymbol symbol)
        {
            var stringWriter = new StringWriter();
            var astBuilder   = new TypeSystemAstBuilder();

            astBuilder.AlwaysUseShortTypeNames = true;
            AstNode node   = astBuilder.ConvertSymbol(symbol);
            var     writer = new TextWriterTokenWriter(stringWriter);
            var     rt     = node.GetChildByRole(Roles.Type);

            if (!rt.IsNull)
            {
                rt.AcceptVisitor(new CSharpOutputVisitor(stringWriter, FormattingOptionsFactory.CreateMono()));
            }

            IProperty property = symbol as IProperty;

            if (property != null)
            {
                writer.Space();
                writer.WriteToken(Roles.LBrace, "{");
                writer.Space();
                if (property.CanGet)
                {
                    writer.WriteKeyword(PropertyDeclaration.GetKeywordRole, "get");
                    writer.WriteToken(Roles.Semicolon, ";");
                    writer.Space();
                }
                if (property.CanSet)
                {
                    writer.WriteKeyword(PropertyDeclaration.SetKeywordRole, "set");
                    writer.WriteToken(Roles.Semicolon, ";");
                    writer.Space();
                }
                writer.WriteToken(Roles.RBrace, "}");
            }
            return(stringWriter.ToString());
        }
Exemplo n.º 17
0
        void WriteStringId(BamlContext ctx, ushort id)
        {
            string str;

            if (id > 0x7fff)
            {
                str = ctx.KnownThings.Strings((short)-id);
            }
            else if (ctx.StringIdMap.ContainsKey(id))
            {
                str = ctx.StringIdMap[id].Value;
            }
            else
            {
                str = null;
            }
            string reference = null;

            if (str != null)
            {
                reference = string.Format("\"{0}\"", TextWriterTokenWriter.ConvertString(str));
            }
            output.WriteReference(string.Format("0x{0:x4}", id), reference, TextTokenType.Number, true);
        }
Exemplo n.º 18
0
            public void ConvertEntity(IEntity entity, TextWriterTokenWriter formatter, CSharpFormattingOptions formattingPolicy)
            {
                if (entity == null)
                {
                    throw new ArgumentNullException("entity");
                }
                if (formatter == null)
                {
                    throw new ArgumentNullException("formatter");
                }
                if (formattingPolicy == null)
                {
                    throw new ArgumentNullException("options");
                }

                TypeSystemAstBuilder astBuilder = CreateAstBuilder();
                EntityDeclaration    node       = astBuilder.ConvertEntity(entity);

                PrintModifiers(node.Modifiers, formatter);

                if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword)
                {
                    if (node is TypeDeclaration)
                    {
                        switch (((TypeDeclaration)node).ClassType)
                        {
                        case ClassType.Class:
                            formatter.WriteKeyword(Roles.ClassKeyword, "class");
                            break;

                        case ClassType.Struct:
                            formatter.WriteKeyword(Roles.StructKeyword, "struct");
                            break;

                        case ClassType.Interface:
                            formatter.WriteKeyword(Roles.InterfaceKeyword, "interface");
                            break;

                        case ClassType.Enum:
                            formatter.WriteKeyword(Roles.EnumKeyword, "enum");
                            break;

                        default:
                            throw new Exception("Invalid value for ClassType");
                        }
                        formatter.Space();
                    }
                    else if (node is DelegateDeclaration)
                    {
                        formatter.WriteKeyword(Roles.DelegateKeyword, "delegate");
                        formatter.Space();
                    }
                    else if (node is EventDeclaration)
                    {
                        formatter.WriteKeyword(EventDeclaration.EventKeywordRole, "event");
                        formatter.Space();
                    }
                }

                if ((ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
                {
                    var rt = node.GetChildByRole(Roles.Type);
                    if (!rt.IsNull)
                    {
                        rt.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
                        formatter.Space();
                    }
                }

                if (entity is ITypeDefinition)
                {
                    WriteTypeDeclarationName((ITypeDefinition)entity, formatter, formattingPolicy);
                }
                else
                {
                    WriteMemberDeclarationName((IMember)entity, formatter, formattingPolicy);
                }

                if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(entity))
                {
                    if (entity.SymbolKind == SymbolKind.Indexer)
                    {
                        formatter.WriteToken(Roles.LBracket, "[");
                    }
                    else
                    {
                        formatter.WriteToken(Roles.LBrace, "(");
                    }
                    bool first = true;
                    foreach (var param in node.GetChildrenByRole(Roles.Parameter))
                    {
                        if (first)
                        {
                            first = false;
                        }
                        else
                        {
                            formatter.WriteToken(Roles.Comma, ",");
                            formatter.Space();
                        }
                        param.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
                    }
                    if (entity.SymbolKind == SymbolKind.Indexer)
                    {
                        formatter.WriteToken(Roles.RBracket, "]");
                    }
                    else
                    {
                        formatter.WriteToken(Roles.RBrace, ")");
                    }
                }

                if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody && !(node is TypeDeclaration))
                {
                    IProperty property = entity as IProperty;
                    if (property != null)
                    {
                        formatter.Space();
                        formatter.WriteToken(Roles.LBrace, "{");
                        formatter.Space();
                        if (property.CanGet)
                        {
                            formatter.WriteKeyword(PropertyDeclaration.GetKeywordRole, "get");
                            formatter.WriteToken(Roles.Semicolon, ";");
                            formatter.Space();
                        }
                        if (property.CanSet)
                        {
                            formatter.WriteKeyword(PropertyDeclaration.SetKeywordRole, "set");
                            formatter.WriteToken(Roles.Semicolon, ";");
                            formatter.Space();
                        }
                        formatter.WriteToken(Roles.RBrace, "}");
                    }
                    else
                    {
                        formatter.WriteToken(Roles.Semicolon, ";");
                    }
                }
            }
Exemplo n.º 19
0
        static int Main(string[] args)
        {
            var assemblyFilenameOption = new Option <FileInfo>(
                new[] { "--assembly", "-a" },
                description: "The assembly to decompile into XML.");

            var verboseOption = new Option <bool>(
                new[] { "--verbose", "-v" },
                description: "Provide output as code is running.");

            var outputOption = new Option <DirectoryInfo>(
                new[] { "--output", "-o" },
                description: "The root directory where the XML files will be written. The directory must exist.");

            var rootCommand = new RootCommand
            {
                assemblyFilenameOption,
                verboseOption,
                outputOption,
            };

            rootCommand.Description = "Command to extract C# code into XML suitable for reasoning.";

            rootCommand.SetHandler((FileInfo assemblyFile, bool verbose, DirectoryInfo outputDirectory) =>
            {
                if (assemblyFile == null)
                {
                    Console.Error.WriteLine("No assembly provided to extract");
                    return;
                }

                if (outputDirectory == null)
                {
                    Console.Error.WriteLine("No target directory provided");
                    return;
                }

                // Set up the preferences for the decompilation of the IL into source.
                var settings = new DecompilerSettings()
                {
                    AlwaysUseBraces      = true,
                    ShowXmlDocumentation = true
                };
                settings.CSharpFormattingOptions.IndentationString = "    ";

                var decompiler = new CSharpDecompiler(assemblyFile.FullName, settings);

                // Traverse all the types in the assembly
                foreach (var typeDefinition in decompiler.TypeSystem.MainModule.TopLevelTypeDefinitions)
                {
                    if (typeDefinition.Name.StartsWith("<"))
                    {
                        continue;
                    }

                    if (verbose)
                    {
                        Console.WriteLine($"Extracting {typeDefinition.FullName}.");
                    }
                    var syntaxTree = decompiler.DecompileType(typeDefinition.FullTypeName);

                    // This is needed to get the locations correctly set in the AST.
                    StringWriter w = new StringWriter();

                    var q = new TextWriterTokenWriter(w);
                    q.IndentationString = "    ";

                    TokenWriter tokenWriter = q;

                    tokenWriter = TokenWriter.WrapInWriterThatSetsLocationsInAST(tokenWriter);
                    syntaxTree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, settings.CSharpFormattingOptions));
                    var source = w.ToString();

                    var generator = new XmlGeneratorVisitor(assemblyFile.FullName, source);
                    syntaxTree.AcceptVisitor(generator);

                    File.WriteAllText(Path.Combine(outputDirectory.FullName, typeDefinition.FullTypeName.Name) + ".xml", generator.Document.ToString());
                }
            },
                                   assemblyFilenameOption, verboseOption, outputOption);

            return(rootCommand.Invoke(args));
        }
Exemplo n.º 20
0
        void WriteDefinition(string value, string def = null)
        {
            string str = string.Format("\"{0}\"", TextWriterTokenWriter.ConvertString(value));

            output.WriteDefinition(str, def ?? IdentifierEscaper.Escape(value), TextTokenType.String, true);
        }
Exemplo n.º 21
0
        public override void WritePrimitiveValue(object value, TextTokenKind?tokenKind = null, string literalValue = null)
        {
            int column = 0;

            TextWriterTokenWriter.WritePrimitiveValue(value, tokenKind, literalValue, ref column, (a, b) => output.Write(a, b), WriteToken);
        }
Exemplo n.º 22
0
 static string ToString(object val)
 {
     return(TextWriterTokenWriter.PrintPrimitiveValue(val));
 }
Exemplo n.º 23
0
 public override void WriteInterpolatedText(string text)
 {
     output.Write(TextWriterTokenWriter.ConvertString(text));
 }
Exemplo n.º 24
0
            void WriteMemberDeclarationName(IMember member, TextWriterTokenWriter formatter, CSharpFormattingOptions formattingPolicy)
            {
                TypeSystemAstBuilder astBuilder = CreateAstBuilder();

                if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType)
                {
                    ConvertType(member.DeclaringType, formatter, formattingPolicy);
                    formatter.WriteToken(Roles.Dot, ".");
                }
                switch (member.SymbolKind)
                {
                case SymbolKind.Indexer:
                    formatter.WriteKeyword(IndexerDeclaration.ThisKeywordRole, "this");
                    break;

                case SymbolKind.Constructor:
                    formatter.WriteIdentifier(Identifier.Create(member.DeclaringType.Name));
                    break;

                case SymbolKind.Destructor:
                    formatter.WriteToken(DestructorDeclaration.TildeRole, "~");
                    formatter.WriteIdentifier(Identifier.Create(member.DeclaringType.Name));
                    break;

                case SymbolKind.Operator:
                    switch (member.Name)
                    {
                    case "op_Implicit":
                        formatter.WriteKeyword(OperatorDeclaration.ImplicitRole, "implicit");
                        formatter.Space();
                        formatter.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator");
                        formatter.Space();
                        ConvertType(member.ReturnType, formatter, formattingPolicy);
                        break;

                    case "op_Explicit":
                        formatter.WriteKeyword(OperatorDeclaration.ExplicitRole, "explicit");
                        formatter.Space();
                        formatter.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator");
                        formatter.Space();
                        ConvertType(member.ReturnType, formatter, formattingPolicy);
                        break;

                    default:
                        formatter.WriteKeyword(OperatorDeclaration.OperatorKeywordRole, "operator");
                        formatter.Space();
                        var operatorType = OperatorDeclaration.GetOperatorType(member.Name);
                        if (operatorType.HasValue)
                        {
                            formatter.WriteToken(OperatorDeclaration.GetRole(operatorType.Value), OperatorDeclaration.GetToken(operatorType.Value));
                        }
                        else
                        {
                            formatter.WriteIdentifier(Identifier.Create(member.Name));
                        }
                        break;
                    }
                    break;

                default:
                    formatter.WriteIdentifier(Identifier.Create(member.Name));
                    break;
                }
                if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.SymbolKind == SymbolKind.Method)
                {
                    var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
                    outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(member).GetChildrenByRole(Roles.TypeParameter));
                }
            }
Exemplo n.º 25
0
        public override void WritePrimitiveValue(object value, TextTokenType?tokenType = null, string literalValue = null)
        {
            int column = 0;

            TextWriterTokenWriter.WritePrimitiveValue(value, tokenType, literalValue, ref column, (a, b) => output.Write(a, b), (a, b, c) => WriteToken(a, b, c));
        }
Exemplo n.º 26
0
        void WriteString(string value)
        {
            string str = string.Format("\"{0}\"", TextWriterTokenWriter.ConvertString(value));

            output.Write(str, TextTokenType.String);
        }