// Copyright Microsoft Corporation.
// This source file is subject to the Microsoft Permissive License.
// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
// All other rights reserved.
#if !MinimalReader
using System;
using System.Diagnostics;
#if CCINamespace
namespace Microsoft.Cci{
#else
namespace System.Compiler
{
#endif
public class UpdateSpecification
{
public Node Original;
public Node Changes;
public Node Deletions;
public Node Insertions;
//TODO: source change list?
}
public class Updater
{
public static void UpdateOriginal(UpdateSpecification update)
{
if (update == null) { Debug.Assert(false); return; }
Updater updater = new Updater();
updater.Visit(update.Original, update.Changes, update.Deletions, update.Insertions);
}
public Updater callingVisitor;
public int currentSourcePositionDelta;
public Document currentDocument;
public Updater()
{
}
public Updater(Updater callingVisitor)
{
this.callingVisitor = callingVisitor;
}
public virtual Node VisitUnknownNodeType(Node node, Node changes, Node deletions, Node insertions)
{
Updater visitor = this.GetVisitorFor(node);
if (visitor == null) return node;
if (this.callingVisitor != null)
//Allow specialized state (unknown to this visitor) to propagate all the way down to the new visitor
this.callingVisitor.TransferStateTo(visitor);
this.TransferStateTo(visitor);
node = visitor.Visit(node, changes, deletions, insertions);
visitor.TransferStateTo(this);
if (this.callingVisitor != null)
//Propagate specialized state (unknown to this visitor) all the way up the chain
visitor.TransferStateTo(this.callingVisitor);
return node;
}
public virtual void TransferStateTo(Updater target)
{
if (target == null) return;
target.currentSourcePositionDelta = this.currentSourcePositionDelta;
}
public virtual Updater GetVisitorFor(Node node)
{
if (node == null) return null;
return (Updater)node.GetVisitorFor(this, this.GetType().Name);
}
public virtual Node Visit(Node node, Node changes, Node deletions, Node insertions)
{
if (node == null) return changes;
switch (node.NodeType)
{
case NodeType.AddressDereference:
return this.VisitAddressDereference((AddressDereference)node, changes as AddressDereference, deletions as AddressDereference, insertions as AddressDereference);
case NodeType.AliasDefinition:
return this.VisitAliasDefinition((AliasDefinition)node, changes as AliasDefinition, deletions as AliasDefinition, insertions as AliasDefinition);
case NodeType.AnonymousNestedFunction:
return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node, changes as AnonymousNestedFunction, deletions as AnonymousNestedFunction, insertions as AnonymousNestedFunction);
case NodeType.ApplyToAll:
return this.VisitApplyToAll((ApplyToAll)node, changes as ApplyToAll, deletions as ApplyToAll, insertions as ApplyToAll);
case NodeType.Arglist:
return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression);
case NodeType.ArrayType:
Debug.Assert(false); return null;
case NodeType.Assembly:
return this.VisitAssembly((AssemblyNode)node, changes as AssemblyNode, deletions as AssemblyNode, insertions as AssemblyNode);
case NodeType.AssemblyReference:
return this.VisitAssemblyReference((AssemblyReference)node, changes as AssemblyReference, deletions as AssemblyReference, insertions as AssemblyReference);
case NodeType.Assertion:
return this.VisitAssertion((Assertion)node, changes as Assertion, deletions as Assertion, insertions as Assertion);
case NodeType.AssignmentExpression:
return this.VisitAssignmentExpression((AssignmentExpression)node, changes as AssignmentExpression, deletions as AssignmentExpression, insertions as AssignmentExpression);
case NodeType.AssignmentStatement:
return this.VisitAssignmentStatement((AssignmentStatement)node, changes as AssignmentStatement, deletions as AssignmentStatement, insertions as AssignmentStatement);
case NodeType.Attribute:
return this.VisitAttributeNode((AttributeNode)node, changes as AttributeNode, deletions as AttributeNode, insertions as AttributeNode);
case NodeType.Base:
return this.VisitBase((Base)node, changes as Base, deletions as Base, insertions as Base);
case NodeType.Block:
return this.VisitBlock((Block)node, changes as Block, deletions as Block, insertions as Block);
case NodeType.BlockExpression:
return this.VisitBlockExpression((BlockExpression)node, changes as BlockExpression, deletions as BlockExpression, insertions as BlockExpression);
case NodeType.Branch:
Debug.Assert(false); return null;
case NodeType.Compilation:
return this.VisitCompilation((Compilation)node, changes as Compilation, deletions as Compilation, insertions as Compilation);
case NodeType.CompilationUnit:
return this.VisitCompilationUnit((CompilationUnit)node, changes as CompilationUnit, deletions as CompilationUnit, insertions as CompilationUnit);
case NodeType.CompilationUnitSnippet:
return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node, changes as CompilationUnitSnippet, deletions as CompilationUnitSnippet, insertions as CompilationUnitSnippet);
#if ExtendedRuntime
case NodeType.ConstrainedType:
return this.VisitConstrainedType((ConstrainedType)node, changes as ConstrainedType, deletions as ConstrainedType, insertions as ConstrainedType);
#endif
case NodeType.Continue:
return this.VisitContinue((Continue)node, changes as Continue, deletions as Continue, insertions as Continue);
case NodeType.CurrentClosure:
return this.VisitCurrentClosure((CurrentClosure)node, changes as CurrentClosure, deletions as CurrentClosure, insertions as CurrentClosure);
case NodeType.DebugBreak:
return node;
case NodeType.Call:
case NodeType.Calli:
case NodeType.Callvirt:
case NodeType.Jmp:
case NodeType.MethodCall:
return this.VisitMethodCall((MethodCall)node, changes as MethodCall, deletions as MethodCall, insertions as MethodCall);
case NodeType.Catch:
return this.VisitCatch((Catch)node, changes as Catch, deletions as Catch, insertions as Catch);
case NodeType.Class:
return this.VisitClass((Class)node, changes as Class, deletions as Class, insertions as Class);
case NodeType.CoerceTuple:
return this.VisitCoerceTuple((CoerceTuple)node, changes as CoerceTuple, deletions as CoerceTuple, insertions as CoerceTuple);
case NodeType.CollectionEnumerator:
return this.VisitCollectionEnumerator((CollectionEnumerator)node, changes as CollectionEnumerator, deletions as CollectionEnumerator, insertions as CollectionEnumerator);
case NodeType.Composition:
return this.VisitComposition((Composition)node, changes as Composition, deletions as Composition, insertions as Composition);
case NodeType.Construct:
return this.VisitConstruct((Construct)node, changes as Construct, deletions as Construct, insertions as Construct);
case NodeType.ConstructArray:
return this.VisitConstructArray((ConstructArray)node, changes as ConstructArray, deletions as ConstructArray, insertions as ConstructArray);
case NodeType.ConstructDelegate:
return this.VisitConstructDelegate((ConstructDelegate)node, changes as ConstructDelegate, deletions as ConstructDelegate, insertions as ConstructDelegate);
case NodeType.ConstructFlexArray:
return this.VisitConstructFlexArray((ConstructFlexArray)node, changes as ConstructFlexArray, deletions as ConstructFlexArray, insertions as ConstructFlexArray);
case NodeType.ConstructIterator:
return this.VisitConstructIterator((ConstructIterator)node, changes as ConstructIterator, deletions as ConstructIterator, insertions as ConstructIterator);
case NodeType.ConstructTuple:
return this.VisitConstructTuple((ConstructTuple)node, changes as ConstructTuple, deletions as ConstructTuple, insertions as ConstructTuple);
case NodeType.DelegateNode:
return this.VisitDelegateNode((DelegateNode)node, changes as DelegateNode, deletions as DelegateNode, insertions as DelegateNode);
case NodeType.DoWhile:
return this.VisitDoWhile((DoWhile)node, changes as DoWhile, deletions as DoWhile, insertions as DoWhile);
case NodeType.Dup:
return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression);
case NodeType.EndFilter:
return this.VisitEndFilter((EndFilter)node, changes as EndFilter, deletions as EndFilter, insertions as EndFilter);
case NodeType.EndFinally:
return this.VisitEndFinally((EndFinally)node, changes as EndFinally, deletions as EndFinally, insertions as EndFinally);
case NodeType.EnumNode:
return this.VisitEnumNode((EnumNode)node, changes as EnumNode, deletions as EnumNode, insertions as EnumNode);
case NodeType.Event:
return this.VisitEvent((Event)node, changes as Event, deletions as Event, insertions as Event);
case NodeType.Exit:
return this.VisitExit((Exit)node, changes as Exit, deletions as Exit, insertions as Exit);
case NodeType.ExpressionSnippet:
return this.VisitExpressionSnippet((ExpressionSnippet)node, changes as ExpressionSnippet, deletions as ExpressionSnippet, insertions as ExpressionSnippet);
case NodeType.ExpressionStatement:
return this.VisitExpressionStatement((ExpressionStatement)node, changes as ExpressionStatement, deletions as ExpressionStatement, insertions as ExpressionStatement);
case NodeType.FaultHandler:
return this.VisitFaultHandler((FaultHandler)node, changes as FaultHandler, deletions as FaultHandler, insertions as FaultHandler);
case NodeType.Field:
return this.VisitField((Field)node, changes as Field, deletions as Field, insertions as Field);
case NodeType.FieldInitializerBlock:
return this.VisitFieldInitializerBlock((FieldInitializerBlock)node, changes as FieldInitializerBlock, deletions as FieldInitializerBlock, insertions as FieldInitializerBlock);
case NodeType.Finally:
return this.VisitFinally((Finally)node, changes as Finally, deletions as Finally, insertions as Finally);
case NodeType.Filter:
return this.VisitFilter((Filter)node, changes as Filter, deletions as Filter, insertions as Filter);
case NodeType.Fixed:
return this.VisitFixed((Fixed)node, changes as Fixed, deletions as Fixed, insertions as Fixed);
case NodeType.For:
return this.VisitFor((For)node, changes as For, deletions as For, insertions as For);
case NodeType.ForEach:
return this.VisitForEach((ForEach)node, changes as ForEach, deletions as ForEach, insertions as ForEach);
case NodeType.FunctionDeclaration:
return this.VisitFunctionDeclaration((FunctionDeclaration)node, changes as FunctionDeclaration, deletions as FunctionDeclaration, insertions as FunctionDeclaration);
case NodeType.Goto:
return this.VisitGoto((Goto)node, changes as Goto, deletions as Goto, insertions as Goto);
case NodeType.GotoCase:
return this.VisitGotoCase((GotoCase)node, changes as GotoCase, deletions as GotoCase, insertions as GotoCase);
case NodeType.Identifier:
return this.VisitIdentifier((Identifier)node, changes as Identifier, deletions as Identifier, insertions as Identifier);
case NodeType.If:
return this.VisitIf((If)node, changes as If, deletions as If, insertions as If);
case NodeType.ImplicitThis:
return this.VisitImplicitThis((ImplicitThis)node, changes as ImplicitThis, deletions as ImplicitThis, insertions as ImplicitThis);
case NodeType.Indexer:
return this.VisitIndexer((Indexer)node, changes as Indexer, deletions as Indexer, insertions as Indexer);
case NodeType.InstanceInitializer:
return this.VisitInstanceInitializer((InstanceInitializer)node, changes as InstanceInitializer, deletions as InstanceInitializer, insertions as InstanceInitializer);
case NodeType.StaticInitializer:
return this.VisitStaticInitializer((StaticInitializer)node, changes as StaticInitializer, deletions as StaticInitializer, insertions as StaticInitializer);
case NodeType.Method:
return this.VisitMethod((Method)node, changes as Method, deletions as Method, insertions as Method);
case NodeType.Interface:
return this.VisitInterface((Interface)node, changes as Interface, deletions as Interface, insertions as Interface);
case NodeType.LabeledStatement:
return this.VisitLabeledStatement((LabeledStatement)node, changes as LabeledStatement, deletions as LabeledStatement, insertions as LabeledStatement);
case NodeType.Literal:
return this.VisitLiteral((Literal)node, changes as Literal, deletions as Literal, insertions as Literal);
case NodeType.Local:
return this.VisitLocal((Local)node, changes as Local, deletions as Local, insertions as Local);
case NodeType.LocalDeclaration:
return this.VisitLocalDeclaration((LocalDeclaration)node, changes as LocalDeclaration, deletions as LocalDeclaration, insertions as LocalDeclaration);
case NodeType.LocalDeclarationsStatement:
return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node, changes as LocalDeclarationsStatement, deletions as LocalDeclarationsStatement, insertions as LocalDeclarationsStatement);
case NodeType.Lock:
return this.VisitLock((Lock)node, changes as Lock, deletions as Lock, insertions as Lock);
case NodeType.LRExpression:
return this.VisitLRExpression((LRExpression)node, changes as LRExpression, deletions as LRExpression, insertions as LRExpression);
case NodeType.MemberBinding:
return this.VisitMemberBinding((MemberBinding)node, changes as MemberBinding, deletions as MemberBinding, insertions as MemberBinding);
case NodeType.TemplateInstance:
return this.VisitTemplateInstance((TemplateInstance)node, changes as TemplateInstance, deletions as TemplateInstance, insertions as TemplateInstance);
case NodeType.StackAlloc:
return this.VisitStackAlloc((StackAlloc)node, changes as StackAlloc, deletions as StackAlloc, insertions as StackAlloc);
case NodeType.Module:
return this.VisitModule((Module)node, changes as Module, deletions as Module, insertions as Module);
case NodeType.ModuleReference:
return this.VisitModuleReference((ModuleReference)node, changes as ModuleReference, deletions as ModuleReference, insertions as ModuleReference);
case NodeType.NameBinding:
return this.VisitNameBinding((NameBinding)node, changes as NameBinding, deletions as NameBinding, insertions as NameBinding);
case NodeType.NamedArgument:
return this.VisitNamedArgument((NamedArgument)node, changes as NamedArgument, deletions as NamedArgument, insertions as NamedArgument);
case NodeType.Namespace:
return this.VisitNamespace((Namespace)node, changes as Namespace, deletions as Namespace, insertions as Namespace);
case NodeType.Nop:
return node;
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
return this.VisitTypeModifier((TypeModifier)node, changes as TypeModifier, deletions as TypeModifier, insertions as TypeModifier);
case NodeType.Parameter:
return this.VisitParameter((Parameter)node, changes as Parameter, deletions as Parameter, insertions as Parameter);
case NodeType.Pop:
return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression);
case NodeType.PrefixExpression:
return this.VisitPrefixExpression((PrefixExpression)node, changes as PrefixExpression, deletions as PrefixExpression, insertions as PrefixExpression);
case NodeType.PostfixExpression:
return this.VisitPostfixExpression((PostfixExpression)node, changes as PostfixExpression, deletions as PostfixExpression, insertions as PostfixExpression);
case NodeType.Property:
return this.VisitProperty((Property)node, changes as Property, deletions as Property, insertions as Property);
case NodeType.QualifiedIdentifer:
return this.VisitQualifiedIdentifier((QualifiedIdentifier)node, changes as QualifiedIdentifier, deletions as QualifiedIdentifier, insertions as QualifiedIdentifier);
case NodeType.Rethrow:
case NodeType.Throw:
return this.VisitThrow((Throw)node, changes as Throw, deletions as Throw, insertions as Throw);
case NodeType.Return:
return this.VisitReturn((Return)node, changes as Return, deletions as Return, insertions as Return);
case NodeType.ResourceUse:
return this.VisitResourceUse((ResourceUse)node, changes as ResourceUse, deletions as ResourceUse, insertions as ResourceUse);
case NodeType.Repeat:
return this.VisitRepeat((Repeat)node, changes as Repeat, deletions as Repeat, insertions as Repeat);
case NodeType.SecurityAttribute:
return this.VisitSecurityAttribute((SecurityAttribute)node, changes as SecurityAttribute, deletions as SecurityAttribute, insertions as SecurityAttribute);
case NodeType.SetterValue:
return this.VisitSetterValue((SetterValue)node, changes as SetterValue, deletions as SetterValue, insertions as SetterValue);
case NodeType.StatementSnippet:
return this.VisitStatementSnippet((StatementSnippet)node, changes as StatementSnippet, deletions as StatementSnippet, insertions as StatementSnippet);
case NodeType.Struct:
return this.VisitStruct((Struct)node, changes as Struct, deletions as Struct, insertions as Struct);
case NodeType.Switch:
return this.VisitSwitch((Switch)node, changes as Switch, deletions as Switch, insertions as Switch);
case NodeType.SwitchCase:
return this.VisitSwitchCase((SwitchCase)node, changes as SwitchCase, deletions as SwitchCase, insertions as SwitchCase);
case NodeType.SwitchInstruction:
return this.VisitSwitchInstruction((SwitchInstruction)node, changes as SwitchInstruction, deletions as SwitchInstruction, insertions as SwitchInstruction);
case NodeType.Typeswitch:
return this.VisitTypeswitch((Typeswitch)node, changes as Typeswitch, deletions as Typeswitch, insertions as Typeswitch);
case NodeType.TypeswitchCase:
return this.VisitTypeswitchCase((TypeswitchCase)node, changes as TypeswitchCase, deletions as TypeswitchCase, insertions as TypeswitchCase);
case NodeType.This:
return this.VisitThis((This)node, changes as This, deletions as This, insertions as This);
case NodeType.Try:
return this.VisitTry((Try)node, changes as Try, deletions as Try, insertions as Try);
#if ExtendedRuntime
case NodeType.TupleType:
return this.VisitTupleType((TupleType)node, changes as TupleType, deletions as TupleType, insertions as TupleType);
case NodeType.TypeAlias:
return this.VisitTypeAlias((TypeAlias)node, changes as TypeAlias, deletions as TypeAlias, insertions as TypeAlias);
case NodeType.TypeIntersection:
return this.VisitTypeIntersection((TypeIntersection)node, changes as TypeIntersection, deletions as TypeIntersection, insertions as TypeIntersection);
#endif
case NodeType.TypeMemberSnippet:
return this.VisitTypeMemberSnippet((TypeMemberSnippet)node, changes as TypeMemberSnippet, deletions as TypeMemberSnippet, insertions as TypeMemberSnippet);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return this.VisitTypeParameter((TypeNode)node, changes as TypeNode, deletions as TypeNode, insertions as TypeNode);
case NodeType.TypeReference:
return this.VisitTypeReference((TypeReference)node, changes as TypeReference, deletions as TypeReference, insertions as TypeReference);
#if ExtendedRuntime
case NodeType.TypeUnion:
return this.VisitTypeUnion((TypeUnion)node, changes as TypeUnion, deletions as TypeUnion, insertions as TypeUnion);
#endif
case NodeType.UsedNamespace:
return this.VisitUsedNamespace((UsedNamespace)node, changes as UsedNamespace, deletions as UsedNamespace, insertions as UsedNamespace);
case NodeType.VariableDeclaration:
return this.VisitVariableDeclaration((VariableDeclaration)node, changes as VariableDeclaration, deletions as VariableDeclaration, insertions as VariableDeclaration);
case NodeType.While:
return this.VisitWhile((While)node, changes as While, deletions as While, insertions as While);
case NodeType.Yield:
return this.VisitYield((Yield)node, changes as Yield, deletions as Yield, insertions as Yield);
case NodeType.Conditional:
case NodeType.Cpblk:
case NodeType.Initblk:
return this.VisitTernaryExpression((TernaryExpression)node, changes as TernaryExpression, deletions as TernaryExpression, insertions as TernaryExpression);
case NodeType.Add:
case NodeType.Add_Ovf:
case NodeType.Add_Ovf_Un:
case NodeType.AddEventHandler:
case NodeType.And:
case NodeType.As:
case NodeType.Box:
case NodeType.Castclass:
case NodeType.Ceq:
case NodeType.Cgt:
case NodeType.Cgt_Un:
case NodeType.Clt:
case NodeType.Clt_Un:
case NodeType.Comma:
case NodeType.Div:
case NodeType.Div_Un:
case NodeType.Eq:
case NodeType.ExplicitCoercion:
case NodeType.Ge:
case NodeType.Gt:
case NodeType.Is:
case NodeType.Iff:
case NodeType.Implies:
case NodeType.Isinst:
case NodeType.Ldvirtftn:
case NodeType.Le:
case NodeType.LogicalAnd:
case NodeType.LogicalOr:
case NodeType.Lt:
case NodeType.Maplet:
case NodeType.Mkrefany:
case NodeType.Mul:
case NodeType.Mul_Ovf:
case NodeType.Mul_Ovf_Un:
case NodeType.Ne:
case NodeType.Or:
case NodeType.Range:
case NodeType.Refanyval:
case NodeType.Rem:
case NodeType.Rem_Un:
case NodeType.RemoveEventHandler:
case NodeType.Shl:
case NodeType.Shr:
case NodeType.Shr_Un:
case NodeType.Sub:
case NodeType.Sub_Ovf:
case NodeType.Sub_Ovf_Un:
case NodeType.Unbox:
case NodeType.UnboxAny:
case NodeType.Xor:
return this.VisitBinaryExpression((BinaryExpression)node, changes as BinaryExpression, deletions as BinaryExpression, insertions as BinaryExpression);
case NodeType.AddressOf:
case NodeType.OutAddress:
case NodeType.RefAddress:
case NodeType.Ckfinite:
case NodeType.Conv_I:
case NodeType.Conv_I1:
case NodeType.Conv_I2:
case NodeType.Conv_I4:
case NodeType.Conv_I8:
case NodeType.Conv_Ovf_I:
case NodeType.Conv_Ovf_I1:
case NodeType.Conv_Ovf_I1_Un:
case NodeType.Conv_Ovf_I2:
case NodeType.Conv_Ovf_I2_Un:
case NodeType.Conv_Ovf_I4:
case NodeType.Conv_Ovf_I4_Un:
case NodeType.Conv_Ovf_I8:
case NodeType.Conv_Ovf_I8_Un:
case NodeType.Conv_Ovf_I_Un:
case NodeType.Conv_Ovf_U:
case NodeType.Conv_Ovf_U1:
case NodeType.Conv_Ovf_U1_Un:
case NodeType.Conv_Ovf_U2:
case NodeType.Conv_Ovf_U2_Un:
case NodeType.Conv_Ovf_U4:
case NodeType.Conv_Ovf_U4_Un:
case NodeType.Conv_Ovf_U8:
case NodeType.Conv_Ovf_U8_Un:
case NodeType.Conv_Ovf_U_Un:
case NodeType.Conv_R4:
case NodeType.Conv_R8:
case NodeType.Conv_R_Un:
case NodeType.Conv_U:
case NodeType.Conv_U1:
case NodeType.Conv_U2:
case NodeType.Conv_U4:
case NodeType.Conv_U8:
case NodeType.Decrement:
case NodeType.DefaultValue:
case NodeType.Increment:
case NodeType.Ldftn:
case NodeType.Ldlen:
case NodeType.Ldtoken:
case NodeType.Localloc:
case NodeType.LogicalNot:
case NodeType.Neg:
case NodeType.Not:
case NodeType.Parentheses:
case NodeType.Refanytype:
case NodeType.Sizeof:
case NodeType.SkipCheck:
case NodeType.Typeof:
case NodeType.UnaryPlus:
return this.VisitUnaryExpression((UnaryExpression)node, changes as UnaryExpression, deletions as UnaryExpression, insertions as UnaryExpression);
#if ExtendedRuntime
// query node types
case NodeType.QueryAggregate:
return this.VisitQueryAggregate((QueryAggregate)node, changes as QueryAggregate, deletions as QueryAggregate, insertions as QueryAggregate);
case NodeType.QueryAlias:
return this.VisitQueryAlias((QueryAlias)node, changes as QueryAlias, deletions as QueryAlias, insertions as QueryAlias);
case NodeType.QueryAll:
case NodeType.QueryAny:
return this.VisitQueryQuantifier((QueryQuantifier)node, changes as QueryQuantifier, deletions as QueryQuantifier, insertions as QueryQuantifier);
case NodeType.QueryAxis:
return this.VisitQueryAxis((QueryAxis)node, changes as QueryAxis, deletions as QueryAxis, insertions as QueryAxis);
case NodeType.QueryCommit:
return this.VisitQueryCommit((QueryCommit)node, changes as QueryCommit, deletions as QueryCommit, insertions as QueryCommit);
case NodeType.QueryContext:
return this.VisitQueryContext((QueryContext)node, changes as QueryContext, deletions as QueryContext, insertions as QueryContext);
case NodeType.QueryDelete:
return this.VisitQueryDelete((QueryDelete)node, changes as QueryDelete, deletions as QueryDelete, insertions as QueryDelete);
case NodeType.QueryDifference:
return this.VisitQueryDifference((QueryDifference)node, changes as QueryDifference, deletions as QueryDifference, insertions as QueryDifference);
case NodeType.QueryDistinct:
return this.VisitQueryDistinct((QueryDistinct)node, changes as QueryDistinct, deletions as QueryDistinct, insertions as QueryDistinct);
case NodeType.QueryExists:
return this.VisitQueryExists((QueryExists)node, changes as QueryExists, deletions as QueryExists, insertions as QueryExists);
case NodeType.QueryFilter:
return this.VisitQueryFilter((QueryFilter)node, changes as QueryFilter, deletions as QueryFilter, insertions as QueryFilter);
case NodeType.QueryGeneratedType:
return this.VisitQueryGeneratedType((QueryGeneratedType)node, changes as QueryGeneratedType, deletions as QueryGeneratedType, insertions as QueryGeneratedType);
case NodeType.QueryGroupBy:
return this.VisitQueryGroupBy((QueryGroupBy)node, changes as QueryGroupBy, deletions as QueryGroupBy, insertions as QueryGroupBy);
case NodeType.QueryInsert:
return this.VisitQueryInsert((QueryInsert)node, changes as QueryInsert, deletions as QueryInsert, insertions as QueryInsert);
case NodeType.QueryIntersection:
return this.VisitQueryIntersection((QueryIntersection)node, changes as QueryIntersection, deletions as QueryIntersection, insertions as QueryIntersection);
case NodeType.QueryIterator:
return this.VisitQueryIterator((QueryIterator)node, changes as QueryIterator, deletions as QueryIterator, insertions as QueryIterator);
case NodeType.QueryJoin:
return this.VisitQueryJoin((QueryJoin)node, changes as QueryJoin, deletions as QueryJoin, insertions as QueryJoin);
case NodeType.QueryLimit:
return this.VisitQueryLimit((QueryLimit)node, changes as QueryLimit, deletions as QueryLimit, insertions as QueryLimit);
case NodeType.QueryOrderBy:
return this.VisitQueryOrderBy((QueryOrderBy)node, changes as QueryOrderBy, deletions as QueryOrderBy, insertions as QueryOrderBy);
case NodeType.QueryOrderItem:
return this.VisitQueryOrderItem((QueryOrderItem)node, changes as QueryOrderItem, deletions as QueryOrderItem, insertions as QueryOrderItem);
case NodeType.QueryPosition:
return this.VisitQueryPosition((QueryPosition)node, changes as QueryPosition, deletions as QueryPosition, insertions as QueryPosition);
case NodeType.QueryProject:
return this.VisitQueryProject((QueryProject)node, changes as QueryProject, deletions as QueryProject, insertions as QueryProject);
case NodeType.QueryQuantifiedExpression:
return this.VisitQueryQuantifiedExpression((QueryQuantifiedExpression)node, changes as QueryQuantifiedExpression, deletions as QueryQuantifiedExpression, insertions as QueryQuantifiedExpression);
case NodeType.QueryRollback:
return this.VisitQueryRollback((QueryRollback)node, changes as QueryRollback, deletions as QueryRollback, insertions as QueryRollback);
case NodeType.QuerySelect:
return this.VisitQuerySelect((QuerySelect)node, changes as QuerySelect, deletions as QuerySelect, insertions as QuerySelect);
case NodeType.QuerySingleton:
return this.VisitQuerySingleton((QuerySingleton)node, changes as QuerySingleton, deletions as QuerySingleton, insertions as QuerySingleton);
case NodeType.QueryTransact:
return this.VisitQueryTransact((QueryTransact)node, changes as QueryTransact, deletions as QueryTransact, insertions as QueryTransact);
case NodeType.QueryTypeFilter:
return this.VisitQueryTypeFilter((QueryTypeFilter)node, changes as QueryTypeFilter, deletions as QueryTypeFilter, insertions as QueryTypeFilter);
case NodeType.QueryUnion:
return this.VisitQueryUnion((QueryUnion)node, changes as QueryUnion, deletions as QueryUnion, insertions as QueryUnion);
case NodeType.QueryUpdate:
return this.VisitQueryUpdate((QueryUpdate)node, changes as QueryUpdate, deletions as QueryUpdate, insertions as QueryUpdate);
case NodeType.QueryYielder:
return this.VisitQueryYielder((QueryYielder)node, changes as QueryYielder, deletions as QueryYielder, insertions as QueryYielder);
#endif
default:
return this.VisitUnknownNodeType(node, changes, deletions, insertions);
}
}
public virtual void UpdateSourceContext(Node node, Node changes)
{
}
public virtual Expression VisitAddressDereference(AddressDereference addr, AddressDereference changes, AddressDereference deletions, AddressDereference insertions)
{
this.UpdateSourceContext(addr, changes);
if (addr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
addr.Address = this.VisitExpression(addr.Address, changes.Address, deletions.Address, insertions.Address);
addr.Alignment = changes.Alignment;
addr.Volatile = changes.Volatile;
}
}
else if (deletions != null)
return null;
return addr;
}
public virtual AliasDefinition VisitAliasDefinition(AliasDefinition aliasDefinition, AliasDefinition changes, AliasDefinition deletions, AliasDefinition insertions)
{
this.UpdateSourceContext(aliasDefinition, changes);
if (aliasDefinition == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
aliasDefinition.Alias = changes.Alias;
aliasDefinition.AliasedType = this.VisitTypeReference(aliasDefinition.AliasedType, changes.AliasedType, deletions.AliasedType, insertions.AliasedType);
aliasDefinition.AliasedExpression = changes.AliasedExpression;
aliasDefinition.AliasedUri = changes.AliasedUri;
}
}
else if (deletions != null)
return null;
return aliasDefinition;
}
public virtual AliasDefinitionList VisitAliasDefinitionList(AliasDefinitionList aliasDefinitions, AliasDefinitionList changes, AliasDefinitionList deletions, AliasDefinitionList insertions)
{
if (changes == null || deletions == null || insertions == null) return aliasDefinitions;
int n = aliasDefinitions == null ? 0 : aliasDefinitions.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (aliasDefinitions != null)
for (int i = 0; i < n; i++)
aliasDefinitions[i] = this.VisitAliasDefinition(aliasDefinitions[i], changes[i], deletions[i], insertions[i]);
AliasDefinitionList result = new AliasDefinitionList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Expression VisitAnonymousNestedFunction(AnonymousNestedFunction func, AnonymousNestedFunction changes, AnonymousNestedFunction deletions, AnonymousNestedFunction insertions)
{
this.UpdateSourceContext(func, changes);
if (func == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
func.Body = this.VisitBlock(func.Body, changes.Body, deletions.Body, insertions.Body);
func.Parameters = this.VisitParameterList(func.Parameters, changes.Parameters, deletions.Parameters, insertions.Parameters);
}
}
else if (deletions != null)
return null;
return func;
}
public virtual Expression VisitApplyToAll(ApplyToAll applyToAll, ApplyToAll changes, ApplyToAll deletions, ApplyToAll insertions)
{
this.UpdateSourceContext(applyToAll, changes);
if (applyToAll == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
applyToAll.Operand1 = this.VisitExpression(applyToAll.Operand1, changes.Operand1, deletions.Operand1, insertions.Operand1);
applyToAll.Operand2 = this.VisitExpression(applyToAll.Operand2, changes.Operand2, deletions.Operand2, insertions.Operand2);
}
}
else if (deletions != null)
return null;
return applyToAll;
}
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly, AssemblyNode changes, AssemblyNode deletions, AssemblyNode insertions)
{
this.UpdateSourceContext(assembly, changes);
if (assembly == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
assembly.AssemblyReferences = this.VisitAssemblyReferenceList(assembly.AssemblyReferences, changes.AssemblyReferences, deletions.AssemblyReferences, insertions.AssemblyReferences);
assembly.Attributes = this.VisitAttributeList(assembly.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes);
assembly.Culture = changes.Culture;
assembly.ExportedTypes = this.VisitTypeReferenceList(assembly.ExportedTypes, changes.ExportedTypes, deletions.ExportedTypes, insertions.ExportedTypes);
assembly.Flags = changes.Flags;
assembly.Kind = changes.Kind;
assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes, changes.ModuleAttributes, deletions.ModuleAttributes, insertions.ModuleAttributes);
assembly.ModuleReferences = this.VisitModuleReferenceList(assembly.ModuleReferences, changes.ModuleReferences, deletions.ModuleReferences, insertions.ModuleReferences);
assembly.Name = changes.Name;
assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes, changes.SecurityAttributes, deletions.SecurityAttributes, insertions.SecurityAttributes);
assembly.Types = this.VisitTypeNodeList(assembly.Types, changes.Types, deletions.Types, insertions.Types);
assembly.Version = changes.Version;
}
}
else if (deletions != null)
return null;
return assembly;
}
public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference, AssemblyReference changes, AssemblyReference deletions, AssemblyReference insertions)
{
this.UpdateSourceContext(assemblyReference, changes);
if (assemblyReference == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
assemblyReference.Culture = changes.Culture;
assemblyReference.Flags = changes.Flags;
assemblyReference.Name = changes.Name;
assemblyReference.PublicKeyOrToken = changes.PublicKeyOrToken;
assemblyReference.Version = changes.Version;
}
}
else if (deletions != null)
return null;
return assemblyReference;
}
public virtual AssemblyReferenceList VisitAssemblyReferenceList(AssemblyReferenceList assemblyReferences, AssemblyReferenceList changes, AssemblyReferenceList deletions, AssemblyReferenceList insertions)
{
if (changes == null || deletions == null || insertions == null) return assemblyReferences;
int n = assemblyReferences == null ? 0 : assemblyReferences.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (assemblyReferences != null)
for (int i = 0; i < n; i++)
assemblyReferences[i] = this.VisitAssemblyReference(assemblyReferences[i], changes[i], deletions[i], insertions[i]);
AssemblyReferenceList result = new AssemblyReferenceList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Statement VisitAssertion(Assertion assertion, Assertion changes, Assertion deletions, Assertion insertions)
{
this.UpdateSourceContext(assertion, changes);
if (assertion == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
assertion.Condition = this.VisitExpression(assertion.Condition, changes.Condition, deletions.Condition, insertions.Condition);
}
}
else if (deletions != null)
return null;
return assertion;
}
public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment, AssignmentExpression changes, AssignmentExpression deletions, AssignmentExpression insertions)
{
this.UpdateSourceContext(assignment, changes);
if (assignment == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
assignment.AssignmentStatement = this.VisitAssignmentStatement(assignment.AssignmentStatement as AssignmentStatement, changes.AssignmentStatement as AssignmentStatement, deletions.AssignmentStatement as AssignmentStatement, insertions.AssignmentStatement as AssignmentStatement);
}
}
else if (deletions != null)
return null;
return assignment;
}
public virtual Statement VisitAssignmentStatement(AssignmentStatement assignment, AssignmentStatement changes, AssignmentStatement deletions, AssignmentStatement insertions)
{
this.UpdateSourceContext(assignment, changes);
if (assignment == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
assignment.Operator = changes.Operator;
assignment.Source = this.VisitExpression(assignment.Source, changes.Source, deletions.Source, insertions.Source);
assignment.Target = this.VisitExpression(assignment.Target, changes.Target, deletions.Target, insertions.Target);
}
}
else if (deletions != null)
return null;
return assignment;
}
public virtual AttributeNode VisitAttributeNode(AttributeNode attribute, AttributeNode changes, AttributeNode deletions, AttributeNode insertions)
{
this.UpdateSourceContext(attribute, changes);
if (attribute == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
attribute.AllowMultiple = changes.AllowMultiple;
attribute.Constructor = this.VisitExpression(attribute.Constructor, changes.Constructor, deletions.Constructor, insertions.Constructor);
attribute.Expressions = this.VisitExpressionList(attribute.Expressions, changes.Expressions, deletions.Expressions, insertions.Expressions);
attribute.Target = changes.Target;
}
}
else if (deletions != null)
return null;
return attribute;
}
public virtual AttributeList VisitAttributeList(AttributeList attributes, AttributeList changes, AttributeList deletions, AttributeList insertions)
{
if (changes == null || deletions == null || insertions == null) return attributes;
int n = attributes == null ? 0 : attributes.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (attributes != null)
for (int i = 0; i < n; i++)
attributes[i] = this.VisitAttributeNode(attributes[i], changes[i], deletions[i], insertions[i]);
AttributeList result = new AttributeList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Expression VisitBase(Base Base, Base changes, Base deletions, Base insertions)
{
this.UpdateSourceContext(Base, changes);
if (Base == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Base;
}
public virtual Expression VisitBinaryExpression(BinaryExpression binaryExpression, BinaryExpression changes, BinaryExpression deletions, BinaryExpression insertions)
{
this.UpdateSourceContext(binaryExpression, changes);
if (binaryExpression == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
binaryExpression.NodeType = changes.NodeType;
binaryExpression.Operand1 = this.VisitExpression(binaryExpression.Operand1, changes.Operand1, deletions.Operand1, insertions.Operand1);
binaryExpression.Operand2 = this.VisitExpression(binaryExpression.Operand2, changes.Operand2, deletions.Operand2, insertions.Operand2);
}
}
else if (deletions != null)
return null;
return binaryExpression;
}
public virtual Block VisitBlock(Block block, Block changes, Block deletions, Block insertions)
{
this.UpdateSourceContext(block, changes);
if (block == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
block.Checked = changes.Checked;
block.Statements = this.VisitStatementList(block.Statements, changes.Statements, deletions.Statements, insertions.Statements);
block.SuppressCheck = changes.SuppressCheck;
}
}
else if (deletions != null)
return null;
return block;
}
public virtual Expression VisitBlockExpression(BlockExpression blockExpression, BlockExpression changes, BlockExpression deletions, BlockExpression insertions)
{
this.UpdateSourceContext(blockExpression, changes);
if (blockExpression == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
blockExpression.Block = this.VisitBlock(blockExpression.Block, changes.Block, deletions.Block, insertions.Block);
}
}
else if (deletions != null)
return null;
return blockExpression;
}
public virtual BlockList VisitBlockList(BlockList blockList, BlockList changes, BlockList deletions, BlockList insertions)
{
if (changes == null || deletions == null || insertions == null) return blockList;
int n = blockList == null ? 0 : blockList.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (blockList != null)
for (int i = 0; i < n; i++)
blockList[i] = this.VisitBlock(blockList[i], changes[i], deletions[i], insertions[i]);
BlockList result = new BlockList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Catch VisitCatch(Catch Catch, Catch changes, Catch deletions, Catch insertions)
{
this.UpdateSourceContext(Catch, changes);
if (Catch == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
Catch.Block = this.VisitBlock(Catch.Block, changes.Block, deletions.Block, insertions.Block);
Catch.Type = this.VisitTypeReference(Catch.Type, changes.Type);
Catch.Variable = this.VisitExpression(Catch.Variable, changes.Variable, deletions.Variable, insertions.Variable);
}
}
else if (deletions != null)
return null;
return Catch;
}
public virtual CatchList VisitCatchList(CatchList catchers, CatchList changes, CatchList deletions, CatchList insertions)
{
if (changes == null || deletions == null || insertions == null) return catchers;
int n = catchers == null ? 0 : catchers.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (catchers != null)
for (int i = 0; i < n; i++)
catchers[i] = this.VisitCatch(catchers[i], changes[i], deletions[i], insertions[i]);
CatchList result = new CatchList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Class VisitClass(Class Class, Class changes, Class deletions, Class insertions)
{
TypeNode result = this.VisitTypeNode(Class, changes, deletions, insertions);
Debug.Assert(result is Class);
return result as Class;
}
public virtual Expression VisitCoerceTuple(CoerceTuple coerceTuple, CoerceTuple changes, CoerceTuple deletions, CoerceTuple insertions)
{
this.UpdateSourceContext(coerceTuple, changes);
if (coerceTuple == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
coerceTuple.Fields = this.VisitFieldList(coerceTuple.Fields, changes.Fields, deletions.Fields, insertions.Fields);
coerceTuple.OriginalTuple = this.VisitExpression(coerceTuple.OriginalTuple, changes.OriginalTuple, deletions.OriginalTuple, insertions.OriginalTuple);
}
}
else if (deletions != null)
return null;
return coerceTuple;
}
public virtual CollectionEnumerator VisitCollectionEnumerator(CollectionEnumerator ce, CollectionEnumerator changes, CollectionEnumerator deletions, CollectionEnumerator insertions)
{
this.UpdateSourceContext(ce, changes);
if (ce == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
ce.Collection = this.VisitExpression(ce.Collection, changes.Collection, deletions.Collection, insertions.Collection);
//REVIEW: update method bindings?
}
}
else if (deletions != null)
return null;
return ce;
}
public virtual Compilation VisitCompilation(Compilation compilation, Compilation changes, Compilation deletions, Compilation insertions)
{
this.UpdateSourceContext(compilation, changes);
if (compilation == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
compilation.CompilerParameters = changes.CompilerParameters;
compilation.CompilationUnits = this.VisitCompilationUnitList(compilation.CompilationUnits, changes.CompilationUnits, deletions.CompilationUnits, insertions.CompilationUnits);
}
}
else if (deletions != null)
return null;
return compilation;
}
public virtual CompilationUnit VisitCompilationUnit(CompilationUnit cUnit, CompilationUnit changes, CompilationUnit deletions, CompilationUnit insertions)
{
this.UpdateSourceContext(cUnit, changes);
if (cUnit == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
cUnit.Nodes = this.VisitNodeList(cUnit.Nodes, changes.Nodes, deletions.Nodes, insertions.Nodes);
cUnit.PreprocessorDefinedSymbols = changes.PreprocessorDefinedSymbols;
}
}
else if (deletions != null)
return null;
return cUnit;
}
public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList compUnits, CompilationUnitList changes, CompilationUnitList deletions, CompilationUnitList insertions)
{
if (changes == null || deletions == null || insertions == null) return compUnits;
int n = compUnits == null ? 0 : compUnits.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (compUnits != null)
for (int i = 0; i < n; i++)
compUnits[i] = this.VisitCompilationUnit(compUnits[i], changes[i], deletions[i], insertions[i]);
CompilationUnitList result = new CompilationUnitList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual CompilationUnitSnippet VisitCompilationUnitSnippet(CompilationUnitSnippet snippet, CompilationUnitSnippet changes, CompilationUnitSnippet deletions, CompilationUnitSnippet insertions)
{
CompilationUnit cu = this.VisitCompilationUnit(snippet, changes, deletions, insertions);
Debug.Assert(cu is CompilationUnitSnippet);
return cu as CompilationUnitSnippet;
}
public virtual Node VisitComposition(Composition comp, Composition changes, Composition deletions, Composition insertions)
{
this.UpdateSourceContext(comp, changes);
if (comp == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
comp.Expression = this.VisitExpression(comp.Expression, changes.Expression, deletions.Expression, insertions.Expression);
}
}
else if (deletions != null)
return null;
return comp;
}
public virtual Expression VisitConstruct(Construct cons, Construct changes, Construct deletions, Construct insertions)
{
this.UpdateSourceContext(cons, changes);
if (cons == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
cons.Constructor = this.VisitExpression(cons.Constructor, changes.Constructor, deletions.Constructor, insertions.Constructor);
cons.Operands = this.VisitExpressionList(cons.Operands, changes.Operands, deletions.Operands, insertions.Operands);
cons.Owner = this.VisitExpression(cons.Owner, changes.Owner, deletions.Owner, insertions.Owner);
}
}
else if (deletions != null)
return null;
return cons;
}
public virtual Expression VisitConstructArray(ConstructArray consArr, ConstructArray changes, ConstructArray deletions, ConstructArray insertions)
{
this.UpdateSourceContext(consArr, changes);
if (consArr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
consArr.ElementType = this.VisitTypeReference(consArr.ElementType, changes.ElementType);
consArr.Initializers = this.VisitExpressionList(consArr.Initializers, changes.Initializers, deletions.Initializers, insertions.Initializers);
consArr.Operands = this.VisitExpressionList(consArr.Operands, changes.Operands, deletions.Operands, insertions.Operands);
consArr.Rank = changes.Rank;
consArr.Owner = this.VisitExpression(consArr.Owner, changes.Owner, deletions.Owner, insertions.Owner);
}
}
else if (deletions != null)
return null;
return consArr;
}
public virtual Expression VisitConstructDelegate(ConstructDelegate consDelegate, ConstructDelegate changes, ConstructDelegate deletions, ConstructDelegate insertions)
{
this.UpdateSourceContext(consDelegate, changes);
if (consDelegate == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
consDelegate.DelegateType = this.VisitTypeReference(consDelegate.DelegateType, changes.DelegateType);
consDelegate.MethodName = changes.MethodName;
consDelegate.TargetObject = this.VisitExpression(consDelegate.TargetObject, changes.TargetObject, deletions.TargetObject, insertions.TargetObject);
}
}
else if (deletions != null)
return null;
return consDelegate;
}
public virtual Expression VisitConstructFlexArray(ConstructFlexArray consArr, ConstructFlexArray changes, ConstructFlexArray deletions, ConstructFlexArray insertions)
{
this.UpdateSourceContext(consArr, changes);
if (consArr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
consArr.ElementType = this.VisitTypeReference(consArr.ElementType, changes.ElementType);
consArr.Initializers = this.VisitExpressionList(consArr.Initializers, changes.Initializers, deletions.Initializers, insertions.Initializers);
consArr.Operands = this.VisitExpressionList(consArr.Operands, changes.Operands, deletions.Operands, insertions.Operands);
}
}
else if (deletions != null)
return null;
return consArr;
}
public virtual Expression VisitConstructIterator(ConstructIterator consIterator, ConstructIterator changes, ConstructIterator deletions, ConstructIterator insertions)
{
this.UpdateSourceContext(consIterator, changes);
if (consIterator == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
consIterator.Body = this.VisitBlock(consIterator.Body, changes.Body, deletions.Body, insertions.Body);
consIterator.ElementType = this.VisitTypeReference(consIterator.ElementType, changes.ElementType);
consIterator.State = this.VisitClass(consIterator.State, changes.State, deletions.State, insertions.State);
}
}
else if (deletions != null)
return null;
return consIterator;
}
public virtual Expression VisitConstructTuple(ConstructTuple consTuple, ConstructTuple changes, ConstructTuple deletions, ConstructTuple insertions)
{
this.UpdateSourceContext(consTuple, changes);
if (consTuple == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
consTuple.Fields = this.VisitFieldList(consTuple.Fields, changes.Fields, deletions.Fields, insertions.Fields);
}
}
else if (deletions != null)
return null;
return consTuple;
}
#if ExtendedRuntime
public virtual TypeNode VisitConstrainedType(ConstrainedType cType, ConstrainedType changes, ConstrainedType deletions, ConstrainedType insertions){
this.UpdateSourceContext(cType, changes);
if (cType == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
cType.Constraint = this.VisitExpression(cType.Constraint, changes.Constraint, deletions.Constraint, insertions.Constraint);
cType.UnderlyingType = this.VisitTypeReference(cType.UnderlyingType, changes.UnderlyingType);
}
}else if (deletions != null)
return null;
return cType;
}
#endif
public virtual Statement VisitContinue(Continue Continue, Continue changes, Continue deletions, Continue insertions)
{
this.UpdateSourceContext(Continue, changes);
if (Continue == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
Continue.Level = changes.Level;
}
}
else if (deletions != null)
return null;
return Continue;
}
public virtual Expression VisitCurrentClosure(CurrentClosure currentClosure, CurrentClosure changes, CurrentClosure deletions, CurrentClosure insertions)
{
this.UpdateSourceContext(currentClosure, changes);
if (currentClosure == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return currentClosure;
}
public virtual DelegateNode VisitDelegateNode(DelegateNode delegateNode, DelegateNode changes, DelegateNode deletions, DelegateNode insertions)
{
this.UpdateSourceContext(delegateNode, changes);
if (delegateNode == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
delegateNode.Attributes = this.VisitAttributeList(delegateNode.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes);
#if !NoXml
delegateNode.Documentation = changes.Documentation;
#endif
delegateNode.Flags = changes.Flags;
delegateNode.Parameters = this.VisitParameterList(delegateNode.Parameters, changes.Parameters, deletions.Parameters, insertions.Parameters);
delegateNode.ReturnType = this.VisitTypeReference(delegateNode.ReturnType, changes.ReturnType);
delegateNode.SecurityAttributes = this.VisitSecurityAttributeList(delegateNode.SecurityAttributes, changes.SecurityAttributes, deletions.SecurityAttributes, insertions.SecurityAttributes);
delegateNode.TemplateParameters = this.VisitTypeReferenceList(delegateNode.TemplateParameters, changes.TemplateParameters, deletions.TemplateParameters, insertions.TemplateParameters);
}
}
else if (deletions != null)
return null;
return delegateNode;
}
public virtual Statement VisitDoWhile(DoWhile doWhile, DoWhile changes, DoWhile deletions, DoWhile insertions)
{
this.UpdateSourceContext(doWhile, changes);
if (doWhile == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
doWhile.Body = this.VisitBlock(doWhile.Body, changes.Body, deletions.Body, insertions.Body);
doWhile.Condition = this.VisitExpression(doWhile.Condition, changes.Condition, deletions.Condition, insertions.Condition);
}
}
else if (deletions != null)
return null;
return doWhile;
}
public virtual Statement VisitEndFilter(EndFilter endFilter, EndFilter changes, EndFilter deletions, EndFilter insertions)
{
this.UpdateSourceContext(endFilter, changes);
if (endFilter == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
endFilter.Value = this.VisitExpression(endFilter.Value, changes.Value, deletions.Value, insertions.Value);
}
}
else if (deletions != null)
return null;
return endFilter;
}
public virtual Statement VisitEndFinally(EndFinally endFinally, EndFinally changes, EndFinally deletions, EndFinally insertions)
{
this.UpdateSourceContext(endFinally, changes);
if (endFinally == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return endFinally;
}
public virtual EnumNode VisitEnumNode(EnumNode enumNode, EnumNode changes, EnumNode deletions, EnumNode insertions)
{
if (enumNode == null) return changes;
TypeNode result = this.VisitTypeNode(enumNode, changes, deletions, insertions);
Debug.Assert(result is EnumNode);
if (result == enumNode)
{
Debug.Assert(changes != null);
if (changes != null)
enumNode.UnderlyingType = this.VisitTypeReference(enumNode.UnderlyingType, changes.UnderlyingType);
return enumNode;
}
return result as EnumNode;
}
public virtual Event VisitEvent(Event evnt, Event changes, Event deletions, Event insertions)
{
this.UpdateSourceContext(evnt, changes);
if (evnt == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
evnt.Attributes = this.VisitAttributeList(evnt.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes);
#if !NoXml
evnt.Documentation = changes.Documentation;
#endif
evnt.Flags = changes.Flags;
evnt.HandlerAdder = this.VisitMethodReference(evnt.HandlerAdder, changes.HandlerAdder);
evnt.HandlerCaller = this.VisitMethodReference(evnt.HandlerCaller, changes.HandlerCaller);
evnt.HandlerFlags = changes.HandlerFlags;
evnt.HandlerRemover = this.VisitMethodReference(evnt.HandlerRemover, changes.HandlerRemover);
evnt.HandlerType = this.VisitTypeReference(evnt.HandlerType, changes.HandlerType);
evnt.InitialHandler = this.VisitExpression(evnt.InitialHandler, changes.InitialHandler, deletions.InitialHandler, insertions.InitialHandler);
evnt.Name = changes.Name;
evnt.OtherMethods = this.VisitMethodReferenceList(evnt.OtherMethods, changes.OtherMethods);
evnt.OverridesBaseClassMember = changes.OverridesBaseClassMember;
}
}
else if (deletions != null)
return null;
return evnt;
}
public virtual Statement VisitExit(Exit exit, Exit changes, Exit deletions, Exit insertions)
{
this.UpdateSourceContext(exit, changes);
if (exit == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
exit.Level = changes.Level;
}
}
else if (deletions != null)
return null;
return exit;
}
public virtual Expression VisitExpression(Expression expression, Expression changes, Expression deletions, Expression insertions)
{
return this.Visit(expression, changes, deletions, insertions) as Expression;
}
public virtual ExpressionList VisitExpressionList(ExpressionList expressions, ExpressionList changes, ExpressionList deletions, ExpressionList insertions)
{
if (changes == null || deletions == null || insertions == null) return expressions;
int n = expressions == null ? 0 : expressions.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (expressions != null)
for (int i = 0; i < n; i++)
expressions[i] = this.VisitExpression(expressions[i], changes[i], deletions[i], insertions[i]);
ExpressionList result = new ExpressionList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Expression VisitExpressionSnippet(ExpressionSnippet snippet, ExpressionSnippet changes, ExpressionSnippet deletions, ExpressionSnippet insertions)
{
this.UpdateSourceContext(snippet, changes);
if (snippet == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return snippet;
}
public virtual Statement VisitExpressionStatement(ExpressionStatement statement, ExpressionStatement changes, ExpressionStatement deletions, ExpressionStatement insertions)
{
this.UpdateSourceContext(statement, changes);
if (statement == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
statement.Expression = this.VisitExpression(statement.Expression, changes.Expression, deletions.Expression, insertions.Expression);
}
}
else if (deletions != null)
return null;
return statement;
}
public virtual FaultHandler VisitFaultHandler(FaultHandler faultHandler, FaultHandler changes, FaultHandler deletions, FaultHandler insertions)
{
this.UpdateSourceContext(faultHandler, changes);
if (faultHandler == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
faultHandler.Block = this.VisitBlock(faultHandler.Block, changes.Block, deletions.Block, insertions.Block);
}
}
else if (deletions != null)
return null;
return faultHandler;
}
public virtual FaultHandlerList VisitFaultHandlerList(FaultHandlerList faultHandlers, FaultHandlerList changes, FaultHandlerList deletions, FaultHandlerList insertions)
{
if (changes == null || deletions == null || insertions == null) return faultHandlers;
int n = faultHandlers == null ? 0 : faultHandlers.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (faultHandlers != null)
for (int i = 0; i < n; i++)
faultHandlers[i] = this.VisitFaultHandler(faultHandlers[i], changes[i], deletions[i], insertions[i]);
FaultHandlerList result = new FaultHandlerList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Field VisitField(Field field, Field changes, Field deletions, Field insertions)
{
this.UpdateSourceContext(field, changes);
if (field == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
field.Attributes = this.VisitAttributeList(field.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes);
field.DefaultValue = this.VisitLiteral(field.DefaultValue, changes.DefaultValue, deletions.DefaultValue, insertions.DefaultValue);
#if !NoXml
field.Documentation = changes.Documentation;
#endif
field.Flags = changes.Flags;
field.HidesBaseClassMember = changes.HidesBaseClassMember;
field.ImplementedInterfaces = this.VisitInterfaceReferenceList(field.ImplementedInterfaces, changes.ImplementedInterfaces, deletions.ImplementedInterfaces, insertions.ImplementedInterfaces);
field.InitialData = changes.InitialData;
field.Initializer = changes.Initializer;
field.MarshallingInformation = changes.MarshallingInformation;
field.Name = changes.Name;
field.Offset = changes.Offset;
field.OverridesBaseClassMember = changes.OverridesBaseClassMember;
field.Section = changes.Section;
field.Type = this.VisitTypeReference(field.Type, changes.Type);
}
}
else if (deletions != null)
return null;
return field;
}
public virtual Block VisitFieldInitializerBlock(FieldInitializerBlock block, FieldInitializerBlock changes, FieldInitializerBlock deletions, FieldInitializerBlock insertions)
{
this.UpdateSourceContext(block, changes);
if (block == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
block.IsStatic = changes.IsStatic;
}
}
else if (deletions != null)
return null;
return block;
}
public virtual FieldList VisitFieldList(FieldList fields, FieldList changes, FieldList deletions, FieldList insertions)
{
if (changes == null || deletions == null || insertions == null) return fields;
int n = fields == null ? 0 : fields.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (fields != null)
for (int i = 0; i < n; i++)
fields[i] = this.VisitField(fields[i], changes[i], deletions[i], insertions[i]);
FieldList result = new FieldList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Statement VisitFilter(Filter filter, Filter changes, Filter deletions, Filter insertions)
{
this.UpdateSourceContext(filter, changes);
if (filter == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
filter.Block = this.VisitBlock(filter.Block, changes.Block, deletions.Block, insertions.Block);
}
}
else if (deletions != null)
return null;
return filter;
}
public virtual FilterList VisitFilterList(FilterList filters, FilterList changes, FilterList deletions, FilterList insertions)
{
if (filters == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return filters;
}
public virtual Statement VisitFinally(Finally Finally, Finally changes, Finally deletions, Finally insertions)
{
this.UpdateSourceContext(Finally, changes);
if (Finally == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Finally;
}
public virtual Statement VisitFixed(Fixed Fixed, Fixed changes, Fixed deletions, Fixed insertions)
{
this.UpdateSourceContext(Fixed, changes);
if (Fixed == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Fixed;
}
public virtual Statement VisitFor(For For, For changes, For deletions, For insertions)
{
this.UpdateSourceContext(For, changes);
if (For == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return For;
}
public virtual Statement VisitForEach(ForEach forEach, ForEach changes, ForEach deletions, ForEach insertions)
{
this.UpdateSourceContext(forEach, changes);
if (forEach == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return forEach;
}
public virtual Statement VisitFunctionDeclaration(FunctionDeclaration functionDeclaration, FunctionDeclaration changes, FunctionDeclaration deletions, FunctionDeclaration insertions)
{
this.UpdateSourceContext(functionDeclaration, changes);
if (functionDeclaration == null) return changes;
return functionDeclaration;
}
public virtual Expression VisitTemplateInstance(TemplateInstance instance, TemplateInstance changes, TemplateInstance deletions, TemplateInstance insertions)
{
this.UpdateSourceContext(instance, changes);
if (instance == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return instance;
}
public virtual Expression VisitStackAlloc(StackAlloc alloc, StackAlloc changes, StackAlloc deletions, StackAlloc insertions)
{
this.UpdateSourceContext(alloc, changes);
if (alloc == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return alloc;
}
public virtual Statement VisitGoto(Goto Goto, Goto changes, Goto deletions, Goto insertions)
{
this.UpdateSourceContext(Goto, changes);
if (Goto == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Goto;
}
public virtual Statement VisitGotoCase(GotoCase gotoCase, GotoCase changes, GotoCase deletions, GotoCase insertions)
{
this.UpdateSourceContext(gotoCase, changes);
if (gotoCase == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return gotoCase;
}
public virtual Expression VisitIdentifier(Identifier identifier, Identifier changes, Identifier deletions, Identifier insertions)
{
this.UpdateSourceContext(identifier, changes);
if (identifier == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return identifier;
}
public virtual Statement VisitIf(If If, If changes, If deletions, If insertions)
{
this.UpdateSourceContext(If, changes);
if (If == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return If;
}
public virtual Expression VisitImplicitThis(ImplicitThis implicitThis, ImplicitThis changes, ImplicitThis deletions, ImplicitThis insertions)
{
this.UpdateSourceContext(implicitThis, changes);
if (implicitThis == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return implicitThis;
}
public virtual Expression VisitIndexer(Indexer indexer, Indexer changes, Indexer deletions, Indexer insertions)
{
this.UpdateSourceContext(indexer, changes);
if (indexer == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return indexer;
}
public virtual Interface VisitInterface(Interface Interface, Interface changes, Interface deletions, Interface insertions)
{
return (Interface)this.VisitTypeNode(Interface, changes, deletions, insertions);
}
public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaces, InterfaceList changes, InterfaceList deletions, InterfaceList insertions)
{
if (interfaces == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return interfaces;
}
public virtual Interface VisitInterfaceReference(Interface Interface, Interface changes)
{
return (Interface)this.VisitTypeReference(Interface, changes);
}
public virtual InstanceInitializer VisitInstanceInitializer(InstanceInitializer cons, InstanceInitializer changes, InstanceInitializer deletions, InstanceInitializer insertions)
{
return (InstanceInitializer)this.VisitMethod(cons, changes, deletions, insertions);
}
public virtual Statement VisitLabeledStatement(LabeledStatement lStatement, LabeledStatement changes, LabeledStatement deletions, LabeledStatement insertions)
{
this.UpdateSourceContext(lStatement, changes);
if (lStatement == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return lStatement;
}
public virtual Literal VisitLiteral(Literal literal, Literal changes, Literal deletions, Literal insertions)
{
this.UpdateSourceContext(literal, changes);
if (literal == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return literal;
}
public virtual Expression VisitLocal(Local local, Local changes, Local deletions, Local insertions)
{
this.UpdateSourceContext(local, changes);
if (local == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return local;
}
public virtual LocalDeclaration VisitLocalDeclaration(LocalDeclaration localDeclaration, LocalDeclaration changes, LocalDeclaration deletions, LocalDeclaration insertions)
{
this.UpdateSourceContext(localDeclaration, changes);
if (localDeclaration == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return localDeclaration;
}
public virtual LocalDeclarationList VisitLocalDeclarationList(LocalDeclarationList localDeclarations, LocalDeclarationList changes, LocalDeclarationList deletions, LocalDeclarationList insertions)
{
if (localDeclarations == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return localDeclarations;
}
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations, LocalDeclarationsStatement changes, LocalDeclarationsStatement deletions, LocalDeclarationsStatement insertions)
{
this.UpdateSourceContext(localDeclarations, changes);
if (localDeclarations == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return localDeclarations;
}
public virtual Statement VisitLock(Lock Lock, Lock changes, Lock deletions, Lock insertions)
{
this.UpdateSourceContext(Lock, changes);
if (Lock == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Lock;
}
public virtual Expression VisitLRExpression(LRExpression expr, LRExpression changes, LRExpression deletions, LRExpression insertions)
{
this.UpdateSourceContext(expr, changes);
if (expr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return expr;
}
public virtual Expression VisitMemberBinding(MemberBinding memberBinding, MemberBinding changes, MemberBinding deletions, MemberBinding insertions)
{
this.UpdateSourceContext(memberBinding, changes);
if (memberBinding == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return memberBinding;
}
public virtual MemberList VisitMemberList(MemberList members, MemberList changes, MemberList deletions, MemberList insertions)
{
if (members == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return members;
}
public virtual Method VisitMethod(Method method, Method changes, Method deletions, Method insertions)
{
this.UpdateSourceContext(method, changes);
if (method == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return method;
}
public virtual Expression VisitMethodCall(MethodCall call, MethodCall changes, MethodCall deletions, MethodCall insertions)
{
this.UpdateSourceContext(call, changes);
if (call == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return call;
}
public virtual Method VisitMethodReference(Method method, Method changes)
{
return method;
}
public virtual MethodList VisitMethodReferenceList(MethodList methodList, MethodList changesList)
{
return methodList;
}
public virtual Module VisitModule(Module module, Module changes, Module deletions, Module insertions)
{
this.UpdateSourceContext(module, changes);
if (module == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return module;
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference, ModuleReference changes, ModuleReference deletions, ModuleReference insertions)
{
this.UpdateSourceContext(moduleReference, changes);
if (moduleReference == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return moduleReference;
}
public virtual ModuleReferenceList VisitModuleReferenceList(ModuleReferenceList moduleReferences, ModuleReferenceList changes, ModuleReferenceList deletions, ModuleReferenceList insertions)
{
return moduleReferences;
}
public virtual Expression VisitNameBinding(NameBinding nameBinding, NameBinding changes, NameBinding deletions, NameBinding insertions)
{
this.UpdateSourceContext(nameBinding, changes);
if (nameBinding == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return nameBinding;
}
public virtual Expression VisitNamedArgument(NamedArgument namedArgument, NamedArgument changes, NamedArgument deletions, NamedArgument insertions)
{
this.UpdateSourceContext(namedArgument, changes);
if (namedArgument == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return namedArgument;
}
public virtual Namespace VisitNamespace(Namespace nspace, Namespace changes, Namespace deletions, Namespace insertions)
{
this.UpdateSourceContext(nspace, changes);
if (nspace == null) return changes;
return nspace;
}
public virtual NamespaceList VisitNamespaceList(NamespaceList namespaces, NamespaceList changes, NamespaceList deletions, NamespaceList insertions)
{
if (namespaces == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return namespaces;
}
public virtual NodeList VisitNodeList(NodeList nodeList, NodeList changes, NodeList deletions, NodeList insertions)
{
if (changes == null || deletions == null || insertions == null) return nodeList;
int n = nodeList == null ? 0 : nodeList.Count;
if (n > changes.Count) { Debug.Assert(false); n = changes.Count; }
if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; }
if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; }
if (nodeList != null)
for (int i = 0; i < n; i++)
nodeList[i] = this.Visit(nodeList[i], changes[i], deletions[i], insertions[i]);
NodeList result = new NodeList(insertions.Count - n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
public virtual Expression VisitParameter(Parameter parameter, Parameter changes, Parameter deletions, Parameter insertions)
{
this.UpdateSourceContext(parameter, changes);
if (parameter == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return parameter;
}
public virtual ParameterList VisitParameterList(ParameterList parameterList, ParameterList changes, ParameterList deletions, ParameterList insertions)
{
if (parameterList == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return parameterList;
}
public virtual Expression VisitPrefixExpression(PrefixExpression pExpr, PrefixExpression changes, PrefixExpression deletions, PrefixExpression insertions)
{
this.UpdateSourceContext(pExpr, changes);
if (pExpr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return pExpr;
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr, PostfixExpression changes, PostfixExpression deletions, PostfixExpression insertions)
{
this.UpdateSourceContext(pExpr, changes);
if (pExpr == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return pExpr;
}
public virtual Property VisitProperty(Property property, Property changes, Property deletions, Property insertions)
{
this.UpdateSourceContext(property, changes);
if (property == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return property;
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier, QualifiedIdentifier changes, QualifiedIdentifier deletions, QualifiedIdentifier insertions)
{
this.UpdateSourceContext(qualifiedIdentifier, changes);
if (qualifiedIdentifier == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return qualifiedIdentifier;
}
public virtual Statement VisitRepeat(Repeat repeat, Repeat changes, Repeat deletions, Repeat insertions)
{
this.UpdateSourceContext(repeat, changes);
if (repeat == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return repeat;
}
public virtual Statement VisitResourceUse(ResourceUse resourceUse, ResourceUse changes, ResourceUse deletions, ResourceUse insertions)
{
this.UpdateSourceContext(resourceUse, changes);
if (resourceUse == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return resourceUse;
}
public virtual Statement VisitReturn(Return Return, Return changes, Return deletions, Return insertions)
{
this.UpdateSourceContext(Return, changes);
if (Return == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Return;
}
public virtual SecurityAttribute VisitSecurityAttribute(SecurityAttribute attribute, SecurityAttribute changes, SecurityAttribute deletions, SecurityAttribute insertions)
{
this.UpdateSourceContext(attribute, changes);
if (attribute == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return attribute;
}
public virtual SecurityAttributeList VisitSecurityAttributeList(SecurityAttributeList attributes, SecurityAttributeList changes, SecurityAttributeList deletions, SecurityAttributeList insertions)
{
if (attributes == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return attributes;
}
public virtual Expression VisitSetterValue(SetterValue value, SetterValue changes, SetterValue deletions, SetterValue insertions)
{
this.UpdateSourceContext(value, changes);
if (value == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return value;
}
public virtual StatementList VisitStatementList(StatementList statements, StatementList changes, StatementList deletions, StatementList insertions)
{
if (statements == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return statements;
}
public virtual StatementSnippet VisitStatementSnippet(StatementSnippet snippet, StatementSnippet changes, StatementSnippet deletions, StatementSnippet insertions)
{
this.UpdateSourceContext(snippet, changes);
if (snippet == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return snippet;
}
public virtual StaticInitializer VisitStaticInitializer(StaticInitializer cons, StaticInitializer changes, StaticInitializer deletions, StaticInitializer insertions)
{
return (StaticInitializer)this.VisitMethod(cons, changes, deletions, insertions);
}
public virtual Struct VisitStruct(Struct Struct, Struct changes, Struct deletions, Struct insertions)
{
return (Struct)this.VisitTypeNode(Struct, changes, deletions, insertions);
}
public virtual Statement VisitSwitch(Switch Switch, Switch changes, Switch deletions, Switch insertions)
{
this.UpdateSourceContext(Switch, changes);
if (Switch == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Switch;
}
public virtual SwitchCase VisitSwitchCase(SwitchCase switchCase, SwitchCase changes, SwitchCase deletions, SwitchCase insertions)
{
this.UpdateSourceContext(switchCase, changes);
if (switchCase == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return switchCase;
}
public virtual SwitchCaseList VisitSwitchCaseList(SwitchCaseList switchCases, SwitchCaseList changes, SwitchCaseList deletions, SwitchCaseList insertions)
{
if (switchCases == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return switchCases;
}
public virtual Statement VisitSwitchInstruction(SwitchInstruction switchInstruction, SwitchInstruction changes, SwitchInstruction deletions, SwitchInstruction insertions)
{
this.UpdateSourceContext(switchInstruction, changes);
if (switchInstruction == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return switchInstruction;
}
public virtual Statement VisitTypeswitch(Typeswitch Typeswitch, Typeswitch changes, Typeswitch deletions, Typeswitch insertions)
{
this.UpdateSourceContext(Typeswitch, changes);
if (Typeswitch == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Typeswitch;
}
public virtual TypeswitchCase VisitTypeswitchCase(TypeswitchCase typeswitchCase, TypeswitchCase changes, TypeswitchCase deletions, TypeswitchCase insertions)
{
this.UpdateSourceContext(typeswitchCase, changes);
if (typeswitchCase == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeswitchCase;
}
public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases, TypeswitchCaseList changes, TypeswitchCaseList deletions, TypeswitchCaseList insertions)
{
if (typeswitchCases == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeswitchCases;
}
public virtual Expression VisitTargetExpression(Expression expression, Expression changes, Expression deletions, Expression insertions)
{
return this.VisitExpression(expression, changes, deletions, insertions);
}
public virtual Expression VisitTernaryExpression(TernaryExpression expression, TernaryExpression changes, TernaryExpression deletions, TernaryExpression insertions)
{
this.UpdateSourceContext(expression, changes);
if (expression == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return expression;
}
public virtual Expression VisitThis(This This, This changes, This deletions, This insertions)
{
this.UpdateSourceContext(This, changes);
if (This == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return This;
}
public virtual Statement VisitThrow(Throw Throw, Throw changes, Throw deletions, Throw insertions)
{
this.UpdateSourceContext(Throw, changes);
if (Throw == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Throw;
}
public virtual Statement VisitTry(Try Try, Try changes, Try deletions, Try insertions)
{
this.UpdateSourceContext(Try, changes);
if (Try == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Try;
}
#if ExtendedRuntime
public virtual TupleType VisitTupleType(TupleType tuple, TupleType changes, TupleType deletions, TupleType insertions){
return (TupleType)this.VisitTypeNode(tuple, changes, deletions, insertions);
}
public virtual TypeAlias VisitTypeAlias(TypeAlias tAlias, TypeAlias changes, TypeAlias deletions, TypeAlias insertions){
this.UpdateSourceContext(tAlias, changes);
if (tAlias == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return tAlias;
}
public virtual TypeIntersection VisitTypeIntersection(TypeIntersection typeIntersection, TypeIntersection changes, TypeIntersection deletions, TypeIntersection insertions){
return (TypeIntersection)this.VisitTypeNode(typeIntersection, changes, deletions, insertions);
}
#endif
public virtual TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet, TypeMemberSnippet changes, TypeMemberSnippet deletions, TypeMemberSnippet insertions)
{
this.UpdateSourceContext(snippet, changes);
return snippet;
}
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier, TypeModifier changes, TypeModifier deletions, TypeModifier insertions)
{
this.UpdateSourceContext(typeModifier, changes);
if (typeModifier == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeModifier;
}
public virtual TypeNode VisitTypeNode(TypeNode typeNode, TypeNode changes, TypeNode deletions, TypeNode insertions)
{
this.UpdateSourceContext(typeNode, changes);
if (typeNode == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeNode;
}
public virtual TypeNodeList VisitTypeNodeList(TypeNodeList types, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions)
{
if (types == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return types;
}
public virtual TypeNode VisitTypeParameter(TypeNode typeParameter, TypeNode changes, TypeNode deletions, TypeNode insertions)
{
this.UpdateSourceContext(typeParameter, changes);
if (typeParameter == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeParameter;
}
public virtual TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions)
{
if (typeParameters == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeParameters;
}
public virtual TypeNode VisitTypeReference(TypeNode type, TypeNode changes)
{
return type;
}
public virtual TypeReference VisitTypeReference(TypeReference type, TypeReference changes, TypeReference deletions, TypeReference insertions)
{
return type;
}
public virtual TypeNodeList VisitTypeReferenceList(TypeNodeList typeReferences, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions)
{
if (typeReferences == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return typeReferences;
}
#if ExtendedRuntime
public virtual TypeUnion VisitTypeUnion(TypeUnion typeUnion, TypeUnion changes, TypeUnion deletions, TypeUnion insertions){
return (TypeUnion)this.VisitTypeNode(typeUnion, changes, deletions, insertions);
}
#endif
public virtual Expression VisitUnaryExpression(UnaryExpression unaryExpression, UnaryExpression changes, UnaryExpression deletions, UnaryExpression insertions)
{
this.UpdateSourceContext(unaryExpression, changes);
if (unaryExpression == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return unaryExpression;
}
public virtual Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration, VariableDeclaration changes, VariableDeclaration deletions, VariableDeclaration insertions)
{
this.UpdateSourceContext(variableDeclaration, changes);
if (variableDeclaration == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return variableDeclaration;
}
public virtual UsedNamespace VisitUsedNamespace(UsedNamespace usedNamespace, UsedNamespace changes, UsedNamespace deletions, UsedNamespace insertions)
{
this.UpdateSourceContext(usedNamespace, changes);
if (usedNamespace == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return usedNamespace;
}
public virtual UsedNamespaceList VisitUsedNamespaceList(UsedNamespaceList usedNspaces, UsedNamespaceList changes, UsedNamespaceList deletions, UsedNamespaceList insertions)
{
if (usedNspaces == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return usedNspaces;
}
public virtual Statement VisitWhile(While While, While changes, While deletions, While insertions)
{
this.UpdateSourceContext(While, changes);
if (While == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return While;
}
public virtual Statement VisitYield(Yield Yield, Yield changes, Yield deletions, Yield insertions)
{
this.UpdateSourceContext(Yield, changes);
if (Yield == null) return changes;
if (changes != null)
{
if (deletions == null || insertions == null)
Debug.Assert(false);
else
{
}
}
else if (deletions != null)
return null;
return Yield;
}
#if ExtendedRuntime
// query nodes
public virtual Node VisitQueryAggregate(QueryAggregate qa, QueryAggregate changes, QueryAggregate deletions, QueryAggregate insertions){
this.UpdateSourceContext(qa, changes);
if (qa == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qa;
}
public virtual Node VisitQueryAlias(QueryAlias alias, QueryAlias changes, QueryAlias deletions, QueryAlias insertions){
this.UpdateSourceContext(alias, changes);
if (alias == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return alias;
}
public virtual Node VisitQueryAxis(QueryAxis axis, QueryAxis changes, QueryAxis deletions, QueryAxis insertions){
this.UpdateSourceContext(axis, changes);
if (axis == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return axis;
}
public virtual Node VisitQueryCommit(QueryCommit qc, QueryCommit changes, QueryCommit deletions, QueryCommit insertions){
this.UpdateSourceContext(qc, changes);
if (qc == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qc;
}
public virtual Node VisitQueryContext(QueryContext context, QueryContext changes, QueryContext deletions, QueryContext insertions){
this.UpdateSourceContext(context, changes);
if (context == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return context;
}
public virtual Node VisitQueryDelete(QueryDelete delete, QueryDelete changes, QueryDelete deletions, QueryDelete insertions){
this.UpdateSourceContext(delete, changes);
if (delete == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return delete;
}
public virtual Node VisitQueryDifference(QueryDifference diff, QueryDifference changes, QueryDifference deletions, QueryDifference insertions){
this.UpdateSourceContext(diff, changes);
if (diff == null) return changes;
return diff;
}
public virtual Node VisitQueryDistinct(QueryDistinct distinct, QueryDistinct changes, QueryDistinct deletions, QueryDistinct insertions){
this.UpdateSourceContext(distinct, changes);
if (distinct == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return distinct;
}
public virtual Node VisitQueryExists(QueryExists exists, QueryExists changes, QueryExists deletions, QueryExists insertions){
this.UpdateSourceContext(exists, changes);
if (exists == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return exists;
}
public virtual Node VisitQueryFilter(QueryFilter filter, QueryFilter changes, QueryFilter deletions, QueryFilter insertions){
this.UpdateSourceContext(filter, changes);
if (filter == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return filter;
}
public virtual Node VisitQueryGroupBy(QueryGroupBy groupby, QueryGroupBy changes, QueryGroupBy deletions, QueryGroupBy insertions){
this.UpdateSourceContext(groupby, changes);
if (groupby == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return groupby;
}
public virtual Statement VisitQueryGeneratedType(QueryGeneratedType qgt, QueryGeneratedType changes, QueryGeneratedType deletions, QueryGeneratedType insertions){
this.UpdateSourceContext(qgt, changes);
if (qgt == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qgt;
}
public virtual Node VisitQueryInsert(QueryInsert insert, QueryInsert changes, QueryInsert deletions, QueryInsert insertions){
this.UpdateSourceContext(insert, changes);
if (insert == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return insert;
}
public virtual Node VisitQueryIntersection(QueryIntersection intersection, QueryIntersection changes, QueryIntersection deletions, QueryIntersection insertions){
this.UpdateSourceContext(intersection, changes);
if (intersection == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return intersection;
}
public virtual Node VisitQueryIterator(QueryIterator xiterator, QueryIterator changes, QueryIterator deletions, QueryIterator insertions){
this.UpdateSourceContext(xiterator, changes);
if (xiterator == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return xiterator;
}
public virtual Node VisitQueryJoin(QueryJoin join, QueryJoin changes, QueryJoin deletions, QueryJoin insertions){
this.UpdateSourceContext(join, changes);
if (join == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return join;
}
public virtual Node VisitQueryLimit(QueryLimit limit, QueryLimit changes, QueryLimit deletions, QueryLimit insertions){
this.UpdateSourceContext(limit, changes);
if (limit == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return limit;
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby, QueryOrderBy changes, QueryOrderBy deletions, QueryOrderBy insertions){
this.UpdateSourceContext(orderby, changes);
if (orderby == null) return changes;
return orderby;
}
public virtual Node VisitQueryOrderItem(QueryOrderItem item, QueryOrderItem changes, QueryOrderItem deletions, QueryOrderItem insertions){
this.UpdateSourceContext(item, changes);
if (item == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return item;
}
public virtual Node VisitQueryPosition(QueryPosition position, QueryPosition changes, QueryPosition deletions, QueryPosition insertions){
this.UpdateSourceContext(position, changes);
if (position == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return position;
}
public virtual Node VisitQueryProject(QueryProject project, QueryProject changes, QueryProject deletions, QueryProject insertions){
this.UpdateSourceContext(project, changes);
if (project == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return project;
}
public virtual Node VisitQueryRollback(QueryRollback qr, QueryRollback changes, QueryRollback deletions, QueryRollback insertions){
this.UpdateSourceContext(qr, changes);
if (qr == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qr;
}
public virtual Node VisitQueryQuantifier(QueryQuantifier qq, QueryQuantifier changes, QueryQuantifier deletions, QueryQuantifier insertions){
this.UpdateSourceContext(qq, changes);
if (qq == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qq;
}
public virtual Node VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe, QueryQuantifiedExpression changes, QueryQuantifiedExpression deletions, QueryQuantifiedExpression insertions){
this.UpdateSourceContext(qqe, changes);
if (qqe == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qqe;
}
public virtual Node VisitQuerySelect(QuerySelect select, QuerySelect changes, QuerySelect deletions, QuerySelect insertions){
this.UpdateSourceContext(select, changes);
if (select == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return select;
}
public virtual Node VisitQuerySingleton(QuerySingleton singleton, QuerySingleton changes, QuerySingleton deletions, QuerySingleton insertions){
this.UpdateSourceContext(singleton, changes);
if (singleton == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return singleton;
}
public virtual Node VisitQueryTransact(QueryTransact qt, QueryTransact changes, QueryTransact deletions, QueryTransact insertions){
this.UpdateSourceContext(qt, changes);
if (qt == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return qt;
}
public virtual Node VisitQueryTypeFilter(QueryTypeFilter filter, QueryTypeFilter changes, QueryTypeFilter deletions, QueryTypeFilter insertions){
this.UpdateSourceContext(filter, changes);
if (filter == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return filter;
}
public virtual Node VisitQueryUnion(QueryUnion union, QueryUnion changes, QueryUnion deletions, QueryUnion insertions){
this.UpdateSourceContext(union, changes);
if (union == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return union;
}
public virtual Node VisitQueryUpdate(QueryUpdate update, QueryUpdate changes, QueryUpdate deletions, QueryUpdate insertions){
this.UpdateSourceContext(update, changes);
if (update == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return update;
}
public virtual Node VisitQueryYielder(QueryYielder yielder, QueryYielder changes, QueryYielder deletions, QueryYielder insertions){
this.UpdateSourceContext(yielder, changes);
if (yielder == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return yielder;
}
#endif
}
}
#endif
|