Beispiel #1
0
        public override AstNode VisitSimpleType(SimpleType simpleType, ICecilArgumentsResolver argumentsResolver)
        {
            Type type          = null;
            var  typeReference = simpleType.Annotation <TypeReference>();

            if (typeReference != null)
            {
                bool   hasTypes = false;
                Type[] types    = new Type[simpleType.TypeArguments.Count];

                if (typeReference.HasGenericParameters)
                {
                    simpleType.TypeArguments
                    .ForEach((a, i) => {
                        type = a.GetActualType() ?? argumentsResolver.ResolveType(a.ToString());

                        if (type != null)
                        {
                            types[i] = type;
                            hasTypes = true;
                        }
                    });

                    if (hasTypes)
                    {
                        type = typeReference.GetActualType()
                               .MakeGenericType(types);

                        simpleType.RemoveAnnotations <TypeReference>();
                        typeReference = new TypeReference(string.Empty, type.FullName, typeReference.Module, typeReference.Scope);
                        simpleType.AddAnnotation(typeReference);
                    }
                }
            }
            else
            {
                var pair = argumentsResolver.ResolvePair(simpleType.Identifier);

                type          = pair.Type;
                typeReference = pair.TypeReference;
                simpleType.AddAnnotation(typeReference);
                simpleType.Identifier = pair.Type.FullName;
            }

            return(simpleType);
        }
Beispiel #2
0
        public static IEnumerable <TreeNode> LazyGetItemsOfIList(Expression targetObject)
        {
            // This is needed for expanding IEnumerable<T>

            var type = new SimpleType()
            {
                Identifier = typeof(IList).FullName
            };

            type.AddAnnotation(typeof(IList));

            targetObject = new CastExpression()
            {
                Expression = targetObject.Clone(), Type = type
            };

            int count = 0;
            GetValueException error = null;

            try {
                count = GetIListCount(targetObject);
            } catch (GetValueException e) {
                // Cannot yield a value in the body of a catch clause (CS1631)
                error = e;
            }
            if (error != null)
            {
                yield return(new TreeNode(null, "(error)", error.Message, null, null));
            }
            else if (count == 0)
            {
                yield return(new TreeNode(null, "(empty)", null, null, null));
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    string imageName;
                    var    image      = ExpressionNode.GetImageForArrayIndexer(out imageName);
                    var    expression = new ExpressionNode(image, "[" + i + "]", targetObject.AppendIndexer(i));
                    expression.ImageName = imageName;
                    yield return(expression);
                }
            }
        }
		public static IEnumerable<TreeNode> LazyGetItemsOfIList(Expression targetObject)
		{
			// This is needed for expanding IEnumerable<T>
			
			var type = new SimpleType() { Identifier = typeof(IList).FullName };
			type.AddAnnotation(typeof(IList));
			
			targetObject = new CastExpression() { Expression = targetObject.Clone(), Type = type };

			int count = 0;
			GetValueException error = null;
			try {
				count = GetIListCount(targetObject);
			} catch (GetValueException e) {
				// Cannot yield a value in the body of a catch clause (CS1631)
				error = e;
			}
			if (error != null) {
				yield return new TreeNode(null, "(error)", error.Message, null, null);
			} else if (count == 0) {
				yield return new TreeNode(null, "(empty)", null, null, null);
			} else {
				for(int i = 0; i < count; i++) {
					string imageName;
					var image = ExpressionNode.GetImageForArrayIndexer(out imageName);
					var expression = new ExpressionNode(image, "[" + i + "]", targetObject.AppendIndexer(i));
					expression.ImageName = imageName;
					yield return expression;
				}
			}
		}
Beispiel #4
0
			public override void VisitMemberType (MemberType memberType)
			{
				base.VisitMemberType (memberType);


				AstNodeCollection<AstType> args = memberType.TypeArguments;

				var mems = new Stack<MemberType> ();
				var t = (AstType)memberType;
				var mem = memberType;
				while (mem != null) {
					mems.Push (mem);
					if (args.Count == 0)
						args = mem.TypeArguments;
					t = mem.Target;
					mem = t as MemberType;
				}

				var newName = "";

				var simp = t as SimpleType;
				if (simp != null) {

					if (args.Count == 0)
						args = simp.TypeArguments;
					newName += (simp.Identifier);

				} else {
					t.AcceptVisitor (this);
				}

				while (mems.Count > 0) {
					var mm = mems.Pop ();
					newName += ("_" + mm.MemberName);
				}

				var newType = new SimpleType (newName, args.Select (x => x.Clone ()));
				var td = memberType.Annotation<TypeDefinition> ();
				if (td != null) {
					newType.AddAnnotation (td);
				}
				memberType.ReplaceWith (newType);

			}