C# SemanticModel.GetSpeculativeTypeInfo方法代码示例

        protected override ITypeSymbol GetTypeSymbolFromPartialName(string partialName, SemanticModel semanticModel, int position)
        {
            var parsedTypeName = SyntaxFactory.ParseTypeName(partialName);

            return semanticModel.GetSpeculativeTypeInfo(position, parsedTypeName, SpeculativeBindingOption.BindAsTypeOrNamespace).Type;
        }

		static Tuple<ITypeSymbol, Location> GetInitializedType (Document document, SemanticModel semanticModel, int position, CancellationToken cancellationToken)
		{
			var tree = semanticModel.SyntaxTree;
			if (tree.IsInNonUserCode (position, cancellationToken)) {
				return null;
			}

			var token = tree.FindTokenOnLeftOfPosition (position, cancellationToken);
			token = token.GetPreviousTokenIfTouchingWord (position);

			if (token.Kind () != SyntaxKind.CommaToken && token.Kind () != SyntaxKind.OpenBraceToken) {
				return null;
			}

			if (token.Parent == null || token.Parent.Parent == null) {
				return null;
			}

			// If we got a comma, we can syntactically find out if we're in an ObjectInitializerExpression
			if (token.Kind () == SyntaxKind.CommaToken &&
				token.Parent.Kind () != SyntaxKind.ObjectInitializerExpression) {
				return null;
			}

			// new Foo { bar = $$
			if (token.Parent.Parent.IsKind (SyntaxKind.ObjectCreationExpression)) {
				var objectCreation = token.Parent.Parent as ObjectCreationExpressionSyntax;
				if (objectCreation == null) {
					return null;
				}

				var ctor = semanticModel.GetSymbolInfo (objectCreation, cancellationToken).Symbol;
				var type = ctor != null ? ctor.ContainingType : null;
				if (type == null) {
					type = semanticModel.GetSpeculativeTypeInfo (objectCreation.SpanStart, objectCreation.Type, SpeculativeBindingOption.BindAsTypeOrNamespace).Type as INamedTypeSymbol;
				}

				return Tuple.Create<ITypeSymbol, Location> (type, token.GetLocation ());
			}

			// Nested: new Foo { bar = { $$
			if (token.Parent.Parent.IsKind (SyntaxKind.SimpleAssignmentExpression)) {
				// Use the type inferrer to get the type being initialzied.
				var typeInferenceService = TypeGuessing.typeInferenceService;
				var parentInitializer = token.GetAncestor<InitializerExpressionSyntax> ();

				var expectedType = typeInferenceService.InferType (semanticModel, parentInitializer, objectAsDefault: false, cancellationToken: cancellationToken);
				return Tuple.Create (expectedType, token.GetLocation ());
			}

			return null;
		}

        private SyntaxNode linkArray(ExcessContext ctx, SyntaxNode linkNode, SyntaxNode newNode, SemanticModel model)
        {
            ArrayCreationExpressionSyntax ace = newNode as ArrayCreationExpressionSyntax;
            ArgumentSyntax arg = null;
            bool asParam = newNode is ArgumentSyntax;
            if (asParam)
            {
                arg = (ArgumentSyntax)newNode;
                ace = (ArrayCreationExpressionSyntax)arg.Expression;
            }

            ITypeSymbol arrayType = null;
            foreach (var expr in ace.Initializer.Expressions)
            {
                ITypeSymbol type = model.GetSpeculativeTypeInfo(expr.SpanStart, expr, SpeculativeBindingOption.BindAsExpression).Type;

                if (arrayType == null)
                    arrayType = type;
                else if (type != arrayType)
                {
                    if (isSuperClass(type, arrayType))
                        arrayType = type; //downcast
                    else if (!isSuperClass(arrayType, type))
                    {
                        //td: error
                        return newNode; //unable to refine
                    }
                }
            }

            if (arrayType == null)
                return newNode;

            ace = ace.WithType(SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(arrayType.Name + "[]")));
            if (asParam)
                return arg.WithExpression(ace);

            return ace;
        }

            protected override ITypeSymbol GetRangeVariableType(SemanticModel model, IRangeVariableSymbol symbol)
            {
                var info = model.GetSpeculativeTypeInfo(this.SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);
				if (info.Type.IsErrorType())
                {
                    return null;
                }

                return info.Type == null || info.Type.SpecialType == Microsoft.CodeAnalysis.SpecialType.System_Object
                    ? info.Type
                    : info.ConvertedType;
            }

		private IEnumerable<IMethodSymbol> GetMethods(SemanticModel semanticModel, ITypeSymbol symbol, string name, MethodDeclarationSyntax method, MethodDeclarationSyntax originalMethod)
		{
			var parameters = method.ParameterList.Parameters;

			var retval = this
				.GetAllMembers(symbol)
				.Where(c => c.Name == name)
				.OfType<IMethodSymbol>()
				.Where(c => c.Parameters.Select(d => this.GetParameterTypeComparisonKey(d.Type)).SequenceEqual(parameters.Select(d => this.GetParameterTypeComparisonKey(semanticModel.GetSpeculativeTypeInfo(originalMethod.ParameterList.SpanStart, d.Type, SpeculativeBindingOption.BindAsExpression).Type, method, d.Type))));

			return retval;
		}