C# SyntaxNode.GetNameAndArityOfSimpleName方法代码示例

		internal async Task<IEnumerable<ISymbol>> GetMatchingNamespacesAsync(
			Microsoft.CodeAnalysis.Project project,
			SemanticModel semanticModel,
			SyntaxNode simpleName,
			CancellationToken cancellationToken)
		{
			if (simpleName.IsAttributeName())
			{
				return null;
			}

			string name;
			int arity;
			simpleName.GetNameAndArityOfSimpleName(out name, out arity);
			if (cancellationToken.IsCancellationRequested)
			{
				return null;
			}

			var symbols = await SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Namespace, cancellationToken).ConfigureAwait(false);

			var namespaces = symbols
				.OfType<INamespaceSymbol>()
				.Where(n => !n.IsGlobalNamespace &&
					HasAccessibleTypes(n, semanticModel, cancellationToken));

			return namespaces;
		}

		internal async Task<IEnumerable<ISymbol>> GetMatchingTypesAsync(
			Microsoft.CodeAnalysis.Project project, SemanticModel semanticModel, SyntaxNode node, CancellationToken cancellationToken)
		{
			// Can't be on the right hand side of binary expression (like 'dot').
			cancellationToken.ThrowIfCancellationRequested();
			string name;
			int arity;
			node.GetNameAndArityOfSimpleName(out name, out arity);

			var symbols = await SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Type, cancellationToken).ConfigureAwait(false);

			// also lookup type symbols with the "Attribute" suffix.
			var inAttributeContext = node.IsAttributeName();
			if (inAttributeContext)
			{
				symbols = symbols.Concat(
					await SymbolFinder.FindDeclarationsAsync(project, name + "Attribute", this.IgnoreCase, SymbolFilter.Type, cancellationToken).ConfigureAwait(false));
			}

			var accessibleTypeSymbols = symbols
				.OfType<INamedTypeSymbol>()
				.Where(s => (arity == 0 || s.GetArity() == arity)
					&& s.IsAccessibleWithin(semanticModel.Compilation.Assembly)
					&& (!inAttributeContext || s.IsAttribute())
					&& HasValidContainer(s))
				.ToList();

			return accessibleTypeSymbols;
		}

		private static void CalculateContext(SyntaxNode node, out string name, out int arity, out bool inAttributeContext, out bool hasIncompleteParentMember)
		{
			// Has to be a simple identifier or generic name.
			node.GetNameAndArityOfSimpleName(out name, out arity);

			inAttributeContext = node.IsAttributeName();
			hasIncompleteParentMember = node.HasIncompleteParentMember();
		}

		private async Task<IEnumerable<IMethodSymbol>> GetAddMethodsAsync(
			Microsoft.CodeAnalysis.Project project,
			Diagnostic diagnostic,
			SyntaxNode node,
			SemanticModel semanticModel,
			ISet<INamespaceSymbol> namespacesInScope,
			SyntaxNode expression,
			CancellationToken cancellationToken)
		{
			string name;
			int arity;
			node.GetNameAndArityOfSimpleName(out name, out arity);
			if (name != null)
			{
				return SpecializedCollections.EmptyEnumerable<IMethodSymbol>();
			}

			if (IsAddMethodContext(node, semanticModel))
			{
				var symbols = await SymbolFinder.FindDeclarationsAsync(project, "Add", this.IgnoreCase, SymbolFilter.Member, cancellationToken).ConfigureAwait(false);
				return symbols
					.OfType<IMethodSymbol>()
					.Where(method => method.IsExtensionMethod &&
						method.ContainingType?.IsAccessibleWithin(semanticModel.Compilation.Assembly) == true &&
						IsViableExtensionMethod(method, expression, semanticModel,  cancellationToken));
			}

			return SpecializedCollections.EmptyEnumerable<IMethodSymbol>();
		}

		private Task<IEnumerable<ISymbol>> GetSymbolsAsync(
			Microsoft.CodeAnalysis.Project project,
			SyntaxNode node,
			SemanticModel semanticModel,
			CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();

			// See if the name binds.  If it does, there's nothing further we need to do.
			if (ExpressionBinds(node, semanticModel, cancellationToken, checkForExtensionMethods: true))
			{
				return Task.FromResult (Enumerable.Empty<ISymbol>());
			}

			string name;
			int arity;
			node.GetNameAndArityOfSimpleName(out name, out arity);
			if (name == null)
			{
				return Task.FromResult (Enumerable.Empty<ISymbol>());
			}

			return SymbolFinder.FindDeclarationsAsync(project, name, this.IgnoreCase, SymbolFilter.Member, cancellationToken);
		}

		private async Task<IEnumerable<INamespaceSymbol>> GetNamespacesForMatchingNamespacesAsync(
			Microsoft.CodeAnalysis.Project project,
			Diagnostic diagnostic,
			SyntaxNode node,
			SemanticModel semanticModel,
			ISet<INamespaceSymbol> namespacesInScope,
			CancellationToken cancellationToken)
		{
			if (!this.CanAddImportForNamespace(diagnostic, ref node))
			{
				return null;
			}

			string name;
			int arity;
			node.GetNameAndArityOfSimpleName(out name, out arity);

			if (ExpressionBinds(node, semanticModel, cancellationToken))
			{
				return null;
			}

			var symbols = await SymbolFinder.FindDeclarationsAsync(
				project, name, this.IgnoreCase, SymbolFilter.Namespace, cancellationToken).ConfigureAwait(false);

			return GetProposedNamespaces(
				symbols.OfType<INamespaceSymbol>().Select(n => n.ContainingNamespace),
				semanticModel,
				namespacesInScope);
		}