C# ReferenceExpression.CloneNode方法代码示例

        protected override void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
        {
            if (!TypeSystemServices.IsQuackBuiltin(pair.First))
            {
                base.AddResolvedNamedArgumentToEval(eval, pair, instance);
                return;
            }

            MemberReferenceExpression memberRef = new MemberReferenceExpression(
                pair.First.LexicalInfo,
                instance.CloneNode(),
                ((ReferenceExpression)pair.First).Name);
            BindQuack(memberRef);

            eval.Arguments.Add(
                CodeBuilder.CreateAssignment(
                    pair.First.LexicalInfo,
                    memberRef,
                    pair.Second));
        }

		public override void OnCollectionInitializationExpression(CollectionInitializationExpression node)
		{
			var temp = new ReferenceExpression(node.LexicalInfo, Context.GetUniqueName("collection"));

			var initialization = CodeBuilder.CreateEvalInvocation(node.LexicalInfo);

			// temp = $(node.Collection)
			initialization.Arguments.Add(new BinaryExpression(BinaryOperatorType.Assign, temp, node.Collection));

			if (node.Initializer is ListLiteralExpression)
				foreach (var item in ((ListLiteralExpression)node.Initializer).Items)
					// temp.Add(item)
					initialization.Arguments.Add(NewAddInvocation(item.LexicalInfo, temp, item));
			else
				foreach (var pair in ((HashLiteralExpression)node.Initializer).Items)
					// temp.Add(key, value)
					initialization.Arguments.Add(NewAddInvocation(pair.LexicalInfo, temp, pair.First, pair.Second));

			// return temp
			initialization.Arguments.Add(temp.CloneNode());

			ReplaceCurrentNode(initialization);
		}

        protected virtual void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
        {
            IEntity entity = GetEntity(pair.First);
            switch (entity.EntityType)
            {
                case EntityType.Event:
                    {
                        IEvent member = (IEvent)entity;
                        eval.Arguments.Add(
                            CodeBuilder.CreateMethodInvocation(
                                pair.First.LexicalInfo,
                                instance.CloneNode(),
                                member.GetAddMethod(),
                                pair.Second));
                        break;
                    }

                case EntityType.Field:
                    {
                        eval.Arguments.Add(
                            CodeBuilder.CreateAssignment(
                                pair.First.LexicalInfo,
                                CodeBuilder.CreateMemberReference(
                                    instance.CloneNode(),
                                    (IMember)entity),
                                pair.Second));
                        break;
                    }

                case EntityType.Property:
                    {
                        IProperty property = (IProperty)entity;
                        IMethod setter = property.GetSetMethod();
                        if (null == setter)
                        {
                            Error(CompilerErrorFactory.PropertyIsReadOnly(pair.First, property));
                        }
                        else
                        {
                            //EnsureRelatedNodeWasVisited(pair.First, setter);
                            eval.Arguments.Add(
                                CodeBuilder.CreateAssignment(
                                    pair.First.LexicalInfo,
                                    CodeBuilder.CreateMemberReference(
                                        instance.CloneNode(),
                                        property),
                                    pair.Second));
                        }
                        break;
                    }
            }
        }

		protected Expression ProcessTargets(Expression node)
		{
			// Look for safe access operators in the targets chain
			UnaryExpression ue = null;
			Expression target = node;
			Expression nextTarget = null;
			while (IsTargetable(target))
			{
				if (target is MemberReferenceExpression)
				{
					nextTarget = ((MemberReferenceExpression)target).Target;
				} 
				else if (target is SlicingExpression)
				{
					nextTarget = ((SlicingExpression)target).Target;
				}
				else
				{
					nextTarget = ((MethodInvocationExpression)target).Target;
				}

				if (IsSafeAccess(nextTarget))
				{
					ue = (UnaryExpression)nextTarget;
					break;
				}

				target = nextTarget;
			}

			// No safe access operator was found
			if (ue == null)
			{
				return null;
			}

			// Target the safe access to a temporary variable
			var tmp = new ReferenceExpression(node.LexicalInfo, Context.GetUniqueName("safe"));
			tmp.IsSynthetic = true;

			// Make sure preceding operators are processed
			MemberReferenceExpression mre = null;
			SlicingExpression se = null;
			MethodInvocationExpression mie = null;
			if (null != (mre = target as MemberReferenceExpression))
			{
				Visit(mre.Target);
				mre.Target = tmp.CloneNode();
			} 
			else if (null != (se = target as SlicingExpression))
			{
				Visit(se.Target);
				se.Target = tmp.CloneNode();
			}
			else if (null != (mie = target as MethodInvocationExpression))
			{
				Visit(mie.Target);
				mie.Target = tmp.CloneNode();
			}

			// Convert the target into a ternary operation 
			var tern = new ConditionalExpression(node.LexicalInfo);
			tern.Condition = new BinaryExpression(
				BinaryOperatorType.ReferenceInequality,
				CodeBuilder.CreateAssignment(tmp, ue.Operand),
				CodeBuilder.CreateNullLiteral()
				);
			tern.TrueValue = node;
			tern.FalseValue = CodeBuilder.CreateNullLiteral();

			return tern;
		}

 private static SlicingExpression CreateRawArraySlicing(ReferenceExpression arrayRef, Expression numRef, IType elementType)
 {
     SlicingExpression expression = new SlicingExpression(arrayRef.CloneNode(), numRef.CloneNode());
     expression.ExpressionType = elementType;
     AstAnnotations.MarkRawArrayIndexing(expression);
     return expression;
 }

		private static MethodInvocationExpression NewAddInvocation(LexicalInfo location, ReferenceExpression target, params Expression[] args)
		{
			return new MethodInvocationExpression(location, new MemberReferenceExpression(target.CloneNode(), "Add"), args);
		}