C# SemanticModel.LookupSymbols方法代码示例

 ExpressionSyntax GenerateTarget(SemanticModel model, BinaryExpressionSyntax node)
 {
     var symbols = model.LookupSymbols(node.SpanStart).OfType<IMethodSymbol>();
     if (!symbols.Any() || HasDifferentEqualsMethod(symbols))
         return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression("object"), SyntaxFactory.IdentifierName("Equals"));
     else
         return SyntaxFactory.IdentifierName("Equals");
 }

 public static string ReduceQualifiedTypeName(
     this ITypeSymbol type,SemanticModel semantic,int classDeclarationPosition)
 {
     // one problem is that the type could be from a different semantic model
     // (one that was created before) so we search the type in the
     // new model and if we find it use the new one instead
     var typeInSemanticModel = semantic.LookupSymbols(0, name: type.Name)
         .OfType<ITypeSymbol>()
         .FirstOrDefault();
     if (typeInSemanticModel != null)
         type = typeInSemanticModel;
     return type.ToMinimalDisplayString(semantic, classDeclarationPosition);
 }

        private static string GetProgramElementNameThatMatchStringLiteral(LiteralExpressionSyntax stringLiteral, SemanticModel semanticModel)
        {
            var programElementName = GetParameterNameThatMatchStringLiteral(stringLiteral);

            if (!Found(programElementName))
            {
                var literalValueText = stringLiteral.Token.ValueText;
                var symbol = semanticModel.LookupSymbols(stringLiteral.Token.SpanStart, null, literalValueText).FirstOrDefault();

                programElementName = symbol?.ToDisplayParts().LastOrDefault(IncludeOnlyPartsThatAreName).ToString();
            }

            return programElementName;
        }

		protected virtual IEnumerable<CompletionData> CreateCompletionData (CompletionEngine engine, SemanticModel semanticModel, int position, INamedTypeSymbol enclosingType, SyntaxToken token, bool afterPartialKeyword, CancellationToken cancellationToken)
		{
			var symbols = semanticModel.LookupSymbols(position, container: enclosingType)
				.OfType<IMethodSymbol>()
				.Where(m => IsPartial(m) && m.PartialImplementationPart == null);

			var list = new List<CompletionData> ();

			var declarationBegin = afterPartialKeyword ? token.Parent.SpanStart : position - 1;
			foreach (var m in symbols) {
				var data = engine.Factory.CreatePartialCompletionData (
					this,
					declarationBegin,
					enclosingType,
					m,
					afterPartialKeyword
				);
				list.Add (data); 
			}
			return list;
		}

        private static string GetProgramElementNameThatMatchStringLiteral(LiteralExpressionSyntax stringLiteral, SemanticModel semanticModel)
        {
            var programElementName = GetParameterNameThatMatchStringLiteral(stringLiteral);

            if (!Found(programElementName))
            {
                var literalValueText = stringLiteral.Token.ValueText;
                var symbol = semanticModel.LookupSymbols(stringLiteral.Token.SpanStart, null, literalValueText).FirstOrDefault();

                if (symbol?.Kind == SymbolKind.Local)
                {
                    var symbolSpan = symbol.Locations.Min(i => i.SourceSpan);
                    if (symbolSpan.CompareTo(stringLiteral.Token.Span) > 0)
                        return string.Empty;
                }

                programElementName = symbol?.ToDisplayParts().LastOrDefault(AnalyzerExtensions.IsName).ToString();
            }

            return programElementName;
        }

        private static string DetectSynchronousUsages(IMethodSymbol methodCallSymbol, SemanticModel semanticModel)
        {
            var list = semanticModel.LookupSymbols(0, container: methodCallSymbol.ContainingType,
                                includeReducedExtensionMethods: true);

            var name = methodCallSymbol.Name;

            if (methodCallSymbol.ContainingType == null)
            {
                return "None";
            }

            if (methodCallSymbol.ContainingType.Name == "Thread" && name == "Sleep")
            {
                return "Task.Delay";
            }
            // Parameter Sifir olmasi lazim!!!!!
            else if (methodCallSymbol.ContainingType.Name == "Task" && name == "Wait")
            {
                return "await";
            }
            else if (methodCallSymbol.ContainingType.Name == "Task" && name == "WaitAll")
            {
                return "Task.WhenAll";
            }
            else if (methodCallSymbol.ContainingType.Name == "Task" && name == "WaitAny")
            {
                return "Task.WhenAny";
            }

            foreach (var tmp in list)
            {
                if (tmp.Name.Equals(name + "Async"))
                {
                    return tmp.Name;
                }
            }

            return "None";
        }

        static bool FindIssuesInAccessor(SemanticModel semanticModel, AccessorDeclarationSyntax accessor)
        {
            var body = accessor.Body;
            if (!IsEligible(body))
                return false;

            if (body.Statements.Any())
            {
                var foundValueSymbol = semanticModel.LookupSymbols(body.Statements.First().SpanStart, null, "value").FirstOrDefault();
                if (foundValueSymbol == null)
                    return false;

                foreach (var valueRef in body.DescendantNodes().OfType<IdentifierNameSyntax>().Where(ins => ins.Identifier.ValueText == "value"))
                {
                    var valueRefSymbol = semanticModel.GetSymbolInfo(valueRef).Symbol;
                    if (foundValueSymbol.Equals(valueRefSymbol))
                        return false;
                }
            }

            return true;
        }

        private static string GetProgramElementNameThatMatchStringLiteral(LiteralExpressionSyntax stringLiteral, SemanticModel semanticModel, out bool externalSymbol)
        {
            externalSymbol = false;
            var programElementName = GetParameterNameThatMatchStringLiteral(stringLiteral);
            if (!Found(programElementName))
            {
                var literalValueText = stringLiteral.Token.ValueText;
                var symbol = semanticModel.LookupSymbols(stringLiteral.Token.SpanStart, null, literalValueText).FirstOrDefault();
                if (symbol == null) return null;
                externalSymbol = !symbol.Locations.Any(l => l.IsInSource);

                if (symbol.Kind == SymbolKind.Local)
                {
                    var symbolSpan = symbol.Locations.Min(i => i.SourceSpan);
                    if (symbolSpan.CompareTo(stringLiteral.Token.Span) > 0)
                        return null;
                }

                programElementName = symbol.ToDisplayParts(NameOfSymbolDisplayFormat).LastOrDefault(AnalyzerExtensions.IsName).ToString();
            }

            return programElementName;
        }

        private bool TryGetIndexers(int position, SemanticModel semanticModel, ExpressionSyntax expression, CancellationToken cancellationToken, out IEnumerable<IPropertySymbol> indexers, out ITypeSymbol expressionType)
        {
            expressionType = semanticModel.GetTypeInfo(expression, cancellationToken).Type;

            if (expressionType == null)
            {
                indexers = null;
                return false;
            }

            if (expressionType is IErrorTypeSymbol)
            {
                expressionType = (expressionType as IErrorTypeSymbol).CandidateSymbols.FirstOrDefault().GetSymbolType();
            }

            indexers = semanticModel.LookupSymbols(position, expressionType, WellKnownMemberNames.Indexer).OfType<IPropertySymbol>();
            return true;
        }

		private Task<IEnumerable<CompletionData>> GetCompletionsOffOfExplicitInterfaceAsync(
			CompletionEngine engine, Document document, SemanticModel semanticModel, int position, NameSyntax name, CancellationToken cancellationToken)
		{
			// Bind the interface name which is to the left of the dot
			var syntaxTree = semanticModel.SyntaxTree;
			var nameBinding = semanticModel.GetSymbolInfo(name, cancellationToken);
			// var context = CSharpSyntaxContext.CreateContext(document.Project.Solution.Workspace, semanticModel, position, cancellationToken);

			var symbol = nameBinding.Symbol as ITypeSymbol;
			if (symbol == null || symbol.TypeKind != TypeKind.Interface)
			{
				return Task.FromResult (Enumerable.Empty<CompletionData> ());
			}

			var members = semanticModel.LookupSymbols (
	              position: name.SpanStart,
	              container: symbol)
				.Where (s => !s.IsStatic);
			//	.FilterToVisibleAndBrowsableSymbols(document.ShouldHideAdvancedMembers(), semanticModel.Compilation);

			// We're going to create a entry for each one, including the signature
			var completions = new List<CompletionData>();

//			var signatureDisplayFormat =
//				new SymbolDisplayFormat(
//					genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
//					memberOptions:
//					SymbolDisplayMemberOptions.IncludeParameters,
//					parameterOptions:
//					SymbolDisplayParameterOptions.IncludeName |
//					SymbolDisplayParameterOptions.IncludeType |
//					SymbolDisplayParameterOptions.IncludeParamsRefOut,
//					miscellaneousOptions:
//					SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers |
//					SymbolDisplayMiscellaneousOptions.UseSpecialTypes);

			var namePosition = name.SpanStart;

			// var text = await context.SyntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
			// var textChangeSpan = GetTextChangeSpan(text, context.Position);

			foreach (var member in members)
			{
				// var displayString = member.ToMinimalDisplayString(semanticModel, namePosition, signatureDisplayFormat);
				// var memberCopied = member;
				// var insertionText = displayString;

				completions.Add(engine.Factory.CreateSymbolCompletionData (this, member)

					/*new SymbolCompletionItem(
					this,
					displayString,
					insertionText: insertionText,
					filterSpan: textChangeSpan,
					position: position,
					symbols: new List<ISymbol> { member },
					context: context) */);
			}

			return Task.FromResult ((IEnumerable<CompletionData>)completions);
		}

 static string GetName(SemanticModel model, TextSpan span, string[] variableNames)
 {
     var symbols = model.LookupSymbols(span.Start).ToList();
     for (int i = 0; i < 1000; i++)
     {
         foreach (var vn in variableNames)
         {
             string id = i > 0 ? vn + i : vn;
             if (symbols.All(s => s.Name != id))
                 return id;
         }
     }
     return null;
 }

        private bool TryGetIndexers(int position, SemanticModel semanticModel, ExpressionSyntax expression, CancellationToken cancellationToken, out IEnumerable<IPropertySymbol> indexers, out ITypeSymbol expressionType)
        {
            expressionType = semanticModel.GetTypeInfo(expression, cancellationToken).Type;

            if (expressionType == null)
            {
                indexers = null;
                return false;
            }

            if (expressionType is IErrorTypeSymbol)
            {
                // If `expression` is a QualifiedNameSyntax then GetTypeInfo().Type won't have any CandidateSymbols, so
                // we should then fall back to getting the actual symbol for the expression.
                expressionType = (expressionType as IErrorTypeSymbol).CandidateSymbols.FirstOrDefault().GetSymbolType()
                    ?? semanticModel.GetSymbolInfo(expression).GetAnySymbol().GetSymbolType();
            }

            indexers = semanticModel.LookupSymbols(position, expressionType, WellKnownMemberNames.Indexer).OfType<IPropertySymbol>();
            return true;
        }

        public IEnumerable<Location> ComputePossibleImplicitUsageConflicts(
            ISymbol renamedSymbol,
            SemanticModel semanticModel,
            Location originalDeclarationLocation,
            int newDeclarationLocationStartingPosition,
            CancellationToken cancellationToken)
        {
            // TODO: support other implicitly used methods like dispose

            if ((renamedSymbol.Name == "MoveNext" || renamedSymbol.Name == "GetEnumerator" || renamedSymbol.Name == "Current") && renamedSymbol.GetAllTypeArguments().Length == 0)
            {
                // TODO: partial methods currently only show the location where the rename happens as a conflict.
                //       Consider showing both locations as a conflict.
                var baseType = renamedSymbol.ContainingType.GetBaseTypes().FirstOrDefault();
                if (baseType != null)
                {
                    var implicitSymbols = semanticModel.LookupSymbols(
                        newDeclarationLocationStartingPosition,
                        baseType,
                        renamedSymbol.Name)
                            .Where(sym => !sym.Equals(renamedSymbol));

                    foreach (var symbol in implicitSymbols)
                    {
                        if (symbol.GetAllTypeArguments().Length != 0)
                        {
                            continue;
                        }

                        if (symbol.Kind == SymbolKind.Method)
                        {
                            var method = (IMethodSymbol)symbol;

                            if (symbol.Name == "MoveNext")
                            {
                                if (!method.ReturnsVoid && !method.Parameters.Any() && method.ReturnType.SpecialType == SpecialType.System_Boolean)
                                {
                                    return SpecializedCollections.SingletonEnumerable(originalDeclarationLocation);
                                }
                            }
                            else if (symbol.Name == "GetEnumerator")
                            {
                                // we are a bit pessimistic here. 
                                // To be sure we would need to check if the returned type is having a MoveNext and Current as required by foreach
                                if (!method.ReturnsVoid &&
                                    !method.Parameters.Any())
                                {
                                    return SpecializedCollections.SingletonEnumerable(originalDeclarationLocation);
                                }
                            }
                        }
                        else if (symbol.Kind == SymbolKind.Property && symbol.Name == "Current")
                        {
                            var property = (IPropertySymbol)symbol;

                            if (!property.Parameters.Any() && !property.IsWriteOnly)
                            {
                                return SpecializedCollections.SingletonEnumerable(originalDeclarationLocation);
                            }
                        }
                    }
                }
            }

            return SpecializedCollections.EmptyEnumerable<Location>();
        }

 CodeAction GetAction(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, MethodDeclarationSyntax method)
 {
     return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("Extract anonymous method"), t2 =>
     {
         var identifier = SyntaxFactory.IdentifierName(NameGenerator.EnsureUniqueness("Method", model.LookupSymbols(node.SpanStart).Select(s => s.Name)));
         var surroundingMemberDeclaration = node.GetAncestor<MemberDeclarationSyntax>();
         var rootWithTrackedMember = root.TrackNodes(node, surroundingMemberDeclaration);
         var newRoot = rootWithTrackedMember.ReplaceNode(rootWithTrackedMember.GetCurrentNode(node), identifier);
         newRoot = newRoot
             .InsertNodesBefore(newRoot.GetCurrentNode(surroundingMemberDeclaration),
             new[] { method.WithTrailingTrivia(surroundingMemberDeclaration.GetTrailingTrivia()) });
         return Task.FromResult(document.WithSyntaxRoot(newRoot));
     });
 }

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