// 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.
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Diagnostics;
#if FxCop
using AttributeListMicrosoft.Cci.AttributeNodeCollection;
using BlockListMicrosoft.Cci.BlockCollection;
using ExpressionListMicrosoft.Cci.ExpressionCollection;
using InterfaceListMicrosoft.Cci.InterfaceCollection;
using MemberListMicrosoft.Cci.MemberCollection;
using NodeListMicrosoft.Cci.NodeCollection;
using ParameterListMicrosoft.Cci.ParameterCollection;
using SecurityAttributeListMicrosoft.Cci.SecurityAttributeCollection;
using StatementListMicrosoft.Cci.StatementCollection;
using TypeNodeListMicrosoft.Cci.TypeNodeCollection;
using PropertyMicrosoft.Cci.PropertyNode;
using ModuleMicrosoft.Cci.ModuleNode;
using ReturnMicrosoft.Cci.ReturnNode;
using ClassMicrosoft.Cci.ClassNode;
using InterfaceMicrosoft.Cci.InterfaceNode;
using EventMicrosoft.Cci.EventNode;
using ThrowMicrosoft.Cci.ThrowNode;
#endif
#if CCINamespace
namespace Microsoft.Cci{
#else
namespace System.Compiler
{
#endif
/// <summary>
/// Base for all classes that process the IR using the visitor pattern.
/// </summary>
#if !FxCop
public
#endif
abstract class Visitor
{
/// <summary>
/// Switches on node.NodeType to call a visitor method that has been specialized for node.
/// </summary>
/// <param name="node">The node to be visited.</param>
/// <returns> Returns null if node is null. Otherwise returns an updated node (possibly a different object).</returns>
public abstract Node Visit(Node node);
#if !MinimalReader
/// <summary>
/// Transfers the state from one visitor to another. This enables separate visitor instances to cooperative process a single IR.
/// </summary>
public virtual void TransferStateTo(Visitor targetVisitor)
{
}
#endif
public virtual ExpressionList VisitExpressionList(ExpressionList list)
{
if (list == null) return null;
for (int i = 0, n = list.Count; i < n; i++)
list[i] = (Expression)this.Visit(list[i]);
return list;
}
}
/// <summary>
/// Walks an IR, mutuating it into a new form
/// </summary>
#if !FxCop
public
#endif
class StandardVisitor : Visitor
{
#if !MinimalReader
public Visitor callingVisitor;
#endif
protected bool memberListNamesChanged;
public StandardVisitor()
{
}
#if !MinimalReader
public StandardVisitor(Visitor callingVisitor)
{
this.callingVisitor = callingVisitor;
}
#endif
public virtual Node VisitUnknownNodeType(Node node)
{
#if !MinimalReader
Visitor 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);
visitor.TransferStateTo(this);
if (this.callingVisitor != null)
//Propagate specialized state (unknown to this visitor) all the way up the chain
visitor.TransferStateTo(this.callingVisitor);
#else
Debug.Assert(false);
#endif
return node;
}
#if !MinimalReader
public virtual Visitor GetVisitorFor(Node node)
{
if (node == null) return null;
return (Visitor)node.GetVisitorFor(this, this.GetType().Name);
}
#endif
public override Node Visit(Node node)
{
if (node == null) return null;
switch (node.NodeType)
{
#if !MinimalReader
case NodeType.Acquire:
return this.VisitAcquire((Acquire)node);
#endif
case NodeType.AddressDereference:
return this.VisitAddressDereference((AddressDereference)node);
#if !MinimalReader
case NodeType.AliasDefinition:
return this.VisitAliasDefinition((AliasDefinition)node);
case NodeType.AnonymousNestedFunction:
return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node);
case NodeType.ApplyToAll:
return this.VisitApplyToAll((ApplyToAll)node);
#endif
case NodeType.Arglist:
return this.VisitExpression((Expression)node);
#if !MinimalReader
case NodeType.ArglistArgumentExpression:
return this.VisitArglistArgumentExpression((ArglistArgumentExpression)node);
case NodeType.ArglistExpression:
return this.VisitArglistExpression((ArglistExpression)node);
#endif
case NodeType.ArrayType:
Debug.Assert(false); return null;
case NodeType.Assembly:
return this.VisitAssembly((AssemblyNode)node);
case NodeType.AssemblyReference:
return this.VisitAssemblyReference((AssemblyReference)node);
#if !MinimalReader
case NodeType.Assertion:
return this.VisitAssertion((Assertion)node);
case NodeType.Assumption:
return this.VisitAssumption((Assumption)node);
case NodeType.AssignmentExpression:
return this.VisitAssignmentExpression((AssignmentExpression)node);
#endif
case NodeType.AssignmentStatement:
return this.VisitAssignmentStatement((AssignmentStatement)node);
case NodeType.Attribute:
return this.VisitAttributeNode((AttributeNode)node);
#if !MinimalReader
case NodeType.Base:
return this.VisitBase((Base)node);
#endif
case NodeType.Block:
return this.VisitBlock((Block)node);
#if !MinimalReader
case NodeType.BlockExpression:
return this.VisitBlockExpression((BlockExpression)node);
#endif
case NodeType.Branch:
return this.VisitBranch((Branch)node);
#if !MinimalReader
case NodeType.Compilation:
return this.VisitCompilation((Compilation)node);
case NodeType.CompilationUnit:
return this.VisitCompilationUnit((CompilationUnit)node);
case NodeType.CompilationUnitSnippet:
return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node);
#endif
#if ExtendedRuntime
case NodeType.ConstrainedType:
return this.VisitConstrainedType((ConstrainedType)node);
#endif
#if !MinimalReader
case NodeType.Continue:
return this.VisitContinue((Continue)node);
case NodeType.CurrentClosure:
return this.VisitCurrentClosure((CurrentClosure)node);
#endif
case NodeType.DebugBreak:
return node;
case NodeType.Call:
case NodeType.Calli:
case NodeType.Callvirt:
case NodeType.Jmp:
#if !MinimalReader
case NodeType.MethodCall:
#endif
return this.VisitMethodCall((MethodCall)node);
#if !MinimalReader
case NodeType.Catch:
return this.VisitCatch((Catch)node);
#endif
case NodeType.Class:
return this.VisitClass((Class)node);
#if !MinimalReader
case NodeType.CoerceTuple:
return this.VisitCoerceTuple((CoerceTuple)node);
case NodeType.CollectionEnumerator:
return this.VisitCollectionEnumerator((CollectionEnumerator)node);
case NodeType.Composition:
return this.VisitComposition((Composition)node);
#endif
case NodeType.Construct:
return this.VisitConstruct((Construct)node);
case NodeType.ConstructArray:
return this.VisitConstructArray((ConstructArray)node);
#if !MinimalReader
case NodeType.ConstructDelegate:
return this.VisitConstructDelegate((ConstructDelegate)node);
case NodeType.ConstructFlexArray:
return this.VisitConstructFlexArray((ConstructFlexArray)node);
case NodeType.ConstructIterator:
return this.VisitConstructIterator((ConstructIterator)node);
case NodeType.ConstructTuple:
return this.VisitConstructTuple((ConstructTuple)node);
#endif
case NodeType.DelegateNode:
return this.VisitDelegateNode((DelegateNode)node);
#if !MinimalReader
case NodeType.DoWhile:
return this.VisitDoWhile((DoWhile)node);
#endif
case NodeType.Dup:
return this.VisitExpression((Expression)node);
case NodeType.EndFilter:
return this.VisitEndFilter((EndFilter)node);
case NodeType.EndFinally:
return this.VisitEndFinally((EndFinally)node);
case NodeType.EnumNode:
return this.VisitEnumNode((EnumNode)node);
case NodeType.Event:
return this.VisitEvent((Event)node);
#if ExtendedRuntime
case NodeType.EnsuresExceptional :
return this.VisitEnsuresExceptional((EnsuresExceptional)node);
#endif
#if !MinimalReader
case NodeType.Exit:
return this.VisitExit((Exit)node);
case NodeType.Read:
case NodeType.Write:
return this.VisitExpose((Expose)node);
case NodeType.ExpressionSnippet:
return this.VisitExpressionSnippet((ExpressionSnippet)node);
#endif
case NodeType.ExpressionStatement:
return this.VisitExpressionStatement((ExpressionStatement)node);
#if !MinimalReader
case NodeType.FaultHandler:
return this.VisitFaultHandler((FaultHandler)node);
#endif
case NodeType.Field:
return this.VisitField((Field)node);
#if !MinimalReader
case NodeType.FieldInitializerBlock:
return this.VisitFieldInitializerBlock((FieldInitializerBlock)node);
case NodeType.Finally:
return this.VisitFinally((Finally)node);
case NodeType.Filter:
return this.VisitFilter((Filter)node);
case NodeType.Fixed:
return this.VisitFixed((Fixed)node);
case NodeType.For:
return this.VisitFor((For)node);
case NodeType.ForEach:
return this.VisitForEach((ForEach)node);
case NodeType.FunctionDeclaration:
return this.VisitFunctionDeclaration((FunctionDeclaration)node);
case NodeType.Goto:
return this.VisitGoto((Goto)node);
case NodeType.GotoCase:
return this.VisitGotoCase((GotoCase)node);
#endif
case NodeType.Identifier:
return this.VisitIdentifier((Identifier)node);
#if !MinimalReader
case NodeType.If:
return this.VisitIf((If)node);
case NodeType.ImplicitThis:
return this.VisitImplicitThis((ImplicitThis)node);
#endif
case NodeType.Indexer:
return this.VisitIndexer((Indexer)node);
case NodeType.InstanceInitializer:
return this.VisitInstanceInitializer((InstanceInitializer)node);
#if ExtendedRuntime
case NodeType.Invariant :
return this.VisitInvariant((Invariant)node);
#endif
case NodeType.StaticInitializer:
return this.VisitStaticInitializer((StaticInitializer)node);
case NodeType.Method:
return this.VisitMethod((Method)node);
#if !MinimalReader
case NodeType.TemplateInstance:
return this.VisitTemplateInstance((TemplateInstance)node);
case NodeType.StackAlloc:
return this.VisitStackAlloc((StackAlloc)node);
#endif
case NodeType.Interface:
return this.VisitInterface((Interface)node);
#if !MinimalReader
case NodeType.LabeledStatement:
return this.VisitLabeledStatement((LabeledStatement)node);
#endif
case NodeType.Literal:
return this.VisitLiteral((Literal)node);
case NodeType.Local:
return this.VisitLocal((Local)node);
#if !MinimalReader
case NodeType.LocalDeclaration:
return this.VisitLocalDeclaration((LocalDeclaration)node);
case NodeType.LocalDeclarationsStatement:
return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node);
case NodeType.Lock:
return this.VisitLock((Lock)node);
case NodeType.LRExpression:
return this.VisitLRExpression((LRExpression)node);
#endif
case NodeType.MemberBinding:
return this.VisitMemberBinding((MemberBinding)node);
#if ExtendedRuntime
case NodeType.MethodContract :
return this.VisitMethodContract((MethodContract)node);
#endif
case NodeType.Module:
return this.VisitModule((Module)node);
case NodeType.ModuleReference:
return this.VisitModuleReference((ModuleReference)node);
#if !MinimalReader
case NodeType.NameBinding:
return this.VisitNameBinding((NameBinding)node);
#endif
case NodeType.NamedArgument:
return this.VisitNamedArgument((NamedArgument)node);
#if !MinimalReader
case NodeType.Namespace:
return this.VisitNamespace((Namespace)node);
#endif
case NodeType.Nop:
#if !MinimalReader
case NodeType.SwitchCaseBottom:
#endif
return node;
#if ExtendedRuntime
case NodeType.EnsuresNormal :
return this.VisitEnsuresNormal((EnsuresNormal)node);
case NodeType.OldExpression :
return this.VisitOldExpression((OldExpression)node);
case NodeType.RequiresOtherwise :
return this.VisitRequiresOtherwise((RequiresOtherwise)node);
case NodeType.RequiresPlain :
return this.VisitRequiresPlain((RequiresPlain)node);
#endif
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
//TODO: type modifers should only be visited via VisitTypeReference
return this.VisitTypeModifier((TypeModifier)node);
case NodeType.Parameter:
return this.VisitParameter((Parameter)node);
case NodeType.Pop:
return this.VisitExpression((Expression)node);
#if !MinimalReader
case NodeType.PrefixExpression:
return this.VisitPrefixExpression((PrefixExpression)node);
case NodeType.PostfixExpression:
return this.VisitPostfixExpression((PostfixExpression)node);
#endif
case NodeType.Property:
return this.VisitProperty((Property)node);
#if !MinimalReader
case NodeType.Quantifier:
return this.VisitQuantifier((Quantifier)node);
case NodeType.Comprehension:
return this.VisitComprehension((Comprehension)node);
case NodeType.ComprehensionBinding:
return this.VisitComprehensionBinding((ComprehensionBinding)node);
case NodeType.QualifiedIdentifer:
return this.VisitQualifiedIdentifier((QualifiedIdentifier)node);
#endif
case NodeType.Rethrow:
case NodeType.Throw:
return this.VisitThrow((Throw)node);
#if !MinimalReader
case NodeType.RefValueExpression:
return this.VisitRefValueExpression((RefValueExpression)node);
case NodeType.RefTypeExpression:
return this.VisitRefTypeExpression((RefTypeExpression)node);
#endif
case NodeType.Return:
return this.VisitReturn((Return)node);
#if !MinimalReader
case NodeType.Repeat:
return this.VisitRepeat((Repeat)node);
case NodeType.ResourceUse:
return this.VisitResourceUse((ResourceUse)node);
#endif
case NodeType.SecurityAttribute:
return this.VisitSecurityAttribute((SecurityAttribute)node);
#if !MinimalReader
case NodeType.SetterValue:
return this.VisitSetterValue((SetterValue)node);
case NodeType.StatementSnippet:
return this.VisitStatementSnippet((StatementSnippet)node);
#endif
case NodeType.Struct:
return this.VisitStruct((Struct)node);
#if !MinimalReader
case NodeType.Switch:
return this.VisitSwitch((Switch)node);
case NodeType.SwitchCase:
return this.VisitSwitchCase((SwitchCase)node);
#endif
case NodeType.SwitchInstruction:
return this.VisitSwitchInstruction((SwitchInstruction)node);
#if !MinimalReader
case NodeType.Typeswitch:
return this.VisitTypeswitch((Typeswitch)node);
case NodeType.TypeswitchCase:
return this.VisitTypeswitchCase((TypeswitchCase)node);
#endif
case NodeType.This:
return this.VisitThis((This)node);
#if !MinimalReader
case NodeType.Try:
return this.VisitTry((Try)node);
#endif
#if ExtendedRuntime
case NodeType.TypeContract:
return this.VisitTypeContract((TypeContract)node);
case NodeType.TupleType:
return this.VisitTupleType((TupleType)node);
case NodeType.TypeAlias:
return this.VisitTypeAlias((TypeAlias)node);
case NodeType.TypeIntersection:
return this.VisitTypeIntersection((TypeIntersection)node);
#endif
#if !MinimalReader
case NodeType.TypeMemberSnippet:
return this.VisitTypeMemberSnippet((TypeMemberSnippet)node);
#endif
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return this.VisitTypeParameter((TypeNode)node);
#if ExtendedRuntime
case NodeType.TypeUnion:
return this.VisitTypeUnion((TypeUnion)node);
#endif
#if !MinimalReader
case NodeType.TypeReference:
return this.VisitTypeReference((TypeReference)node);
case NodeType.UsedNamespace:
return this.VisitUsedNamespace((UsedNamespace)node);
case NodeType.VariableDeclaration:
return this.VisitVariableDeclaration((VariableDeclaration)node);
case NodeType.While:
return this.VisitWhile((While)node);
case NodeType.Yield:
return this.VisitYield((Yield)node);
case NodeType.Conditional:
#endif
case NodeType.Cpblk:
case NodeType.Initblk:
return this.VisitTernaryExpression((TernaryExpression)node);
case NodeType.Add:
case NodeType.Add_Ovf:
case NodeType.Add_Ovf_Un:
#if !MinimalReader
case NodeType.AddEventHandler:
#endif
case NodeType.And:
#if !MinimalReader
case NodeType.As:
#endif
case NodeType.Box:
case NodeType.Castclass:
case NodeType.Ceq:
case NodeType.Cgt:
case NodeType.Cgt_Un:
case NodeType.Clt:
case NodeType.Clt_Un:
#if !MinimalReader
case NodeType.Comma:
#endif
case NodeType.Div:
case NodeType.Div_Un:
case NodeType.Eq:
#if !MinimalReader
case NodeType.ExplicitCoercion:
#endif
case NodeType.Ge:
case NodeType.Gt:
#if !MinimalReader
case NodeType.Is:
case NodeType.Iff:
case NodeType.Implies:
#endif
case NodeType.Isinst:
case NodeType.Ldvirtftn:
case NodeType.Le:
#if !MinimalReader
case NodeType.LogicalAnd:
case NodeType.LogicalOr:
#endif
case NodeType.Lt:
case NodeType.Mkrefany:
#if !MinimalReader
case NodeType.Maplet:
#endif
case NodeType.Mul:
case NodeType.Mul_Ovf:
case NodeType.Mul_Ovf_Un:
case NodeType.Ne:
case NodeType.Or:
#if !MinimalReader
case NodeType.NullCoalesingExpression:
case NodeType.Range:
#endif
case NodeType.Refanyval:
case NodeType.Rem:
case NodeType.Rem_Un:
#if !MinimalReader
case NodeType.RemoveEventHandler:
#endif
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);
case NodeType.AddressOf:
#if !MinimalReader
case NodeType.OutAddress:
case NodeType.RefAddress:
#endif
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:
#if !MinimalReader
case NodeType.Decrement:
case NodeType.DefaultValue:
case NodeType.Increment:
#endif
case NodeType.Ldftn:
case NodeType.Ldlen:
case NodeType.Ldtoken:
case NodeType.Localloc:
case NodeType.LogicalNot:
case NodeType.Neg:
case NodeType.Not:
#if !MinimalReader
case NodeType.Parentheses:
#endif
case NodeType.Refanytype:
case NodeType.ReadOnlyAddressOf:
case NodeType.Sizeof:
case NodeType.SkipCheck:
#if !MinimalReader
case NodeType.Typeof:
case NodeType.UnaryPlus:
#endif
return this.VisitUnaryExpression((UnaryExpression)node);
#if ExtendedRuntime
// query node types
case NodeType.QueryAggregate:
return this.VisitQueryAggregate((QueryAggregate)node);
case NodeType.QueryAlias:
return this.VisitQueryAlias((QueryAlias)node);
case NodeType.QueryAll:
case NodeType.QueryAny:
return this.VisitQueryQuantifier((QueryQuantifier)node);
case NodeType.QueryAxis:
return this.VisitQueryAxis((QueryAxis)node);
case NodeType.QueryCommit:
return this.VisitQueryCommit((QueryCommit)node);
case NodeType.QueryContext:
return this.VisitQueryContext((QueryContext)node);
case NodeType.QueryDelete:
return this.VisitQueryDelete((QueryDelete)node);
case NodeType.QueryDifference:
return this.VisitQueryDifference((QueryDifference)node);
case NodeType.QueryDistinct:
return this.VisitQueryDistinct((QueryDistinct)node);
case NodeType.QueryExists:
return this.VisitQueryExists((QueryExists)node);
case NodeType.QueryFilter:
return this.VisitQueryFilter((QueryFilter)node);
case NodeType.QueryGeneratedType:
return this.VisitQueryGeneratedType((QueryGeneratedType)node);
case NodeType.QueryGroupBy:
return this.VisitQueryGroupBy((QueryGroupBy)node);
case NodeType.QueryInsert:
return this.VisitQueryInsert((QueryInsert)node);
case NodeType.QueryIntersection:
return this.VisitQueryIntersection((QueryIntersection)node);
case NodeType.QueryIterator:
return this.VisitQueryIterator((QueryIterator)node);
case NodeType.QueryJoin:
return this.VisitQueryJoin((QueryJoin)node);
case NodeType.QueryLimit:
return this.VisitQueryLimit((QueryLimit)node);
case NodeType.QueryOrderBy:
return this.VisitQueryOrderBy((QueryOrderBy)node);
case NodeType.QueryOrderItem:
return this.VisitQueryOrderItem((QueryOrderItem)node);
case NodeType.QueryPosition:
return this.VisitQueryPosition((QueryPosition)node);
case NodeType.QueryProject:
return this.VisitQueryProject((QueryProject)node);
case NodeType.QueryQuantifiedExpression:
return this.VisitQueryQuantifiedExpression((QueryQuantifiedExpression)node);
case NodeType.QueryRollback:
return this.VisitQueryRollback((QueryRollback)node);
case NodeType.QuerySelect:
return this.VisitQuerySelect((QuerySelect)node);
case NodeType.QuerySingleton:
return this.VisitQuerySingleton((QuerySingleton)node);
case NodeType.QueryTransact:
return this.VisitQueryTransact((QueryTransact)node);
case NodeType.QueryTypeFilter:
return this.VisitQueryTypeFilter((QueryTypeFilter)node);
case NodeType.QueryUnion:
return this.VisitQueryUnion((QueryUnion)node);
case NodeType.QueryUpdate:
return this.VisitQueryUpdate((QueryUpdate)node);
case NodeType.QueryYielder:
return this.VisitQueryYielder((QueryYielder)node);
#endif
default:
return this.VisitUnknownNodeType(node);
}
}
public virtual Expression VisitAddressDereference(AddressDereference addr)
{
if (addr == null) return null;
addr.Address = this.VisitExpression(addr.Address);
return addr;
}
#if !MinimalReader
public virtual AliasDefinition VisitAliasDefinition(AliasDefinition aliasDefinition)
{
if (aliasDefinition == null) return null;
aliasDefinition.AliasedType = this.VisitTypeReference(aliasDefinition.AliasedType);
return aliasDefinition;
}
public virtual AliasDefinitionList VisitAliasDefinitionList(AliasDefinitionList aliasDefinitions)
{
if (aliasDefinitions == null) return null;
for (int i = 0, n = aliasDefinitions.Count; i < n; i++)
aliasDefinitions[i] = this.VisitAliasDefinition(aliasDefinitions[i]);
return aliasDefinitions;
}
public virtual Expression VisitAnonymousNestedFunction(AnonymousNestedFunction func)
{
if (func == null) return null;
func.Parameters = this.VisitParameterList(func.Parameters);
func.Body = this.VisitBlock(func.Body);
return func;
}
public virtual Expression VisitApplyToAll(ApplyToAll applyToAll)
{
if (applyToAll == null) return null;
applyToAll.Operand1 = this.VisitExpression(applyToAll.Operand1);
applyToAll.Operand2 = this.VisitExpression(applyToAll.Operand2);
return applyToAll;
}
public ArrayType VisitArrayType(ArrayType array)
{
Debug.Assert(false, "An array type exists only at runtime. It should be referred to, but never visited.");
return null;
}
#endif
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly)
{
if (assembly == null) return null;
this.VisitModule(assembly);
assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes);
assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes);
return assembly;
}
public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference)
{
return assemblyReference;
}
#if !MinimalReader
public virtual Statement VisitAssertion(Assertion assertion)
{
if (assertion == null) return null;
assertion.Condition = this.VisitExpression(assertion.Condition);
return assertion;
}
public virtual Statement VisitAssumption(Assumption assumption)
{
if (assumption == null) return null;
assumption.Condition = this.VisitExpression(assumption.Condition);
return assumption;
}
public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment)
{
if (assignment == null) return null;
assignment.AssignmentStatement = (Statement)this.Visit(assignment.AssignmentStatement);
return assignment;
}
#endif
public virtual Statement VisitAssignmentStatement(AssignmentStatement assignment)
{
if (assignment == null) return null;
assignment.Target = this.VisitTargetExpression(assignment.Target);
assignment.Source = this.VisitExpression(assignment.Source);
return assignment;
}
public virtual Expression VisitAttributeConstructor(AttributeNode attribute)
{
if (attribute == null) return null;
return this.VisitExpression(attribute.Constructor);
}
public virtual AttributeNode VisitAttributeNode(AttributeNode attribute)
{
if (attribute == null) return null;
attribute.Constructor = this.VisitAttributeConstructor(attribute);
attribute.Expressions = this.VisitExpressionList(attribute.Expressions);
return attribute;
}
public virtual AttributeList VisitAttributeList(AttributeList attributes)
{
if (attributes == null) return null;
for (int i = 0, n = attributes.Count; i < n; i++)
attributes[i] = this.VisitAttributeNode(attributes[i]);
return attributes;
}
#if !MinimalReader
public virtual Expression VisitBase(Base Base)
{
return Base;
}
#endif
public virtual Expression VisitBinaryExpression(BinaryExpression binaryExpression)
{
if (binaryExpression == null) return null;
binaryExpression.Operand1 = this.VisitExpression(binaryExpression.Operand1);
binaryExpression.Operand2 = this.VisitExpression(binaryExpression.Operand2);
return binaryExpression;
}
public virtual Block VisitBlock(Block block)
{
if (block == null) return null;
block.Statements = this.VisitStatementList(block.Statements);
return block;
}
#if !MinimalReader
public virtual Expression VisitBlockExpression(BlockExpression blockExpression)
{
if (blockExpression == null) return null;
blockExpression.Block = this.VisitBlock(blockExpression.Block);
return blockExpression;
}
#endif
public virtual BlockList VisitBlockList(BlockList blockList)
{
if (blockList == null) return null;
for (int i = 0, n = blockList.Count; i < n; i++)
blockList[i] = this.VisitBlock(blockList[i]);
return blockList;
}
public virtual Statement VisitBranch(Branch branch)
{
if (branch == null) return null;
branch.Condition = this.VisitExpression(branch.Condition);
return branch;
}
#if !MinimalReader
public virtual Statement VisitCatch(Catch Catch)
{
if (Catch == null) return null;
Catch.Variable = this.VisitTargetExpression(Catch.Variable);
Catch.Type = this.VisitTypeReference(Catch.Type);
Catch.Block = this.VisitBlock(Catch.Block);
return Catch;
}
public virtual CatchList VisitCatchList(CatchList catchers)
{
if (catchers == null) return null;
for (int i = 0, n = catchers.Count; i < n; i++)
catchers[i] = (Catch)this.VisitCatch(catchers[i]);
return catchers;
}
#endif
public virtual Class VisitClass(Class Class)
{
return (Class)this.VisitTypeNode(Class);
}
#if !MinimalReader
public virtual Expression VisitCoerceTuple(CoerceTuple coerceTuple)
{
if (coerceTuple == null) return null;
coerceTuple.OriginalTuple = this.VisitExpression(coerceTuple.OriginalTuple);
return this.VisitConstructTuple(coerceTuple);
}
public virtual CollectionEnumerator VisitCollectionEnumerator(CollectionEnumerator ce)
{
if (ce == null) return null;
ce.Collection = this.VisitExpression(ce.Collection);
return ce;
}
public virtual Compilation VisitCompilation(Compilation compilation)
{
if (compilation == null) return null;
Module module = compilation.TargetModule;
if (module != null)
module.Attributes = this.VisitAttributeList(module.Attributes);
AssemblyNode assem = module as AssemblyNode;
if (assem != null)
assem.ModuleAttributes = this.VisitAttributeList(assem.ModuleAttributes);
compilation.CompilationUnits = this.VisitCompilationUnitList(compilation.CompilationUnits);
return compilation;
}
public virtual CompilationUnit VisitCompilationUnit(CompilationUnit cUnit)
{
if (cUnit == null) return null;
cUnit.Nodes = this.VisitNodeList(cUnit.Nodes);
return cUnit;
}
public virtual NodeList VisitNodeList(NodeList nodes)
{
if (nodes == null) return null;
for (int i = 0, n = nodes.Count; i < n; i++)
nodes[i] = this.Visit(nodes[i]);
return nodes;
}
public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList compilationUnits)
{
if (compilationUnits == null) return null;
for (int i = 0, n = compilationUnits.Count; i < n; i++)
compilationUnits[i] = (CompilationUnit)this.Visit(compilationUnits[i]);
return compilationUnits;
}
public virtual CompilationUnit VisitCompilationUnitSnippet(CompilationUnitSnippet snippet)
{
return this.VisitCompilationUnit(snippet);
}
public virtual Node VisitComposition(Composition comp)
{
if (comp == null) return null;
if (comp.GetType() == typeof(Composition))
{
comp.Expression = (Expression)this.Visit(comp.Expression);
return comp;
}
return this.VisitUnknownNodeType(comp);
}
#endif
public virtual Expression VisitConstruct(Construct cons)
{
if (cons == null) return null;
cons.Constructor = this.VisitExpression(cons.Constructor);
cons.Operands = this.VisitExpressionList(cons.Operands);
#if !MinimalReader
cons.Owner = this.VisitExpression(cons.Owner);
#endif
return cons;
}
public virtual Expression VisitConstructArray(ConstructArray consArr)
{
if (consArr == null) return null;
consArr.ElementType = this.VisitTypeReference(consArr.ElementType);
consArr.Operands = this.VisitExpressionList(consArr.Operands);
#if !MinimalReader
consArr.Initializers = this.VisitExpressionList(consArr.Initializers);
consArr.Owner = this.VisitExpression(consArr.Owner);
#endif
return consArr;
}
#if !MinimalReader
public virtual Expression VisitConstructDelegate(ConstructDelegate consDelegate)
{
if (consDelegate == null) return null;
consDelegate.DelegateType = this.VisitTypeReference(consDelegate.DelegateType);
consDelegate.TargetObject = this.VisitExpression(consDelegate.TargetObject);
return consDelegate;
}
public virtual Expression VisitConstructFlexArray(ConstructFlexArray consArr)
{
if (consArr == null) return null;
consArr.ElementType = this.VisitTypeReference(consArr.ElementType);
consArr.Operands = this.VisitExpressionList(consArr.Operands);
consArr.Initializers = this.VisitExpressionList(consArr.Initializers);
return consArr;
}
public virtual Expression VisitConstructIterator(ConstructIterator consIterator)
{
return consIterator;
}
public virtual Expression VisitConstructTuple(ConstructTuple consTuple)
{
if (consTuple == null) return null;
consTuple.Fields = this.VisitFieldList(consTuple.Fields);
return consTuple;
}
#endif
#if ExtendedRuntime
public virtual TypeNode VisitConstrainedType(ConstrainedType cType){
if (cType == null) return null;
cType.UnderlyingType = this.VisitTypeReference(cType.UnderlyingType);
cType.Constraint = this.VisitExpression(cType.Constraint);
return cType;
}
#endif
#if !MinimalReader
public virtual Statement VisitContinue(Continue Continue)
{
return Continue;
}
public virtual Expression VisitCurrentClosure(CurrentClosure currentClosure)
{
return currentClosure;
}
#endif
public virtual DelegateNode VisitDelegateNode(DelegateNode delegateNode)
{
if (delegateNode == null) return null;
delegateNode = (DelegateNode)this.VisitTypeNode(delegateNode);
if (delegateNode == null) return null;
delegateNode.Parameters = this.VisitParameterList(delegateNode.Parameters);
delegateNode.ReturnType = this.VisitTypeReference(delegateNode.ReturnType);
return delegateNode;
}
#if !MinimalReader
public virtual Statement VisitDoWhile(DoWhile doWhile)
{
if (doWhile == null) return null;
doWhile.Invariants = this.VisitLoopInvariantList(doWhile.Invariants);
doWhile.Body = this.VisitBlock(doWhile.Body);
doWhile.Condition = this.VisitExpression(doWhile.Condition);
return doWhile;
}
#endif
public virtual Statement VisitEndFilter(EndFilter endFilter)
{
if (endFilter == null) return null;
endFilter.Value = this.VisitExpression(endFilter.Value);
return endFilter;
}
public virtual Statement VisitEndFinally(EndFinally endFinally)
{
return endFinally;
}
#if ExtendedRuntime
public virtual EnsuresList VisitEnsuresList(EnsuresList Ensures) {
if (Ensures == null) return null;
for (int i = 0, n = Ensures.Count; i < n; i++)
Ensures[i] = (Ensures) this.Visit(Ensures[i]);
return Ensures;
}
#endif
public virtual EnumNode VisitEnumNode(EnumNode enumNode)
{
return (EnumNode)this.VisitTypeNode(enumNode);
}
public virtual Event VisitEvent(Event evnt)
{
if (evnt == null) return null;
evnt.Attributes = this.VisitAttributeList(evnt.Attributes);
evnt.HandlerType = this.VisitTypeReference(evnt.HandlerType);
return evnt;
}
#if ExtendedRuntime
public virtual EnsuresExceptional VisitEnsuresExceptional(EnsuresExceptional exceptional) {
if (exceptional == null) return null;
exceptional.PostCondition = this.VisitExpression(exceptional.PostCondition);
exceptional.Type = this.VisitTypeReference(exceptional.Type);
exceptional.Variable = this.VisitExpression(exceptional.Variable);
return exceptional;
}
#endif
#if !MinimalReader
public virtual Statement VisitExit(Exit exit)
{
return exit;
}
public virtual Statement VisitExpose(Expose @expose)
{
if (@expose == null) return null;
@expose.Instance = this.VisitExpression(@expose.Instance);
@expose.Body = this.VisitBlock(expose.Body);
return expose;
}
#endif
public virtual Expression VisitExpression(Expression expression)
{
if (expression == null) return null;
switch (expression.NodeType)
{
case NodeType.Dup:
case NodeType.Arglist:
return expression;
case NodeType.Pop:
UnaryExpression uex = expression as UnaryExpression;
if (uex != null)
{
uex.Operand = this.VisitExpression(uex.Operand);
return uex;
}
return expression;
default:
return (Expression)this.Visit(expression);
}
}
public override ExpressionList VisitExpressionList(ExpressionList expressions)
{
if (expressions == null) return null;
for (int i = 0, n = expressions.Count; i < n; i++)
expressions[i] = this.VisitExpression(expressions[i]);
return expressions;
}
#if !MinimalReader
public virtual Expression VisitExpressionSnippet(ExpressionSnippet snippet)
{
return snippet;
}
#endif
public virtual Statement VisitExpressionStatement(ExpressionStatement statement)
{
if (statement == null) return null;
statement.Expression = this.VisitExpression(statement.Expression);
return statement;
}
#if !MinimalReader
public virtual Statement VisitFaultHandler(FaultHandler faultHandler)
{
if (faultHandler == null) return null;
faultHandler.Block = this.VisitBlock(faultHandler.Block);
return faultHandler;
}
public virtual FaultHandlerList VisitFaultHandlerList(FaultHandlerList faultHandlers)
{
if (faultHandlers == null) return null;
for (int i = 0, n = faultHandlers.Count; i < n; i++)
faultHandlers[i] = (FaultHandler)this.VisitFaultHandler(faultHandlers[i]);
return faultHandlers;
}
#endif
public virtual Field VisitField(Field field)
{
if (field == null) return null;
field.Attributes = this.VisitAttributeList(field.Attributes);
field.Type = this.VisitTypeReference(field.Type);
#if !MinimalReader
field.Initializer = this.VisitExpression(field.Initializer);
field.ImplementedInterfaces = this.VisitInterfaceReferenceList(field.ImplementedInterfaces);
#endif
return field;
}
#if !MinimalReader
public virtual Block VisitFieldInitializerBlock(FieldInitializerBlock block)
{
if (block == null) return null;
block.Type = this.VisitTypeReference(block.Type);
return this.VisitBlock(block);
}
public virtual FieldList VisitFieldList(FieldList fields)
{
if (fields == null) return null;
for (int i = 0, n = fields.Count; i < n; i++)
fields[i] = this.VisitField(fields[i]);
return fields;
}
public virtual Statement VisitFilter(Filter filter)
{
if (filter == null) return null;
filter.Expression = this.VisitExpression(filter.Expression);
filter.Block = this.VisitBlock(filter.Block);
return filter;
}
public virtual FilterList VisitFilterList(FilterList filters)
{
if (filters == null) return null;
for (int i = 0, n = filters.Count; i < n; i++)
filters[i] = (Filter)this.VisitFilter(filters[i]);
return filters;
}
public virtual Statement VisitFinally(Finally Finally)
{
if (Finally == null) return null;
Finally.Block = this.VisitBlock(Finally.Block);
return Finally;
}
public virtual Statement VisitFixed(Fixed Fixed)
{
if (Fixed == null) return null;
Fixed.Declarators = (Statement)this.Visit(Fixed.Declarators);
Fixed.Body = this.VisitBlock(Fixed.Body);
return Fixed;
}
public virtual Statement VisitFor(For For)
{
if (For == null) return null;
For.Initializer = this.VisitStatementList(For.Initializer);
For.Invariants = this.VisitLoopInvariantList(For.Invariants);
For.Condition = this.VisitExpression(For.Condition);
For.Incrementer = this.VisitStatementList(For.Incrementer);
For.Body = this.VisitBlock(For.Body);
return For;
}
public virtual Statement VisitForEach(ForEach forEach)
{
if (forEach == null) return null;
forEach.TargetVariableType = this.VisitTypeReference(forEach.TargetVariableType);
forEach.TargetVariable = this.VisitTargetExpression(forEach.TargetVariable);
forEach.SourceEnumerable = this.VisitExpression(forEach.SourceEnumerable);
forEach.InductionVariable = this.VisitTargetExpression(forEach.InductionVariable);
forEach.Invariants = this.VisitLoopInvariantList(forEach.Invariants);
forEach.Body = this.VisitBlock(forEach.Body);
return forEach;
}
public virtual Statement VisitFunctionDeclaration(FunctionDeclaration functionDeclaration)
{
if (functionDeclaration == null) return null;
functionDeclaration.Parameters = this.VisitParameterList(functionDeclaration.Parameters);
functionDeclaration.ReturnType = this.VisitTypeReference(functionDeclaration.ReturnType);
functionDeclaration.Body = this.VisitBlock(functionDeclaration.Body);
return functionDeclaration;
}
public virtual Expression VisitTemplateInstance(TemplateInstance templateInstance)
{
if (templateInstance == null) return null;
templateInstance.Expression = this.VisitExpression(templateInstance.Expression);
templateInstance.TypeArguments = this.VisitTypeReferenceList(templateInstance.TypeArguments);
return templateInstance;
}
public virtual Expression VisitStackAlloc(StackAlloc alloc)
{
if (alloc == null) return null;
alloc.ElementType = this.VisitTypeReference(alloc.ElementType);
alloc.NumberOfElements = this.VisitExpression(alloc.NumberOfElements);
return alloc;
}
public virtual Statement VisitGoto(Goto Goto)
{
return Goto;
}
public virtual Statement VisitGotoCase(GotoCase gotoCase)
{
if (gotoCase == null) return null;
gotoCase.CaseLabel = this.VisitExpression(gotoCase.CaseLabel);
return gotoCase;
}
#endif
public virtual Expression VisitIdentifier(Identifier identifier)
{
return identifier;
}
#if !MinimalReader
public virtual Statement VisitIf(If If)
{
if (If == null) return null;
If.Condition = this.VisitExpression(If.Condition);
If.TrueBlock = this.VisitBlock(If.TrueBlock);
If.FalseBlock = this.VisitBlock(If.FalseBlock);
return If;
}
public virtual Expression VisitImplicitThis(ImplicitThis implicitThis)
{
return implicitThis;
}
#endif
public virtual Expression VisitIndexer(Indexer indexer)
{
if (indexer == null) return null;
indexer.Object = this.VisitExpression(indexer.Object);
indexer.Operands = this.VisitExpressionList(indexer.Operands);
return indexer;
}
public virtual Interface VisitInterface(Interface Interface)
{
return (Interface)this.VisitTypeNode(Interface);
}
public virtual Interface VisitInterfaceReference(Interface Interface)
{
return (Interface)this.VisitTypeReference(Interface);
}
public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaceReferences)
{
if (interfaceReferences == null) return null;
for (int i = 0, n = interfaceReferences.Count; i < n; i++)
interfaceReferences[i] = this.VisitInterfaceReference(interfaceReferences[i]);
return interfaceReferences;
}
#if ExtendedRuntime
public virtual Invariant VisitInvariant(Invariant @invariant){
if (@invariant == null) return null;
@invariant.Condition = VisitExpression(@invariant.Condition);
return @invariant;
}
public virtual InvariantList VisitInvariantList(InvariantList invariants){
if (invariants == null) return null;
for (int i = 0, n = invariants.Count; i < n; i++)
invariants[i] = this.VisitInvariant(invariants[i]);
return invariants;
}
public virtual ModelfieldContract VisitModelfieldContract(ModelfieldContract mfC) {
if (mfC == null) return null;
mfC.Witness = this.VisitExpression(mfC.Witness);
for (int i = 0, n = mfC.SatisfiesList.Count; i < n; i++)
mfC.SatisfiesList[i] = this.VisitExpression(mfC.SatisfiesList[i]);
return mfC;
}
public virtual ModelfieldContractList VisitModelfieldContractList(ModelfieldContractList mfCs) {
if (mfCs == null) return null;
for (int i = 0, n = mfCs.Count; i < n; i++)
mfCs[i] = this.VisitModelfieldContract(mfCs[i]);
return mfCs;
}
#endif
public virtual InstanceInitializer VisitInstanceInitializer(InstanceInitializer cons)
{
return (InstanceInitializer)this.VisitMethod(cons);
}
#if !MinimalReader
public virtual Statement VisitLabeledStatement(LabeledStatement lStatement)
{
if (lStatement == null) return null;
lStatement.Statement = (Statement)this.Visit(lStatement.Statement);
return lStatement;
}
#endif
public virtual Expression VisitLiteral(Literal literal)
{
return literal;
}
public virtual Expression VisitLocal(Local local)
{
if (local == null) return null;
local.Type = this.VisitTypeReference(local.Type);
#if !MinimalReader
LocalBinding lb = local as LocalBinding;
if (lb != null)
{
Local loc = this.VisitLocal(lb.BoundLocal) as Local;
if (loc != null)
lb.BoundLocal = loc;
}
#endif
return local;
}
#if !MinimalReader
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations)
{
if (localDeclarations == null) return null;
localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type);
localDeclarations.Declarations = this.VisitLocalDeclarationList(localDeclarations.Declarations);
return localDeclarations;
}
public virtual LocalDeclarationList VisitLocalDeclarationList(LocalDeclarationList localDeclarations)
{
if (localDeclarations == null) return null;
for (int i = 0, n = localDeclarations.Count; i < n; i++)
localDeclarations[i] = this.VisitLocalDeclaration(localDeclarations[i]);
return localDeclarations;
}
public virtual LocalDeclaration VisitLocalDeclaration(LocalDeclaration localDeclaration)
{
if (localDeclaration == null) return null;
localDeclaration.InitialValue = this.VisitExpression(localDeclaration.InitialValue);
return localDeclaration;
}
public virtual Statement VisitLock(Lock Lock)
{
if (Lock == null) return null;
Lock.Guard = this.VisitExpression(Lock.Guard);
Lock.Body = this.VisitBlock(Lock.Body);
return Lock;
}
public virtual Expression VisitLRExpression(LRExpression expr)
{
if (expr == null) return null;
expr.Expression = this.VisitExpression(expr.Expression);
return expr;
}
#endif
public virtual Expression VisitMemberBinding(MemberBinding memberBinding)
{
if (memberBinding == null) return null;
memberBinding.TargetObject = this.VisitExpression(memberBinding.TargetObject);
return memberBinding;
}
public virtual MemberList VisitMemberList(MemberList members)
{
this.memberListNamesChanged = false;
if (members == null) return null;
for (int i = 0, n = members.Count; i < n; i++)
{
Member oldm = members[i];
if (oldm != null)
{
Identifier oldId = oldm.Name;
members[i] = (Member)this.Visit(oldm);
if (members[i] != null)
{
if (oldId != null && members[i].Name != null && members[i].Name.UniqueIdKey != oldId.UniqueIdKey)
{
this.memberListNamesChanged = true;
}
}
}
}
return members;
}
public virtual Method VisitMethod(Method method)
{
if (method == null) return null;
method.Attributes = this.VisitAttributeList(method.Attributes);
method.ReturnAttributes = this.VisitAttributeList(method.ReturnAttributes);
method.SecurityAttributes = this.VisitSecurityAttributeList(method.SecurityAttributes);
method.ReturnType = this.VisitTypeReference(method.ReturnType);
#if !MinimalReader
method.ImplementedTypes = this.VisitTypeReferenceList(method.ImplementedTypes);
#endif
method.Parameters = this.VisitParameterList(method.Parameters);
if (TargetPlatform.UseGenerics)
{
method.TemplateArguments = this.VisitTypeReferenceList(method.TemplateArguments);
method.TemplateParameters = this.VisitTypeParameterList(method.TemplateParameters);
}
#if ExtendedRuntime
method.Contract = this.VisitMethodContract(method.Contract);
#endif
method.Body = this.VisitBlock(method.Body);
return method;
}
public virtual Expression VisitMethodCall(MethodCall call)
{
if (call == null) return null;
call.Callee = this.VisitExpression(call.Callee);
call.Operands = this.VisitExpressionList(call.Operands);
call.Constraint = this.VisitTypeReference(call.Constraint);
return call;
}
#if !MinimalReader
public virtual Expression VisitArglistArgumentExpression(ArglistArgumentExpression argexp)
{
if (argexp == null) return null;
argexp.Operands = this.VisitExpressionList(argexp.Operands);
return argexp;
}
public virtual Expression VisitArglistExpression(ArglistExpression argexp)
{
if (argexp == null) return null;
return argexp;
}
#endif
#if ExtendedRuntime
public virtual MethodContract VisitMethodContract(MethodContract contract){
if (contract == null) return null;
// don't visit contract.DeclaringMethod
// don't visit contract.OverriddenMethods
contract.Requires = this.VisitRequiresList(contract.Requires);
contract.Ensures = this.VisitEnsuresList(contract.Ensures);
contract.Modifies = this.VisitExpressionList(contract.Modifies);
return contract;
}
#endif
public virtual Module VisitModule(Module module)
{
if (module == null) return null;
module.Attributes = this.VisitAttributeList(module.Attributes);
module.Types = this.VisitTypeNodeList(module.Types);
return module;
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference)
{
return moduleReference;
}
#if !MinimalReader
public virtual Expression VisitNameBinding(NameBinding nameBinding)
{
return nameBinding;
}
#endif
public virtual Expression VisitNamedArgument(NamedArgument namedArgument)
{
if (namedArgument == null) return null;
namedArgument.Value = this.VisitExpression(namedArgument.Value);
return namedArgument;
}
#if !MinimalReader
public virtual Namespace VisitNamespace(Namespace nspace)
{
if (nspace == null) return null;
nspace.AliasDefinitions = this.VisitAliasDefinitionList(nspace.AliasDefinitions);
nspace.UsedNamespaces = this.VisitUsedNamespaceList(nspace.UsedNamespaces);
nspace.Attributes = this.VisitAttributeList(nspace.Attributes);
nspace.Types = this.VisitTypeNodeList(nspace.Types);
nspace.NestedNamespaces = this.VisitNamespaceList(nspace.NestedNamespaces);
return nspace;
}
public virtual NamespaceList VisitNamespaceList(NamespaceList namespaces)
{
if (namespaces == null) return null;
for (int i = 0, n = namespaces.Count; i < n; i++)
namespaces[i] = this.VisitNamespace(namespaces[i]);
return namespaces;
}
#endif
#if ExtendedRuntime
public virtual EnsuresNormal VisitEnsuresNormal(EnsuresNormal normal) {
if (normal == null) return null;
normal.PostCondition = this.VisitExpression(normal.PostCondition);
return normal;
}
public virtual Expression VisitOldExpression(OldExpression oldExpression) {
if (oldExpression == null) return null;
oldExpression.expression = this.VisitExpression(oldExpression.expression);
return oldExpression;
}
public virtual RequiresOtherwise VisitRequiresOtherwise(RequiresOtherwise otherwise) {
if (otherwise == null) return null;
otherwise.Condition = this.VisitExpression(otherwise.Condition);
otherwise.ThrowException = this.VisitExpression(otherwise.ThrowException);
return otherwise;
}
public virtual RequiresPlain VisitRequiresPlain(RequiresPlain plain) {
if (plain == null) return null;
plain.Condition = this.VisitExpression(plain.Condition);
return plain;
}
#endif
public virtual Expression VisitParameter(Parameter parameter)
{
if (parameter == null) return null;
parameter.Attributes = this.VisitAttributeList(parameter.Attributes);
parameter.Type = this.VisitTypeReference(parameter.Type);
parameter.DefaultValue = this.VisitExpression(parameter.DefaultValue);
#if !MinimalReader
ParameterBinding pb = parameter as ParameterBinding;
if (pb != null)
{
Parameter par = this.VisitParameter(pb.BoundParameter) as Parameter;
if (par != null)
pb.BoundParameter = par;
}
#endif
return parameter;
}
public virtual ParameterList VisitParameterList(ParameterList parameterList)
{
if (parameterList == null) return null;
for (int i = 0, n = parameterList.Count; i < n; i++)
parameterList[i] = (Parameter)this.VisitParameter(parameterList[i]);
return parameterList;
}
#if !MinimalReader
public virtual Expression VisitPrefixExpression(PrefixExpression pExpr)
{
if (pExpr == null) return null;
pExpr.Expression = this.VisitExpression(pExpr.Expression);
return pExpr;
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr)
{
if (pExpr == null) return null;
pExpr.Expression = this.VisitExpression(pExpr.Expression);
return pExpr;
}
#endif
public virtual Property VisitProperty(Property property)
{
if (property == null) return null;
property.Attributes = this.VisitAttributeList(property.Attributes);
property.Parameters = this.VisitParameterList(property.Parameters);
property.Type = this.VisitTypeReference(property.Type);
return property;
}
#if !MinimalReader
public virtual Expression VisitQuantifier(Quantifier quantifier)
{
if (quantifier == null) return null;
quantifier.Comprehension = (Comprehension)this.VisitComprehension(quantifier.Comprehension);
return quantifier;
}
public virtual Expression VisitComprehension(Comprehension comprehension)
{
if (comprehension == null) return null;
comprehension.BindingsAndFilters = this.VisitExpressionList(comprehension.BindingsAndFilters);
comprehension.Elements = this.VisitExpressionList(comprehension.Elements);
return comprehension;
}
public virtual ComprehensionBinding VisitComprehensionBinding(ComprehensionBinding comprehensionBinding)
{
if (comprehensionBinding == null) return null;
comprehensionBinding.TargetVariableType = this.VisitTypeReference(comprehensionBinding.TargetVariableType);
comprehensionBinding.TargetVariable = this.VisitTargetExpression(comprehensionBinding.TargetVariable);
comprehensionBinding.AsTargetVariableType = this.VisitTypeReference(comprehensionBinding.AsTargetVariableType);
comprehensionBinding.SourceEnumerable = this.VisitExpression(comprehensionBinding.SourceEnumerable);
return comprehensionBinding;
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier)
{
if (qualifiedIdentifier == null) return null;
qualifiedIdentifier.Qualifier = this.VisitExpression(qualifiedIdentifier.Qualifier);
return qualifiedIdentifier;
}
public virtual Expression VisitRefValueExpression(RefValueExpression refvalexp)
{
if (refvalexp == null) return null;
refvalexp.Operand1 = this.VisitExpression(refvalexp.Operand1);
refvalexp.Operand2 = this.VisitExpression(refvalexp.Operand2);
return refvalexp;
}
public virtual Expression VisitRefTypeExpression(RefTypeExpression reftypexp)
{
if (reftypexp == null) return null;
reftypexp.Operand = this.VisitExpression(reftypexp.Operand);
return reftypexp;
}
public virtual Statement VisitRepeat(Repeat repeat)
{
if (repeat == null) return null;
repeat.Body = this.VisitBlock(repeat.Body);
repeat.Condition = this.VisitExpression(repeat.Condition);
return repeat;
}
#endif
#if ExtendedRuntime
public virtual RequiresList VisitRequiresList(RequiresList Requires) {
if (Requires == null) return null;
for (int i = 0, n = Requires.Count; i < n; i++)
Requires[i] = (Requires) this.Visit(Requires[i]);
return Requires;
}
#endif
public virtual Statement VisitReturn(Return Return)
{
if (Return == null) return null;
Return.Expression = this.VisitExpression(Return.Expression);
return Return;
}
#if !MinimalReader
public virtual Statement VisitAcquire(Acquire @acquire)
{
if (@acquire == null) return null;
@acquire.Target = (Statement)this.Visit(@acquire.Target);
@acquire.Condition = this.VisitExpression(@acquire.Condition);
@acquire.ConditionFunction = this.VisitExpression(@acquire.ConditionFunction);
@acquire.Body = this.VisitBlock(@acquire.Body);
return @acquire;
}
public virtual Statement VisitResourceUse(ResourceUse resourceUse)
{
if (resourceUse == null) return null;
resourceUse.ResourceAcquisition = (Statement)this.Visit(resourceUse.ResourceAcquisition);
resourceUse.Body = this.VisitBlock(resourceUse.Body);
return resourceUse;
}
#endif
public virtual SecurityAttribute VisitSecurityAttribute(SecurityAttribute attribute)
{
return attribute;
}
public virtual SecurityAttributeList VisitSecurityAttributeList(SecurityAttributeList attributes)
{
if (attributes == null) return null;
for (int i = 0, n = attributes.Count; i < n; i++)
attributes[i] = this.VisitSecurityAttribute(attributes[i]);
return attributes;
}
#if !MinimalReader
public virtual Expression VisitSetterValue(SetterValue value)
{
return value;
}
#endif
public virtual StatementList VisitStatementList(StatementList statements)
{
if (statements == null) return null;
for (int i = 0, n = statements.Count; i < n; i++)
statements[i] = (Statement)this.Visit(statements[i]);
return statements;
}
#if !MinimalReader
public virtual StatementSnippet VisitStatementSnippet(StatementSnippet snippet)
{
return snippet;
}
#endif
public virtual StaticInitializer VisitStaticInitializer(StaticInitializer cons)
{
return (StaticInitializer)this.VisitMethod(cons);
}
public virtual Struct VisitStruct(Struct Struct)
{
return (Struct)this.VisitTypeNode(Struct);
}
#if !MinimalReader
public virtual Statement VisitSwitch(Switch Switch)
{
if (Switch == null) return null;
Switch.Expression = this.VisitExpression(Switch.Expression);
Switch.Cases = this.VisitSwitchCaseList(Switch.Cases);
return Switch;
}
public virtual SwitchCase VisitSwitchCase(SwitchCase switchCase)
{
if (switchCase == null) return null;
switchCase.Label = this.VisitExpression(switchCase.Label);
switchCase.Body = this.VisitBlock(switchCase.Body);
return switchCase;
}
public virtual SwitchCaseList VisitSwitchCaseList(SwitchCaseList switchCases)
{
if (switchCases == null) return null;
for (int i = 0, n = switchCases.Count; i < n; i++)
switchCases[i] = this.Visit(switchCases[i]) as SwitchCase;
return switchCases;
}
#endif
public virtual Statement VisitSwitchInstruction(SwitchInstruction switchInstruction)
{
if (switchInstruction == null) return null;
switchInstruction.Expression = this.VisitExpression(switchInstruction.Expression);
return switchInstruction;
}
#if !MinimalReader
public virtual Statement VisitTypeswitch(Typeswitch Typeswitch)
{
if (Typeswitch == null) return null;
Typeswitch.Expression = this.VisitExpression(Typeswitch.Expression);
Typeswitch.Cases = this.VisitTypeswitchCaseList(Typeswitch.Cases);
return Typeswitch;
}
public virtual TypeswitchCase VisitTypeswitchCase(TypeswitchCase typeswitchCase)
{
if (typeswitchCase == null) return null;
typeswitchCase.LabelType = this.VisitTypeReference(typeswitchCase.LabelType);
typeswitchCase.LabelVariable = this.VisitTargetExpression(typeswitchCase.LabelVariable);
typeswitchCase.Body = this.VisitBlock(typeswitchCase.Body);
return typeswitchCase;
}
public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases)
{
if (typeswitchCases == null) return null;
for (int i = 0, n = typeswitchCases.Count; i < n; i++)
typeswitchCases[i] = this.VisitTypeswitchCase(typeswitchCases[i]);
return typeswitchCases;
}
#endif
public virtual Expression VisitTargetExpression(Expression expression)
{
return this.VisitExpression(expression);
}
public virtual Expression VisitTernaryExpression(TernaryExpression expression)
{
if (expression == null) return null;
expression.Operand1 = this.VisitExpression(expression.Operand1);
expression.Operand2 = this.VisitExpression(expression.Operand2);
expression.Operand3 = this.VisitExpression(expression.Operand3);
return expression;
}
public virtual Expression VisitThis(This This)
{
if (This == null) return null;
This.Type = this.VisitTypeReference(This.Type);
#if !MinimalReader
ThisBinding tb = This as ThisBinding;
if (tb != null)
{
This boundThis = this.VisitThis(tb.BoundThis) as This;
if (boundThis != null)
tb.BoundThis = boundThis;
}
#endif
return This;
}
public virtual Statement VisitThrow(Throw Throw)
{
if (Throw == null) return null;
Throw.Expression = this.VisitExpression(Throw.Expression);
return Throw;
}
#if !MinimalReader
public virtual Statement VisitTry(Try Try)
{
if (Try == null) return null;
Try.TryBlock = this.VisitBlock(Try.TryBlock);
Try.Catchers = this.VisitCatchList(Try.Catchers);
Try.Filters = this.VisitFilterList(Try.Filters);
Try.FaultHandlers = this.VisitFaultHandlerList(Try.FaultHandlers);
Try.Finally = (Finally)this.VisitFinally(Try.Finally);
return Try;
}
#endif
#if ExtendedRuntime
public virtual TupleType VisitTupleType(TupleType tuple){
return (TupleType)this.VisitTypeNode(tuple);
}
public virtual TypeAlias VisitTypeAlias(TypeAlias tAlias){
if (tAlias == null) return null;
if (tAlias.AliasedType is ConstrainedType)
//The type alias defines the constrained type, rather than just referencing it
tAlias.AliasedType = this.VisitConstrainedType((ConstrainedType)tAlias.AliasedType);
else
tAlias.AliasedType = this.VisitTypeReference(tAlias.AliasedType);
return tAlias;
}
public virtual TypeContract VisitTypeContract(TypeContract contract){
if (contract == null) return null;
// don't visit contract.DeclaringType
// don't visit contract.InheritedContracts
contract.Invariants = this.VisitInvariantList(contract.Invariants);
contract.ModelfieldContracts = this.VisitModelfieldContractList(contract.ModelfieldContracts);
return contract;
}
public virtual TypeIntersection VisitTypeIntersection(TypeIntersection typeIntersection){
return (TypeIntersection)this.VisitTypeNode(typeIntersection);
}
#endif
#if !MinimalReader
public virtual TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet)
{
return snippet;
}
#endif
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier)
{
if (typeModifier == null) return null;
typeModifier.Modifier = this.VisitTypeReference(typeModifier.Modifier);
typeModifier.ModifiedType = this.VisitTypeReference(typeModifier.ModifiedType);
return typeModifier;
}
public virtual TypeNode VisitTypeNode(TypeNode typeNode)
{
if (typeNode == null) return null;
typeNode.Attributes = this.VisitAttributeList(typeNode.Attributes);
typeNode.SecurityAttributes = this.VisitSecurityAttributeList(typeNode.SecurityAttributes);
Class c = typeNode as Class;
if (c != null) c.BaseClass = (Class)this.VisitTypeReference(c.BaseClass);
typeNode.Interfaces = this.VisitInterfaceReferenceList(typeNode.Interfaces);
typeNode.TemplateArguments = this.VisitTypeReferenceList(typeNode.TemplateArguments);
typeNode.TemplateParameters = this.VisitTypeParameterList(typeNode.TemplateParameters);
this.VisitMemberList(typeNode.Members);
if (this.memberListNamesChanged) { typeNode.ClearMemberTable(); }
#if ExtendedRuntime
// have to visit this *after* visiting the members since in Normalizer
// it creates normalized method bodies for the invariant methods and
// those shouldn't be visited again!!
// REVIEW!! I don't think the method bodies created in Normalizer are necessarily normalized anymore!!
typeNode.Contract = this.VisitTypeContract(typeNode.Contract);
#endif
return typeNode;
}
public virtual TypeNodeList VisitTypeNodeList(TypeNodeList types)
{
if (types == null) return null;
for (int i = 0; i < types.Count; i++) //Visiting a type may result in a new type being appended to this list
types[i] = (TypeNode)this.Visit(types[i]);
return types;
}
public virtual TypeNode VisitTypeParameter(TypeNode typeParameter)
{
if (typeParameter == null) return null;
Class cl = typeParameter as Class;
if (cl != null) cl.BaseClass = (Class)this.VisitTypeReference(cl.BaseClass);
typeParameter.Attributes = this.VisitAttributeList(typeParameter.Attributes);
typeParameter.Interfaces = this.VisitInterfaceReferenceList(typeParameter.Interfaces);
return typeParameter;
}
public virtual TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters)
{
if (typeParameters == null) return null;
for (int i = 0, n = typeParameters.Count; i < n; i++)
typeParameters[i] = this.VisitTypeParameter(typeParameters[i]);
return typeParameters;
}
public virtual TypeNode VisitTypeReference(TypeNode type)
{
return type;
}
#if !MinimalReader
public virtual TypeReference VisitTypeReference(TypeReference type)
{
return type;
}
#endif
public virtual TypeNodeList VisitTypeReferenceList(TypeNodeList typeReferences)
{
if (typeReferences == null) return null;
for (int i = 0, n = typeReferences.Count; i < n; i++)
typeReferences[i] = this.VisitTypeReference(typeReferences[i]);
return typeReferences;
}
#if ExtendedRuntime
public virtual TypeUnion VisitTypeUnion(TypeUnion typeUnion){
return (TypeUnion)this.VisitTypeNode(typeUnion);
}
#endif
public virtual Expression VisitUnaryExpression(UnaryExpression unaryExpression)
{
if (unaryExpression == null) return null;
unaryExpression.Operand = this.VisitExpression(unaryExpression.Operand);
return unaryExpression;
}
#if !MinimalReader
public virtual Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration)
{
if (variableDeclaration == null) return null;
variableDeclaration.Type = this.VisitTypeReference(variableDeclaration.Type);
variableDeclaration.Initializer = this.VisitExpression(variableDeclaration.Initializer);
return variableDeclaration;
}
public virtual UsedNamespace VisitUsedNamespace(UsedNamespace usedNamespace)
{
return usedNamespace;
}
public virtual UsedNamespaceList VisitUsedNamespaceList(UsedNamespaceList usedNspaces)
{
if (usedNspaces == null) return null;
for (int i = 0, n = usedNspaces.Count; i < n; i++)
usedNspaces[i] = this.VisitUsedNamespace(usedNspaces[i]);
return usedNspaces;
}
public virtual ExpressionList VisitLoopInvariantList(ExpressionList expressions)
{
if (expressions == null) return null;
for (int i = 0, n = expressions.Count; i < n; i++)
expressions[i] = this.VisitExpression(expressions[i]);
return expressions;
}
public virtual Statement VisitWhile(While While)
{
if (While == null) return null;
While.Condition = this.VisitExpression(While.Condition);
While.Invariants = this.VisitLoopInvariantList(While.Invariants);
While.Body = this.VisitBlock(While.Body);
return While;
}
public virtual Statement VisitYield(Yield Yield)
{
if (Yield == null) return null;
Yield.Expression = this.VisitExpression(Yield.Expression);
return Yield;
}
#endif
#if ExtendedRuntime
// query nodes
public virtual Node VisitQueryAggregate(QueryAggregate qa){
if (qa == null) return null;
qa.Expression = this.VisitExpression(qa.Expression);
return qa;
}
public virtual Node VisitQueryAlias(QueryAlias alias){
if (alias == null) return null;
alias.Expression = this.VisitExpression(alias.Expression);
return alias;
}
public virtual Node VisitQueryAxis(QueryAxis axis){
if (axis == null) return null;
axis.Source = this.VisitExpression( axis.Source );
return axis;
}
public virtual Node VisitQueryCommit(QueryCommit qc){
return qc;
}
public virtual Node VisitQueryContext(QueryContext context){
return context;
}
public virtual Node VisitQueryDelete(QueryDelete delete){
if (delete == null) return null;
delete.Source = this.VisitExpression(delete.Source);
/*delete.Target =*/ this.VisitExpression(delete.Target); //REVIEW: why should this not be updated?
return delete;
}
public virtual Node VisitQueryDifference(QueryDifference diff){
if (diff == null) return null;
diff.LeftSource = this.VisitExpression(diff.LeftSource);
diff.RightSource = this.VisitExpression(diff.RightSource);
return diff;
}
public virtual Node VisitQueryDistinct(QueryDistinct distinct){
if (distinct == null) return null;
distinct.Source = this.VisitExpression(distinct.Source);
return distinct;
}
public virtual Node VisitQueryExists(QueryExists exists){
if (exists == null) return null;
exists.Source = this.VisitExpression(exists.Source);
return exists;
}
public virtual Node VisitQueryFilter(QueryFilter filter){
if (filter == null) return null;
filter.Source = this.VisitExpression(filter.Source);
filter.Expression = this.VisitExpression(filter.Expression);
return filter;
}
public virtual Node VisitQueryGroupBy(QueryGroupBy groupby){
if (groupby == null) return null;
groupby.Source = this.VisitExpression(groupby.Source);
groupby.GroupList = this.VisitExpressionList(groupby.GroupList);
groupby.Having = this.VisitExpression(groupby.Having);
return groupby;
}
public virtual Statement VisitQueryGeneratedType(QueryGeneratedType qgt){
return qgt;
}
public virtual Node VisitQueryInsert(QueryInsert insert){
if (insert == null) return null;
insert.Location = this.VisitExpression(insert.Location);
insert.HintList = this.VisitExpressionList(insert.HintList);
insert.InsertList = this.VisitExpressionList(insert.InsertList);
return insert;
}
public virtual Node VisitQueryIntersection(QueryIntersection intersection){
if (intersection == null) return intersection;
intersection.LeftSource = this.VisitExpression(intersection.LeftSource);
intersection.RightSource = this.VisitExpression(intersection.RightSource);
intersection.Type = intersection.LeftSource == null ? null : intersection.LeftSource.Type;
return intersection;
}
public virtual Node VisitQueryIterator(QueryIterator xiterator){
if (xiterator == null) return xiterator;
xiterator.Expression = this.VisitExpression(xiterator.Expression);
xiterator.HintList = this.VisitExpressionList(xiterator.HintList);
return xiterator;
}
public virtual Node VisitQueryJoin(QueryJoin join){
if (join == null) return null;
join.LeftOperand = this.VisitExpression(join.LeftOperand);
join.RightOperand = this.VisitExpression(join.RightOperand);
join.JoinExpression = this.VisitExpression(join.JoinExpression);
return join;
}
public virtual Node VisitQueryLimit(QueryLimit limit){
if (limit == null) return null;
limit.Source = this.VisitExpression(limit.Source);
limit.Expression = this.VisitExpression(limit.Expression);
return limit;
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby){
if (orderby == null) return null;
orderby.Source = this.VisitExpression(orderby.Source);
orderby.OrderList = this.VisitExpressionList(orderby.OrderList);
return orderby;
}
public virtual Node VisitQueryOrderItem(QueryOrderItem item){
if (item == null) return null;
item.Expression = this.VisitExpression(item.Expression);
return item;
}
public virtual Node VisitQueryPosition(QueryPosition position){
return position;
}
public virtual Node VisitQueryProject(QueryProject project){
if (project == null) return null;
project.Source = this.VisitExpression(project.Source);
project.ProjectionList = this.VisitExpressionList(project.ProjectionList);
return project;
}
public virtual Node VisitQueryRollback(QueryRollback qr){
return qr;
}
public virtual Node VisitQueryQuantifier(QueryQuantifier qq){
if (qq == null) return null;
qq.Expression = this.VisitExpression(qq.Expression);
return qq;
}
public virtual Node VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe){
if (qqe == null) return null;
qqe.Expression = this.VisitExpression(qqe.Expression);
return qqe;
}
public virtual Node VisitQuerySelect(QuerySelect select){
if (select == null) return null;
select.Source = this.VisitExpression(select.Source);
return select;
}
public virtual Node VisitQuerySingleton(QuerySingleton singleton){
if (singleton == null) return null;
singleton.Source = this.VisitExpression(singleton.Source);
return singleton;
}
public virtual Node VisitQueryTransact(QueryTransact qt){
if (qt == null) return null;
qt.Source = this.VisitExpression(qt.Source);
qt.Body = this.VisitBlock(qt.Body);
qt.CommitBody = this.VisitBlock(qt.CommitBody);
qt.RollbackBody = this.VisitBlock(qt.RollbackBody);
return qt;
}
public virtual Node VisitQueryTypeFilter(QueryTypeFilter filter){
if (filter == null) return null;
filter.Source = this.VisitExpression(filter.Source);
return filter;
}
public virtual Node VisitQueryUnion(QueryUnion union){
if (union == null) return null;
union.LeftSource = this.VisitExpression(union.LeftSource);
union.RightSource = this.VisitExpression(union.RightSource);
return union;
}
public virtual Node VisitQueryUpdate(QueryUpdate update){
if (update == null) return null;
update.Source = this.VisitExpression(update.Source);
update.UpdateList = this.VisitExpressionList(update.UpdateList);
return update;
}
public virtual Node VisitQueryYielder(QueryYielder yielder){
if (yielder == null) return null;
yielder.Source = this.VisitExpression(yielder.Source);
yielder.Target = this.VisitExpression(yielder.Target);
yielder.Body = this.VisitBlock(yielder.Body);
return yielder;
}
#endif
#if !MinimalReader
/// <summary>
/// Return a type viewer for the current scope.
/// [The type viewer acts like the identity function, except for dialects (e.g. Extensible Sing#)
/// that allow extensions and differing views of types.]
/// null can be returned to represent an identity-function type viewer.
/// </summary>
public virtual TypeViewer TypeViewer
{
get
{
return null;
}
}
/// <summary>
/// Return the current scope's view of the argument type, by asking the current scope's type viewer.
/// </summary>
public virtual TypeNode/*!*/ GetTypeView(TypeNode/*!*/ type)
{
return TypeViewer.GetTypeView(this.TypeViewer, type);
}
#endif
}
#if !MinimalReader
/// <summary>
/// Provides methods for invoking a parser to obtain AST nodes corresponding to various types of code snippets.
/// </summary>
public interface IParser
{
/// <summary>
/// Parses the parser's source document as an entire compilation unit and adds the resulting AST nodes to the
/// Nodes list of the given CompilationUnit instance.
/// </summary>
/// <param name="compilationUnit">The compilation unit whose Nodes list will receive the AST root node(s) that the parser produces.</param>
void ParseCompilationUnit(CompilationUnit compilationUnit);
Expression ParseExpression();
void ParseStatements(StatementList statements);
void ParseTypeMembers(TypeNode type);
}
///<summary>Provides a way for general purpose code to construct parsers using an standard interface.
///Useful for base classes without complete knowledge of all the different kinds of parsers that might be used in an application.</summary>
public interface IParserFactory
{
IParser CreateParser(string fileName, int lineNumber, DocumentText text, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options);
}
public class SnippetParser : StandardVisitor
{
public IParserFactory/*!*/ DefaultParserFactory;
public ErrorNodeList ErrorNodes;
public Module SymbolTable;
public StatementList CurrentStatementList;
public CompilerParameters Options;
public SnippetParser(IParserFactory/*!*/ defaultParserFactory, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options)
{
this.DefaultParserFactory = defaultParserFactory;
this.ErrorNodes = errorNodes;
this.SymbolTable = symbolTable;
this.Options = options;
this.CurrentStatementList = new StatementList(0);
//^ base();
}
public override Node VisitUnknownNodeType(Node node)
{
return node; //Do not look for snippets inside unknown node types
}
public override Block VisitBlock(Block block)
{
if (block == null) return null;
StatementList savedStatementList = this.CurrentStatementList;
try
{
StatementList oldStatements = block.Statements;
int n = oldStatements == null ? 0 : oldStatements.Count;
StatementList newStatements = this.CurrentStatementList = block.Statements = new StatementList(n);
for (int i = 0; i < n; i++)
{
//^ assert oldStatements != null;
newStatements.Add((Statement)this.Visit(oldStatements[i]));
}
return block;
}
finally
{
this.CurrentStatementList = savedStatementList;
}
}
public override CompilationUnit VisitCompilationUnitSnippet(CompilationUnitSnippet snippet)
{
if (snippet == null) return null;
Document doc = snippet.SourceContext.Document;
if (doc == null) return null;
string fileName = doc.Name;
int lineNumber = doc.LineNumber;
DocumentText sourceText = doc.Text;
IParserFactory pf = snippet.ParserFactory;
IParser p;
if (pf == null)
p = this.DefaultParserFactory.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
else
p = pf.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
if (p == null) return null;
p.ParseCompilationUnit(snippet);
return snippet;
}
public override Expression VisitExpressionSnippet(ExpressionSnippet snippet)
{
if (snippet == null) return null;
Document doc = snippet.SourceContext.Document;
if (doc == null) return null;
string fileName = doc.Name;
int lineNumber = doc.LineNumber;
DocumentText sourceText = doc.Text;
IParserFactory pf = snippet.ParserFactory;
IParser p;
if (pf == null)
p = this.DefaultParserFactory.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
else
p = pf.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
if (p == null) return null;
return p.ParseExpression();
}
public override StatementSnippet VisitStatementSnippet(StatementSnippet snippet)
{
if (snippet == null) return null;
Document doc = snippet.SourceContext.Document;
if (doc == null) return null;
string fileName = doc.Name;
int lineNumber = doc.LineNumber;
DocumentText sourceText = doc.Text;
IParserFactory pf = snippet.ParserFactory;
IParser p;
if (pf == null)
p = this.DefaultParserFactory.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
else
p = pf.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
if (p == null) return null;
p.ParseStatements(this.CurrentStatementList);
return null;
}
public override TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet)
{
if (snippet == null) return null;
Document doc = snippet.SourceContext.Document;
if (doc == null) return null;
string fileName = doc.Name;
int lineNumber = doc.LineNumber;
DocumentText sourceText = doc.Text;
IParserFactory pf = snippet.ParserFactory;
IParser p;
if (pf == null)
p = this.DefaultParserFactory.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
else
p = pf.CreateParser(fileName, lineNumber, sourceText, this.SymbolTable, this.ErrorNodes, this.Options);
if (p == null) return null;
p.ParseTypeMembers(snippet.DeclaringType);
return null;
}
}
#endif
}
|