C# SyntaxTree.GetNodeAt方法代码示例

        public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
		                                    CancellationToken cancellationToken = default(CancellationToken))
        {
            node = syntaxTree.GetNodeAt(location);
            if (node == null || node is ArrayInitializerExpression)
                return null;
            if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole) {
                var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
                return r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken);
            }
            if (CSharpAstResolver.IsUnresolvableNode(node)) {
                if (node is Identifier) {
                    node = node.Parent;
                } else if (node.NodeType == NodeType.Token) {
                    if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) {
                        // There's no other place where one could hover to see the indexer's tooltip,
                        // so we need to resolve it when hovering over the '[' or ']'.
                        // For constructor initializer, the same applies to the 'base'/'this' token.
                        node = node.Parent;
                    } else {
                        return null;
                    }
                } else {
                    // don't resolve arbitrary nodes - we don't want to show tooltips for everything
                    return null;
                }
            } else {
                // It's a resolvable node.
                // However, we usually don't want to show the tooltip everywhere
                // For example, hovering with the mouse over an empty line between two methods causes
                // node==TypeDeclaration, but we don't want to show any tooltip.

                if (!node.GetChildByRole(Roles.Identifier).IsNull) {
                    // We'll suppress the tooltip for resolvable nodes if there is an identifier that
                    // could be hovered over instead:
                    return null;
                }
            }

            if (node == null)
                return null;

            if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) {
                node = node.Parent;
            }

            InvocationExpression parentInvocation = null;
            if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) {
                // we also need to resolve the invocation
                parentInvocation = node.Parent as InvocationExpression;
            }

            // TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
            CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
            ResolveResult rr = resolver.Resolve(node, cancellationToken);
            if (rr is MethodGroupResolveResult && parentInvocation != null)
                return resolver.Resolve(parentInvocation);
            else
                return rr;
        }

		public override bool TryFix(ConstructFixer fixer, SyntaxTree syntaxTree, IDocument document, TextLocation location, ref int newOffset)
		{
			var typeDeclaration = syntaxTree.GetNodeAt<DelegateDeclaration>(location); 
			if (typeDeclaration != null) {
				if (typeDeclaration.RParToken.IsNull) {
					var lastNode = GetLastNonErrorChild (typeDeclaration);
					if (lastNode == null)
						return false;
					var insertionOffset = document.GetOffset(lastNode.EndLocation);
					document.Insert(insertionOffset, ");\n");
					newOffset += ");\n".Length;
					return true;
				}
			}
			return false;
		}

        /// <summary>
        /// クラスのコンストラクタ定義を生成する
        /// </summary>
        /// <param name="syntaxTree"></param>
        /// <param name="line"></param>
        /// <param name="column"></param>
        /// <returns></returns>
        private static string GenerateConstructorDefinition(SyntaxTree syntaxTree, int line, int column)
        {
            var classAtCursor = syntaxTree.GetNodeAt(line, column) as ICSharpCode.NRefactory.CSharp.TypeDeclaration;

            // fieldとそのtype取得
            var dictFieldNameTypeName = new Dictionary<string, string>();
            foreach (var field in classAtCursor.Members.Where(x => x is ICSharpCode.NRefactory.CSharp.FieldDeclaration))
            {
                foreach (var variable in field.GetChildrenByRole(Roles.Variable) as AstNodeCollection<VariableInitializer>)
                {
                    dictFieldNameTypeName[variable.Name] = field.ReturnType.ToString();
                }
            }

            StringBuilder sb = new StringBuilder();

            sb.AppendFormat("public {0}(\r\n", classAtCursor.Name);
            sb.Append(String.Join(",\r\n", dictFieldNameTypeName.Select(x => x.Value + " " + x.Key)));
            sb.AppendLine(")");

            //コンストラクタのbody
            sb.AppendLine("{");
            foreach (var member in dictFieldNameTypeName)
            {
                sb.AppendFormat("this.{0} = {0};\r\n", member.Key);
            }
            sb.AppendLine("}");

            return sb.ToString();
        }

 /// <summary>
 /// (line, column)でクラス定義を行っているかどうか判定する
 /// </summary>
 /// <param name="syntaxTree"></param>
 /// <param name="line"></param>
 /// <param name="column"></param>
 /// <returns></returns>
 private static bool IsAtClassDefinition(SyntaxTree syntaxTree, int line, int column)
 {
     var nodeAtCursor = syntaxTree.GetNodeAt(line, column);
     return nodeAtCursor is ICSharpCode.NRefactory.CSharp.TypeDeclaration;
 }