C# AstType.ToString方法代码示例

        /// <summary>
        /// Check if the type should be skipped to generate 'Contract.Ensures' and 'Contract.Requires' statemets.
        /// </summary>
        /// <param name="type">the type</param>
        /// <returns>true: skip type</returns>
        public static bool IsSkipType(AstType type)
        {
            string typeName = type.HasChildren ? type.FirstChild.ToString() : type.ToString();

            if (SkipTypes == null)
            {
                return false;
            }

            return SkipTypes.Any(s => s.ToUpper() == typeName.ToUpper());
        }

        /// <summary>
        /// Determines whether the types are equal.
        /// </summary>
        /// <param name="expectedType">The expected type.</param>
        /// <param name="typeReference">The type reference.</param>
        /// <returns><c>true</c> if parameters are equal, otherwise <c>false</c>.</returns>
        private static bool AreTypesEqual(string expectedType, AstType typeReference)
        {
            SimpleType simpleType = typeReference as SimpleType; // Generic types

            if (simpleType != null)
            {
                if (simpleType.TypeArguments.Count == 1)
                {
                    typeReference = simpleType.TypeArguments.First();
                }
                else if (simpleType.TypeArguments.Count >= 2)
                {
                    // This can't be handled correctly
                    return true;
                }
            }

            ComposedType composedType = typeReference as ComposedType; // Arrays

            if (composedType != null)
            {
                if (!expectedType.EndsWith("[]", StringComparison.Ordinal))
                {
                    return false;
                }
                else
                {
                    expectedType = expectedType.Replace("[]", string.Empty);
                    typeReference = composedType.BaseType;
                }
            }

            if (expectedType.StartsWith("ref ", StringComparison.Ordinal))
            {
                expectedType = expectedType.Replace("ref ", string.Empty);
            }

            string typeReplacement;
            if (TypeReplacements.TryGetValue(expectedType, out typeReplacement))
            {
                expectedType = typeReplacement;
            }

            // Validate
            string typeName = typeReference.ToString();
            if (expectedType.Equals(typeName, StringComparison.OrdinalIgnoreCase)
                || ("System." + expectedType).Equals(typeName, StringComparison.OrdinalIgnoreCase)
                || expectedType.Substring(expectedType.LastIndexOf('.') + 1).Equals(typeName, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            return false;
        }

        void ReplaceType(AstType type)
        {
            int length = type.EndLocation.Column - type.StartLocation.Column;
            int offset = type.StartLocation.Column - 1;

            ReplaceType (type.ToString (), offset, length);
        }

		IEnumerable<ICompletionData> CreateTypeCompletionData(IType hintType, AstType hintTypeAst)
		{
			var wrapper = new CompletionDataWrapper(this);
			var state = GetState();
			Func<IType, IType> pred = null;
			if (hintType != null) {
				
				if (hintType.Kind != TypeKind.Unknown) {
					var lookup = new MemberLookup(ctx.CurrentTypeDefinition, Compilation.MainAssembly);
					pred = t => {
						// check if type is in inheritance tree.
						if (hintType.GetDefinition() != null && !t.GetDefinition().IsDerivedFrom(hintType.GetDefinition())) {
							return null;
						}
						if (t.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array) {
							return null;
						}
						// check for valid constructors
						if (t.GetConstructors().Count() > 0) {
							bool isProtectedAllowed = currentType != null ? currentType.Resolve(ctx).GetDefinition().IsDerivedFrom(t.GetDefinition()) : false;
							if (!t.GetConstructors().Any(m => lookup.IsAccessible(m, isProtectedAllowed)))
								return null;
						}

						var typeInference = new TypeInference(Compilation);
						typeInference.Algorithm = TypeInferenceAlgorithm.ImprovedReturnAllResults;
						var inferedType = typeInference.FindTypeInBounds(new [] { t }, new [] { hintType });
						wrapper.AddType(inferedType, amb.ConvertType(inferedType));
						return null;
					};
					if (!(hintType.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array)) {
						DefaultCompletionString = GetShortType(hintType, GetState());
						wrapper.AddType(hintType, DefaultCompletionString);
					}
					if (hintType is ParameterizedType && hintType.TypeParameterCount == 1 && hintType.FullName == "System.Collections.Generic.IEnumerable") {
						var arg = ((ParameterizedType)hintType).TypeArguments.FirstOrDefault();
						var array = new ArrayTypeReference(arg.ToTypeReference(), 1).Resolve(ctx);
						wrapper.AddType(array, amb.ConvertType(array));
					}
				} else {
					DefaultCompletionString = hintTypeAst.ToString();
					wrapper.AddType(hintType, DefaultCompletionString);
				}
			} 
			AddTypesAndNamespaces(wrapper, state, null, pred, m => false);
			if (hintType == null || hintType == SpecialType.UnknownType)
				AddKeywords(wrapper, primitiveTypesKeywords.Where(k => k != "void"));
			CloseOnSquareBrackets = true;
			AutoCompleteEmptyMatch = true;
			return wrapper.Result;
		}

 string GenerateNamespaceString(AstType astType)
 {
     return astType.ToString();
 }