C# SyntaxNode.ToString方法代码示例

 public void IsCreateThreadInLoop(SyntaxNode node)
 {
     if (node.ToString().Contains("new Thread") && node.Parent.ToString().Contains(".Join"))
     {
         if (Id.ToLower().Contains("test"))
             Helper.WriteInstance(LoopThreadTestFile, Id, node.Parent.ToString());
         else
             Helper.WriteInstance(LoopThreadFile, Id, node.Parent.ToString());
     }
 }

        public override void Visit(SyntaxNode node)
        {
            var t = node.Kind();
            if (node.IsKind(SyntaxKind.IdentifierName))
            {
                var name = node.ToString();
                string syntax;
                if (_DefinedOutside.TryGetValue(name, out syntax))
                {
                    _DefinedOutside.Remove(name);
                    sb.Append(syntax);
                }
            }
            /*
            var symbol = _model.GetSymbolInfo(node).Symbol;
            var ca = _model.GetSymbolInfo(node).CandidateSymbols;
            var declaredSymbol = _model.GetDeclaredSymbol(node);

            if (symbol?.Kind == SymbolKind.Field)
            {
                var x = 3;
            }
            if (symbol != null)
            {
                var test = symbol.CanBeReferencedByName;
                var sources = symbol.DeclaringSyntaxReferences;

                if (sources.Any())
                {
                    foreach (var source in sources)
                    {
                        if (source.Span.Start > _end
                            || source.Span.End < _start)
                        {
                            //DefinedOutside.Add(source.GetSyntax().ToFullString());
                        }
                    }
                }
                var locations = symbol?.Locations;
                if (locations.HasValue)
                {
                    /*
                    foreach (var location in locations.Value)
                    {
                        if (location.SourceSpan.Start > _end
                            || location.SourceSpan.End < _start)
                        {
                            DefinedOutside.Add(symbol);
                        }
                    }

                }
            }*/
            base.Visit(node);
        }

 public void IsCreateTaskInLoop(SyntaxNode node)
 {
     if (node.DescendantNodes().OfType<IdentifierNameSyntax>().Any(a => "StartNew".Equals(a.ToString()))
         && !node.ToString().Contains("Stopwatch"))
     {
         if (Id.ToLower().Contains("test"))
             Helper.WriteInstance(LoopTaskTestFile, Id, node.Parent.ToString());
         else
             Helper.WriteInstance(LoopTaskFile, Id, node.Parent.ToString());
     }
 }

        public static string CreateBaseName(SyntaxNode node, ITypeSymbol type)
        {
            string name = null;

            if (node.IsKind(SyntaxKind.Argument))
                node = ((ArgumentSyntax)node).Expression;

            if (node.IsKind(SyntaxKind.NullLiteralExpression))
                return "o";
            if (node.IsKind(SyntaxKind.InvocationExpression))
                return CreateBaseName(((InvocationExpressionSyntax)node).Expression, type);
            if (node.IsKind(SyntaxKind.IdentifierName))
            {
                name = node.ToString();
            }
            else if (node is MemberAccessExpressionSyntax)
            {
                name = ((MemberAccessExpressionSyntax)node).Name.ToString();
            }
            else if (node is LiteralExpressionSyntax)
            {
                var pe = (LiteralExpressionSyntax)node;
                if (pe.IsKind(SyntaxKind.StringLiteralExpression))
                {
                    name = CreateBaseNameFromString(pe.Token.ToString());
                }
                else
                {
                    return char.ToLower(type.Name[0]).ToString();
                }
            }
            else if (node is ArrayCreationExpressionSyntax)
            {
                name = "arr";
            }
            else
            {
                if (type.TypeKind == TypeKind.Error)
                    return "par";
                name = GuessNameFromType(type);
            }
            var sb = new StringBuilder();
            sb.Append(char.ToLower(name[0]));
            for (int i = 1; i < name.Length; i++)
            {
                var ch = name[i];
                if (char.IsLetterOrDigit(ch) || ch == '_')
                    sb.Append(ch);
            }
            return sb.ToString();
        }

        private static void FixMissingType(SyntaxNode node, Scope scope)
        {
            var type = node
                .Ancestors()
                .OfType<TypeDeclarationSyntax>()
                .FirstOrDefault();

            if (type != null)
            {
                var typeScope = scope.GetScope<SyntaxToken, SyntaxNode, SemanticModel>(type);
                if (typeScope != null)
                {
                    SyntaxNode realType = typeScope.get<SyntaxNode>("__tdef" + node.ToString());
                    if (realType != null)
                    {
                        realType = RoslynCompiler.Mark(realType); //make sure not to duplicate nodes

                        var document = scope.GetDocument<SyntaxToken, SyntaxNode, SemanticModel>();
                        document.change(node, RoslynCompiler.ReplaceNode(realType));
                    }
                }
            }
        }

			string GetName (SyntaxNode node)
			{
				if (tag is SyntaxTree) {
					var type = node as TypeDeclarationSyntax;
					if (type != null) {
						var sb = new StringBuilder ();
						sb.Append (type.Identifier.ToString ());
						while (type.Parent is TypeDeclarationSyntax) {
							type = type.Parent as TypeDeclarationSyntax;
							sb.Insert (0, type.Identifier + ".");
						}
						return sb.ToString ();
					}
					var delegateDecl = node as DelegateDeclarationSyntax;
					if (delegateDecl != null) {
						var sb = new StringBuilder ();
						sb.Append (delegateDecl.Identifier.ToString ());
						var parentType = delegateDecl.Parent as TypeDeclarationSyntax;
						while (parentType != null) {
							sb.Insert (0, parentType.Identifier + ".");
							parentType = parentType.Parent as TypeDeclarationSyntax;
						}
						return sb.ToString ();
					}
				}
				var accessor = node as AccessorDeclarationSyntax;
				if (accessor != null) {
					if (accessor.Kind () == SyntaxKind.GetAccessorDeclaration)
						return "get";
					if (accessor.Kind () == SyntaxKind.SetAccessorDeclaration)
						return "set";
					if (accessor.Kind () == SyntaxKind.AddAccessorDeclaration)
						return "add";
					if (accessor.Kind () == SyntaxKind.RemoveAccessorDeclaration)
						return "remove";
					return node.ToString ();
				}
				if (node is OperatorDeclarationSyntax)
					return "operator";
				if (node is PropertyDeclarationSyntax)
					return ((PropertyDeclarationSyntax)node).Identifier.ToString ();
				if (node is MethodDeclarationSyntax)
					return ((MethodDeclarationSyntax)node).Identifier.ToString ();
				if (node is ConstructorDeclarationSyntax)
					return ((ConstructorDeclarationSyntax)node).Identifier.ToString ();
				if (node is DestructorDeclarationSyntax)
					return ((DestructorDeclarationSyntax)node).Identifier.ToString ();
				if (node is BaseTypeDeclarationSyntax)
					return ((BaseTypeDeclarationSyntax)node).Identifier.ToString ();

//				if (node is fixeds) {
//					return ((FixedVariableInitializer)node).Name;
//				}
				if (node is VariableDeclaratorSyntax)
					return ((VariableDeclaratorSyntax)node).Identifier.ToString ();
				return node.ToString ();
			}

 protected void GenerateUnknown(SyntaxNode node)
 {
     using (QuoteTag(GetLineNumber(node)))
     {
         EncodedText(node.ToString());
     }
 }

            public override void Visit(SyntaxNode node)
            {
                if (node is ExpressionSyntax)
                {
                    var type = SemanticModel.GetTypeInfo((ExpressionSyntax)node).Type;
                    if (type != null)
                    {
                        Results.AppendLine();
                        Results.Append(node.GetType().Name);
                        Results.Append(" ");
                        Results.Append(node.ToString());
                        Results.Append(" has type ");
                        Results.Append(type.ToDisplayString());
                    }
                }

                base.Visit(node);
            }

		public async Task<string> OutputNode (SyntaxNode node, CancellationToken cancellationToken = default(CancellationToken))
		{
			node = Formatter.Format (node, TypeSystemService.Workspace, FormattingOptions, cancellationToken);

			var text = Editor.Text;
			string nodeText = node.ToString ();
			text = text.Insert (offset, nodeText);

			var backgroundDocument = DocumentContext.AnalysisDocument.WithText (SourceText.From (text));

			var currentRoot = await backgroundDocument.GetSyntaxRootAsync (cancellationToken).ConfigureAwait (false);

			// add formatter & simplifier annotations 
			var oldNode = currentRoot.FindNode (TextSpan.FromBounds(offset, offset + nodeText.Length));
			currentRoot = currentRoot.ReplaceNode (oldNode, oldNode.WithAdditionalAnnotations (Formatter.Annotation, Simplifier.Annotation)); 

			// get updated node
			node = currentRoot.FindNode (TextSpan.FromBounds(offset, offset + nodeText.Length));
			currentRoot = currentRoot.TrackNodes (node);

			backgroundDocument = backgroundDocument.WithSyntaxRoot (currentRoot);
			backgroundDocument = await Formatter.FormatAsync (backgroundDocument, Formatter.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
			backgroundDocument = await Simplifier.ReduceAsync (backgroundDocument, Simplifier.Annotation, cancellationToken: cancellationToken).ConfigureAwait(false);
			var newRoot = await backgroundDocument.GetSyntaxRootAsync (cancellationToken).ConfigureAwait (false);

			var formattedNode = newRoot.GetCurrentNode (node);
			if (formattedNode == null) {
				LoggingService.LogError ("Fatal error: Can't find current formatted node in code generator document.");
				return nodeText;
			}
			return formattedNode.ToString ();
		}

		ParameterHintingResult HandleTypeParameterCase(SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
		{
			var result = new ParameterHintingResult(node.SpanStart);
			string typeName;
			var gns = node as GenericNameSyntax;
			if (gns != null) {
				typeName = gns.Identifier.ToString ();
			} else {
				typeName = node.ToString ();
			}

			foreach (var cand in semanticModel.LookupSymbols (node.SpanStart).OfType<INamedTypeSymbol> ()) {
				if (cand.TypeParameters.Length == 0)
					continue;
				if (cand.Name == typeName || cand.GetFullName () == typeName)
					result.AddData(factory.CreateTypeParameterDataProvider(cand));
			}

			if (result.Count == 0) {
				foreach (var cand in semanticModel.LookupSymbols (node.SpanStart).OfType<IMethodSymbol> ()) {
					if (cand.TypeParameters.Length == 0)
						continue;
					if (cand.Name == typeName)
						result.AddData (factory.CreateTypeParameterDataProvider (cand));
				}
			}
			return result;
		}

 /// <summary>
 /// Adds new error trace to the trace for
 /// the specified syntax node.
 /// </summary>
 /// <param name="syntaxNode">SyntaxNode</param>
 internal void AddErrorTrace(SyntaxNode syntaxNode)
 {
     var errorTraceStep = new ErrorTraceStep(syntaxNode.ToString(),
         syntaxNode.SyntaxTree.FilePath, syntaxNode.SyntaxTree.GetLineSpan(
             syntaxNode.Span).StartLinePosition.Line + 1);
     this.ErrorTrace.Add(errorTraceStep);
 }

        private IEnumerable<IPackageIndexModelInfo> CollectExtensionSuggestions(SyntaxNode node, IEnumerable<TargetFrameworkMetadata> distinctTargetFrameworks)
        {
            string entityName;
            IEnumerable<IPackageIndexModelInfo> potentialSuggestions = null;
            if (_syntaxHelper.IsExtension(node))
            {
                entityName = node.ToString().NormalizeGenericName();

                potentialSuggestions = _packageSearcher.SearchExtension(entityName);
            }

            if (potentialSuggestions == null || !potentialSuggestions.Any())
            {
                return Enumerable.Empty<IPackageIndexModelInfo>();
            }

            return TargetFrameworkHelper.GetSupportedPackages(potentialSuggestions,
                                                              distinctTargetFrameworks, 
                                                              allowHigherVersions: true);
        }

        private IEnumerable<IPackageIndexModelInfo> CollectTypeSuggestions(SyntaxNode node, IEnumerable<TargetFrameworkMetadata> distinctTargetFrameworks)
        {
            var potentialSuggestions = new List<IPackageIndexModelInfo>();
            if (_syntaxHelper.IsType(node))
            {
                var entityNamesToSearchFor = new List<string>();
                var entityName = node.ToString().NormalizeGenericName();
                entityNamesToSearchFor.Add(entityName);

                if (_syntaxHelper.IsAttribute(node) && !entityName.EndsWith("Attribute"))
                {
                    entityNamesToSearchFor.Add(entityName + "Attribute");
                }

                foreach (var entity in entityNamesToSearchFor)
                {
                    var suggestions = _packageSearcher.SearchType(entity);
                    if (suggestions != null)
                    {
                        potentialSuggestions.AddRange(suggestions);
                    }
                }
            }

            if (potentialSuggestions == null || !potentialSuggestions.Any())
            {
                return Enumerable.Empty<IPackageIndexModelInfo>();
            }

            return TargetFrameworkHelper.GetSupportedPackages(potentialSuggestions,
                                                              distinctTargetFrameworks, 
                                                              allowHigherVersions: true);
        }       

        /// <summary>
        /// True if the given syntax node is a machine method.
        /// </summary>
        /// <param name="node">SyntaxNode</param>
        /// <returns>Boolean value</returns>
        protected bool IsMachineMethod(SyntaxNode node)
        {
            var result = false;

            MachineDeclaration machine = null;
            if (!this.TryGetParentMachine(node, out machine))
            {
                return result;
            }

            result = machine.MethodDeclarations.
                Any(s => s.Identifier.TextUnit.Text.Equals(node.ToString()));

            if (!result)
            {
                result = machine.FieldDeclarations.
                    Any(s => s.Identifier.TextUnit.Text.Equals(node.ToString()));
            }

            return result;
        }

 static string GetAnonymousTypePropertyName(SyntaxNode expr)
 {
     var mAccess = expr as MemberAccessExpressionSyntax;
     return mAccess != null ? mAccess.Name.ToString() : expr.ToString();
 }