public ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.Type == null || node.Constructor == null || !node.Type.IsGenericInstance)
{
return(null);
}
TypeDefinition typeDef = node.Type.Resolve();
if (!typeDef.IsAnonymous())
{
return(null);
}
initializerExpressions = new BlockExpression(null);
ProcessAnonymousType(typeDef, node.Type as GenericInstanceType, node.Constructor.Resolve(), node.Arguments);
node.Initializer = new InitializerExpression(initializerExpressions, InitializerType.ObjectInitializer);
List <Instruction> instructions = new List <Instruction>(node.MappedInstructions);
foreach (Expression argument in node.Arguments)
{
instructions.AddRange(argument.UnderlyingSameMethodInstructions);
}
InitializerExpression initializer = new InitializerExpression(initializerExpressions, InitializerType.AnonymousInitializer);
return(new AnonymousObjectCreationExpression(node.Constructor, typeDef, initializer, instructions));
}
public ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.get_Type() == null || node.get_Constructor() == null || !node.get_Type().get_IsGenericInstance())
{
return(null);
}
V_0 = node.get_Type().Resolve();
if (!V_0.IsAnonymous())
{
return(null);
}
this.initializerExpressions = new BlockExpression(null);
this.ProcessAnonymousType(V_0, node.get_Type() as GenericInstanceType, node.get_Constructor().Resolve(), node.get_Arguments());
V_1 = new InitializerExpression(this.initializerExpressions, 3);
return(new AnonymousObjectCreationExpression(node.get_Constructor(), V_0, V_1, node.get_MappedInstructions()));
}
/// <summary>
/// Evaluates the given initializer expression.
/// </summary>
/// <param name="Expression">The expression to evaluate.</param>
/// <returns>The value obtained by evaluating the initializer expression.</returns>
public T Evaluate <T>(InitializerExpression Expression)
{
var context = new InterpreterContext(this);
foreach (var instruction in Expression.BodyInstructions)
{
Interpreter.Interpret(instruction, context);
}
var result = context.Pop <T>();
if (context.StackDepth > 0)
{
throw new WasmException(
"The stack must contain exactly one value after " +
"evaluating an initializer expression. Actual stack depth: " +
context.StackDepth + ".");
}
return(result);
}
public ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.Type == null || node.Constructor == null || !node.Type.IsGenericInstance)
{
return(null);
}
TypeDefinition typeDef = node.Type.Resolve();
if (!typeDef.IsAnonymous())
{
return(null);
}
initializerExpressions = new BlockExpression(null);
ProcessAnonymousType(typeDef, node.Type as GenericInstanceType, node.Constructor.Resolve(), node.Arguments);
InitializerExpression initializer = new InitializerExpression(initializerExpressions, InitializerType.AnonymousInitializer);
return(new AnonymousObjectCreationExpression(node.Constructor, typeDef, initializer, node.MappedInstructions));
}
private Expression GetMethodHandleExpression(MethodReference methodReference, IEnumerable <Instruction> instructions)
{
TypeDefinition corlibTypeTypeDefinition = GetSystemTypeTypeDefinition();
string[] parametersNames = methodReference.HasParameters ? new string[] { "System.String", "System.Type[]" } : new string[] { "System.String" };
MethodReference getMethodReference = GetSystemTypeMethodReference(corlibTypeTypeDefinition, "GetMethod", parametersNames);
MethodReference getMethodHandleReference = GetHandlePropertyGetterReference(typeof(System.Reflection.MethodBase), "get_MethodHandle");
TypeOfExpression typeOfExpression = new TypeOfExpression(methodReference.DeclaringType, null);
MethodReferenceExpression getMethodMethodReferenceExpression = new MethodReferenceExpression(typeOfExpression, getMethodReference, null);
MethodInvocationExpression getMethodMethodInvocationExpression = new MethodInvocationExpression(getMethodMethodReferenceExpression, null);
LiteralExpression argument = new LiteralExpression(methodReference.Name, this.typeSystem, null);
getMethodMethodInvocationExpression.Arguments.Add(argument);
if (methodReference.HasParameters)
{
BlockExpression blockExpression = new BlockExpression(null);
foreach (ParameterDefinition parameter in methodReference.Parameters)
{
blockExpression.Expressions.Add(new TypeOfExpression(parameter.ParameterType, null));
}
InitializerExpression initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer);
ArrayCreationExpression getMethodTypeParametersArray = new ArrayCreationExpression(corlibTypeTypeDefinition, initializer, null);
getMethodTypeParametersArray.Dimensions.Add(new LiteralExpression(blockExpression.Expressions.Count, this.typeSystem, null));
getMethodMethodInvocationExpression.Arguments.Add(getMethodTypeParametersArray);
}
MethodReferenceExpression getMethodHandleMethodReferenceExpression = new MethodReferenceExpression(getMethodMethodInvocationExpression, getMethodHandleReference, null);
MethodInvocationExpression getMethodHandleMethodInvocationExpression = new MethodInvocationExpression(getMethodHandleMethodReferenceExpression, instructions);
PropertyReferenceExpression methodHandlePropertyReferenceExpression = new PropertyReferenceExpression(getMethodHandleMethodInvocationExpression, null);
return(methodHandlePropertyReferenceExpression);
}
public override void VisitInitializerExpression(InitializerExpression node)
{
count--;
Visit(node.Expression);
}
// Person person = new Person { Name = "John", Age = 20 };
//
// ==
//
// Person person = new Person();
// person.Name = "John";
// person.Age = 20;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return(false);
}
ExpressionCollection inlinedExpressions = new ExpressionCollection();
HashSet <string> visitedPropertyNames = new HashSet <string>();
if (objectCreation.Initializer != null)
{
if (objectCreation.Initializer.InitializerType != InitializerType.ObjectInitializer)
{
return(false);
}
foreach (var item in objectCreation.Initializer.Expressions)
{
string name = GetName((item as BinaryExpression).Left);
visitedPropertyNames.Add(name);
}
}
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
BinaryExpression assignment = expression as BinaryExpression;
if (!IsObjectPropertyOrFieldAssignment(assignment, assignee))
{
break;
}
Expression initializer = null;
if (assignment.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression)
{
PropertyDefinition property = (assignment.Left as PropertyReferenceExpression).Property;
if (!Visit(property.Name, visitedPropertyNames))
{
break;
}
initializer = new PropertyInitializerExpression(property, property.PropertyType,
assignment.Left.UnderlyingSameMethodInstructions);
}
else if (assignment.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition field = (assignment.Left as FieldReferenceExpression).Field.Resolve();
if (!Visit(field.Name, visitedPropertyNames))
{
break;
}
initializer = new FieldInitializerExpression(field, field.FieldType,
assignment.Left.UnderlyingSameMethodInstructions);
}
var inlinedAssignment = new BinaryExpression(BinaryOperator.Assign,
initializer, assignment.Right.Clone(), this.typeSystem, null);
inlinedExpressions.Add(inlinedAssignment);
}
if (inlinedExpressions.Count == 0)
{
return(false);
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(inlinedExpressions, InitializerType.ObjectInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in inlinedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = inlinedExpressions.Count + 1;
return(true);
}
public virtual void VisitInitializerExpression(InitializerExpression node)
{
this.Visit(node.get_Expression());
return;
}
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
if (!this.TryGetObjectCreation(statements, startIndex, out V_0, out V_1))
{
return(false);
}
if (V_0.get_Initializer() != null && V_0.get_Initializer().get_InitializerType() != InitializerType.CollectionInitializer)
{
return(false);
}
if (!this.ImplementsInterface(V_0.get_Type(), "System.Collections.IEnumerable"))
{
return(false);
}
V_2 = new ExpressionCollection();
V_3 = startIndex + 1;
while (V_3 < statements.get_Count() && this.TryGetNextExpression(statements.get_Item(V_3), out V_4) && V_4.get_CodeNodeType() == 19)
{
V_5 = V_4 as MethodInvocationExpression;
V_6 = V_5.get_MethodExpression().get_MethodDefinition();
if (!this.CompareTargets(V_1, V_5.get_MethodExpression().get_Target()) || String.op_Inequality(V_6.get_Name(), "Add") || V_5.get_Arguments().get_Count() == 0)
{
break;
}
if (V_5.get_Arguments().get_Count() != 1)
{
stackVariable88 = V_5.get_Arguments();
stackVariable89 = CollectionInitializationPattern.u003cu003ec.u003cu003e9__1_0;
if (stackVariable89 == null)
{
dummyVar0 = stackVariable89;
stackVariable89 = new Func <Expression, Expression>(CollectionInitializationPattern.u003cu003ec.u003cu003e9.u003cTryMatchInternalu003eb__1_0);
CollectionInitializationPattern.u003cu003ec.u003cu003e9__1_0 = stackVariable89;
}
V_7 = new BlockExpression(new ExpressionCollection(stackVariable88.Select <Expression, Expression>(stackVariable89)), null);
V_2.Add(V_7);
}
else
{
V_2.Add(V_5.get_Arguments().get_Item(0).Clone());
}
V_3 = V_3 + 1;
}
if (V_2.get_Count() == 0)
{
return(false);
}
if (V_0.get_Initializer() != null)
{
V_9 = V_2.GetEnumerator();
try
{
while (V_9.MoveNext())
{
V_10 = V_9.get_Current();
V_0.get_Initializer().get_Expressions().Add(V_10);
}
}
finally
{
if (V_9 != null)
{
V_9.Dispose();
}
}
}
else
{
V_8 = new InitializerExpression(V_2, 0);
V_8.set_IsMultiLine(true);
V_0.set_Initializer(V_8);
}
result = statements.get_Item(startIndex);
replacedStatementsCount = V_2.get_Count() + 1;
return(true);
}
public static bool IsInitializerPresent(InitializerExpression initializer)
{
return(initializer != null && initializer.Expression != null && initializer.Expression.Expressions.Count > 0);
}
.WithInitializer(InitializerExpression(SyntaxKind.ArrayInitializerExpression)
// MyCollection list = new MyCollection() { 1, { 2, 2 } , 3 };
//
// ==
//
// MyCollection temp = new MyCollection();
// temp.Add(1);
// temp.Add(2, 2);
// temp.Add(3);
// MyCollection list = temp;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return(false);
}
if (objectCreation.Initializer != null && objectCreation.Initializer.InitializerType != InitializerType.CollectionInitializer)
{
return(false);
}
if (!ImplementsInterface(objectCreation.Type, "System.Collections.IEnumerable"))
{
return(false);
}
ExpressionCollection addedExpressions = new ExpressionCollection();
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
if (expression.CodeNodeType != CodeNodeType.MethodInvocationExpression)
{
break;
}
MethodInvocationExpression methodInvocation = (expression as MethodInvocationExpression);
MethodDefinition methodDefinition = methodInvocation.MethodExpression.MethodDefinition;
if (!CompareTargets(assignee, methodInvocation.MethodExpression.Target))
{
break;
}
if (methodDefinition.Name != "Add")
{
break;
}
if (methodInvocation.Arguments.Count == 0)
{
break;
}
else if (methodInvocation.Arguments.Count == 1)
{
addedExpressions.Add(methodInvocation.Arguments[0].Clone());
}
else
{
ExpressionCollection currentArguments = new ExpressionCollection(
methodInvocation.Arguments.Select(x => x.Clone()));
BlockExpression blockExpression = new BlockExpression(currentArguments, null);
addedExpressions.Add(blockExpression);
}
}
if (addedExpressions.Count == 0)
{
return(false);
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(addedExpressions, InitializerType.CollectionInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in addedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = addedExpressions.Count + 1;
return(true);
}
public virtual ICodeNode VisitInitializerExpression(InitializerExpression node)
{
node.set_Expression((BlockExpression)this.Visit(node.get_Expression()));
return(node);
}
/// <summary>
/// 式中のメンバアクセス、定数等を解析する。
/// </summary>
/// <param name="syntax"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
Expression ParseExpression(ExpressionSyntax syntax, SemanticModel semanticModel)
{
if (syntax == null)
{
return(null);
}
var mae = syntax as MemberAccessExpressionSyntax;
var gns = syntax as GenericNameSyntax;
var le = syntax as LiteralExpressionSyntax;
var ie = syntax as InvocationExpressionSyntax;
var oce = syntax as ObjectCreationExpressionSyntax;
var ce = syntax as CastExpressionSyntax;
var thise = syntax as ThisExpressionSyntax;
var ae = syntax as AssignmentExpressionSyntax;
var pe = syntax as ParenthesizedExpressionSyntax;
var ine = syntax as IdentifierNameSyntax;
var eae = syntax as ElementAccessExpressionSyntax;
var be = syntax as BinaryExpressionSyntax;
var preue = syntax as PrefixUnaryExpressionSyntax;
var poue = syntax as PostfixUnaryExpressionSyntax;
var basee = syntax as BaseExpressionSyntax;
var ace = syntax as ArrayCreationExpressionSyntax;
var sace = syntax as StackAllocArrayCreationExpressionSyntax;
var iee = syntax as InitializerExpressionSyntax;
/*
* var coe = syntax as ConditionalExpressionSyntax;
* var sle = syntax as SimpleLambdaExpressionSyntax;
* var ple = syntax as ParenthesizedLambdaExpressionSyntax;
* var oase = syntax as OmittedArraySizeExpressionSyntax;
* var iace = syntax as ImplicitArrayCreationExpressionSyntax;
*
* var qua = syntax as QualifiedNameSyntax;
* var predf = syntax as PredefinedTypeSyntax;
*/
// 自己の型を解析
TypeInfo?selfTypeInfo = null;
selfTypeInfo = semanticModel.GetTypeInfo(syntax);
var selfType = ParseType(syntax, selfTypeInfo, semanticModel);
if (mae != null)
{
MemberAccessExpression exp = new MemberAccessExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = mae.Name.ToString();
if (mae.Name is GenericNameSyntax)
{
var gns_ = mae.Name as GenericNameSyntax;
exp.Types = gns_.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray();
}
TypeInfo?parentType = null;
if (mae.Expression != null)
{
parentType = semanticModel.GetTypeInfo(mae.Expression);
}
// 種類を取得
var symbol = semanticModel.GetSymbolInfo(mae);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
// 親の種類を探索
List <ClassDef> classDefPs = new List <ClassDef>();
EnumDef enumDefP = null;
InterfaceDef interfaceDefP = null;
StructDef structDefP = null;
// プロパティである
if (propertySymbol != null)
{
exp.IsProperty = true;
}
if (parentType.HasValue && parentType.Value.Type != null)
{
if (parentType.Value.Type.TypeKind == TypeKind.Interface)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
interfaceDefP = definitions.Interfaces.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Class)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
classDefPs = definitions.FindTypeWithBases(namespace_, name_).OfType <ClassDef>().ToList();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Enum)
{
var enumName = selfTypeInfo.Value.Type.Name;
var namespace_ = Utils.ToStr(selfTypeInfo.Value.Type.ContainingNamespace);
enumDefP = definitions.Enums.Where(_ => _.Namespace == namespace_ && _.Name == enumName).FirstOrDefault();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Struct)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
structDefP = definitions.Structs.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault();
}
}
// 親から子を探索
if (interfaceDefP != null)
{
if (methodSymbol != null)
{
var method = interfaceDefP.Methods.Where(_ =>
{
if (_.Name != methodSymbol.Name)
{
return(false);
}
if (_.Parameters.Count() != methodSymbol.Parameters.Count())
{
return(false);
}
for (int i = 0; i < _.Parameters.Count(); i++)
{
if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name)
{
return(false);
}
// TODO 正しい変換
//if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type)
}
return(true);
}).FirstOrDefault();
if (method != null)
{
exp.Name = null;
exp.Method = method;
}
}
else if (propertySymbol != null)
{
var prop = interfaceDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Property = prop;
}
}
}
else if (classDefPs.Count > 0)
{
if (methodSymbol != null)
{
foreach (var classDefP in classDefPs)
{
var method = classDefP.Methods.Where(_ =>
{
if (_.Name != methodSymbol.Name)
{
return(false);
}
if (_.Parameters.Count() != methodSymbol.Parameters.Count())
{
return(false);
}
for (int i = 0; i < _.Parameters.Count(); i++)
{
if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name)
{
return(false);
}
// TODO 正しい変換
//if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type)
}
return(true);
}).FirstOrDefault();
if (method != null)
{
exp.Name = null;
exp.Class = classDefP;
exp.Method = method;
// staticの場合走査停止
if (method.IsStatic)
{
return(exp);
}
break;
}
}
}
else if (propertySymbol != null)
{
foreach (var classDefP in classDefPs)
{
var prop = classDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Class = classDefP;
exp.Property = prop;
break;
}
}
}
}
else if (structDefP != null)
{
if (propertySymbol != null)
{
var prop = structDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Struct = structDefP;
exp.Property = prop;
}
}
}
else if (enumDefP != null)
{
var name = mae.Name.ToString();
exp.EnumMember = enumDefP.Members.Where(_ => _.Name == name).FirstOrDefault();
if (exp.EnumMember != null)
{
exp.Enum = enumDefP;
exp.Name = null;
}
}
else
{
// 代替処理
if (propertySymbol != null)
{
exp.Property = new PropertyDef();
exp.Property.Name = exp.Name;
}
}
if (exp.EnumMember != null)
{
// enumのメンバーだった場合、親は必ずenumなのでこれ以上走査しない
}
else if (mae.Expression != null)
{
exp.Expression = ParseExpression(mae.Expression, semanticModel);
}
return(exp);
}
else if (gns != null)
{
var symbol = semanticModel.GetSymbolInfo(gns);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var fieldSymbol = symbol.Symbol as IFieldSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
var exp = new GenericNameExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = gns.Identifier.ValueText;
if (methodSymbol != null)
{
exp.IsMethod = true;
}
if (propertySymbol != null)
{
exp.IsProperty = true;
}
exp.Types = gns.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray();
return(exp);
}
else if (le != null)
{
var text = le.GetText().ToString();
var exp = new LiteralExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Text = text;
return(exp);
}
else if (ie != null)
{
var exp = new InvocationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Method = ParseExpression(ie.Expression, semanticModel);
exp.Args = ie.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray();
return(exp);
}
else if (oce != null)
{
var exp = new ObjectCreationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(oce.Type, semanticModel);
if (oce.ArgumentList != null)
{
exp.Args = oce.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray();
}
else
{
exp.Args = new Expression[0];
}
return(exp);
}
else if (ce != null)
{
var exp = new CastExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(ce.Type, semanticModel);
exp.Expression = ParseExpression(ce.Expression, semanticModel);
return(exp);
}
else if (thise != null)
{
var exp = new ThisExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (ae != null)
{
var exp = new AssignmentExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
if (ae.Kind() == SyntaxKind.AddAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Add;
}
if (ae.Kind() == SyntaxKind.SubtractAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Substract;
}
if (ae.Kind() == SyntaxKind.SimpleAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Simple;
}
if (ae.Kind() == SyntaxKind.DivideAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Divide;
}
if (ae.Kind() == SyntaxKind.ModuloAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Modulo;
}
exp.Temp = ae.Kind();
exp.Target = ParseExpression(ae.Left, semanticModel);
exp.Expression = ParseExpression(ae.Right, semanticModel);
return(exp);
}
else if (pe != null)
{
// ()の構文
return(ParseExpression(pe.Expression, semanticModel));
}
else if (ine != null)
{
var symbol = semanticModel.GetSymbolInfo(ine);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var fieldSymbol = symbol.Symbol as IFieldSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
var exp = new IdentifierNameExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = ine.Identifier.Text;
if (selfTypeInfo?.Type != null)
{
exp.Type = ParseType(selfTypeInfo.Value.Type);
}
if (methodSymbol != null)
{
exp.IsMethod = true;
}
if (propertySymbol != null)
{
exp.IsProperty = true;
}
return(exp);
}
else if (eae != null)
{
if (eae.ArgumentList.Arguments.Count() != 1)
{
throw new ParseException("多次元配列は使用禁止です。");
}
var value_ = eae.Expression;
var arg = eae.ArgumentList.Arguments[0].Expression;
var exp = new ElementAccessExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Value = ParseExpression(value_, semanticModel);
exp.Arg = ParseExpression(arg, semanticModel);
return(exp);
}
else if (be != null)
{
var exp = new BinaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Left = ParseExpression(be.Left, semanticModel);
exp.Right = ParseExpression(be.Right, semanticModel);
if (be.Kind() == SyntaxKind.AddExpression)
{
exp.Operator = BinaryExpression.OperatorType.Add;
}
if (be.Kind() == SyntaxKind.SubtractExpression)
{
exp.Operator = BinaryExpression.OperatorType.Subtract;
}
if (be.Kind() == SyntaxKind.IsExpression)
{
exp.Operator = BinaryExpression.OperatorType.Is;
}
if (be.Kind() == SyntaxKind.AsExpression)
{
exp.Operator = BinaryExpression.OperatorType.As;
}
if (be.Kind() == SyntaxKind.EqualsExpression)
{
exp.Operator = BinaryExpression.OperatorType.Equals;
}
if (be.Kind() == SyntaxKind.NotEqualsExpression)
{
exp.Operator = BinaryExpression.OperatorType.NotEquals;
}
if (be.Kind() == SyntaxKind.LogicalAndExpression)
{
exp.Operator = BinaryExpression.OperatorType.LogicalAnd;
}
if (be.Kind() == SyntaxKind.LogicalOrExpression)
{
exp.Operator = BinaryExpression.OperatorType.LogicalOr;
}
if (be.Kind() == SyntaxKind.GreaterThanExpression)
{
exp.Operator = BinaryExpression.OperatorType.GreaterThan;
}
if (be.Kind() == SyntaxKind.GreaterThanOrEqualExpression)
{
exp.Operator = BinaryExpression.OperatorType.GreaterThanOrEqual;
}
if (be.Kind() == SyntaxKind.LessThanExpression)
{
exp.Operator = BinaryExpression.OperatorType.LessThan;
}
if (be.Kind() == SyntaxKind.LessThanOrEqualExpression)
{
exp.Operator = BinaryExpression.OperatorType.LessThanOrEqual;
}
if (be.Kind() == SyntaxKind.MultiplyExpression)
{
exp.Operator = BinaryExpression.OperatorType.Multiply;
}
if (be.Kind() == SyntaxKind.DivideExpression)
{
exp.Operator = BinaryExpression.OperatorType.Divide;
}
if (be.Kind() == SyntaxKind.ModuloExpression)
{
exp.Operator = BinaryExpression.OperatorType.Modulo;
}
if (exp.Operator == BinaryExpression.OperatorType.None)
{
var span_ = syntax.SyntaxTree.GetLineSpan(syntax.Span);
Console.WriteLine(string.Format("{0} : {1} には未対応です。", span_, be.Kind()));
}
return(exp);
}
else if (preue != null)
{
var exp = new PrefixUnaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Expression = ParseExpression(preue.Operand, semanticModel);
switch (preue.Kind())
{
case SyntaxKind.LogicalNotExpression:
exp.Type = PrefixUnaryExpression.OperatorType.LogicalNot;
break;
case SyntaxKind.UnaryPlusExpression:
exp.Type = PrefixUnaryExpression.OperatorType.UnaryPlus;
break;
case SyntaxKind.UnaryMinusExpression:
exp.Type = PrefixUnaryExpression.OperatorType.UnaryMinus;
break;
case SyntaxKind.PreIncrementExpression:
exp.Type = PrefixUnaryExpression.OperatorType.PreIncrement;
break;
default:
throw new Exception();
break;
}
return(exp);
}
else if (poue != null)
{
var exp = new PostfixUnaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Operand = ParseExpression(poue.Operand, semanticModel);
if (poue.Kind() == SyntaxKind.PostIncrementExpression)
{
exp.Type = PostfixUnaryExpression.OperatorType.PostIncrement;
}
if (poue.Kind() == SyntaxKind.PostDecrementExpression)
{
exp.Type = PostfixUnaryExpression.OperatorType.PostDecrement;
}
return(exp);
}
else if (basee != null)
{
var exp = new BaseExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (iee != null)
{
var exp = new InitializerExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
var expressions = iee.Expressions.Select(_ => _).ToArray();
exp.Expressions = expressions.Select(_ => ParseExpression(_, semanticModel)).ToArray();
return(exp);
}
else if (ace != null || sace != null)
{
// stackallocも含め、配列の確保として扱う。
ArrayTypeSyntax ats = null;
if (ace != null)
{
ats = ace.Type;
}
if (sace != null)
{
ats = sace.Type as ArrayTypeSyntax;
}
var exp = new ObjectArrayCreationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(ats.ElementType, semanticModel);
exp.Args = ats.RankSpecifiers.Select(_ => ParseExpression(_.Sizes.FirstOrDefault(), semanticModel)).ToArray();
return(exp);
}
else if (syntax is PredefinedTypeSyntax)
{
var s = syntax as PredefinedTypeSyntax;
var exp = new TypeExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (syntax is QualifiedNameSyntax)
{
var s = syntax as QualifiedNameSyntax;
var exp = new TypeExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
var span = syntax.SyntaxTree.GetLineSpan(syntax.Span);
Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType()));
return(null);
}
public virtual ICodeNode VisitInitializerExpression(InitializerExpression node)
{
node.Expression = (BlockExpression)Visit(node.Expression);
return(node);
}
public virtual void VisitInitializerExpression(InitializerExpression node)
{
Visit(node.Expression);
}
/// <summary>
/// Evaluates an initializer expression.
/// </summary>
/// <param name="expression">The expression to evaluate.</param>
/// <param name="resultType">The result type expected from the expression.</param>
/// <returns>The value obtained by evaluating the initializer expression.</returns>
public object Evaluate(InitializerExpression expression, Type resultType)
{
return(Evaluate(expression, ValueHelpers.ToWasmValueType(resultType)));
}
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
if (!this.TryGetObjectCreation(statements, startIndex, out V_0, out V_1))
{
return(false);
}
V_2 = new ExpressionCollection();
V_3 = new HashSet <string>();
if (V_0.get_Initializer() != null)
{
if (V_0.get_Initializer().get_InitializerType() != 1)
{
return(false);
}
V_4 = V_0.get_Initializer().get_Expressions().GetEnumerator();
try
{
while (V_4.MoveNext())
{
V_5 = V_4.get_Current();
V_6 = this.GetName((V_5 as BinaryExpression).get_Left());
dummyVar0 = V_3.Add(V_6);
}
}
finally
{
if (V_4 != null)
{
V_4.Dispose();
}
}
}
V_7 = startIndex + 1;
while (V_7 < statements.get_Count() && this.TryGetNextExpression(statements.get_Item(V_7), out V_8))
{
V_9 = V_8 as BinaryExpression;
if (!this.IsObjectPropertyOrFieldAssignment(V_9, V_1))
{
break;
}
V_10 = null;
if (V_9.get_Left().get_CodeNodeType() != 42)
{
if (V_9.get_Left().get_CodeNodeType() == 30)
{
V_13 = (V_9.get_Left() as FieldReferenceExpression).get_Field().Resolve();
if (!this.Visit(V_13.get_Name(), V_3))
{
break;
}
V_10 = new FieldInitializerExpression(V_13, V_13.get_FieldType(), V_9.get_Left().get_UnderlyingSameMethodInstructions());
}
}
else
{
V_12 = (V_9.get_Left() as PropertyReferenceExpression).get_Property();
if (!this.Visit(V_12.get_Name(), V_3))
{
break;
}
V_10 = new PropertyInitializerExpression(V_12, V_12.get_PropertyType(), V_9.get_Left().get_UnderlyingSameMethodInstructions());
}
V_11 = new BinaryExpression(26, V_10, V_9.get_Right().Clone(), this.typeSystem, null, false);
V_2.Add(V_11);
V_7 = V_7 + 1;
}
if (V_2.get_Count() == 0)
{
return(false);
}
if (V_0.get_Initializer() != null)
{
V_4 = V_2.GetEnumerator();
try
{
while (V_4.MoveNext())
{
V_15 = V_4.get_Current();
V_0.get_Initializer().get_Expressions().Add(V_15);
}
}
finally
{
if (V_4 != null)
{
V_4.Dispose();
}
}
}
else
{
V_14 = new InitializerExpression(V_2, 1);
V_14.set_IsMultiLine(true);
V_0.set_Initializer(V_14);
}
result = statements.get_Item(startIndex);
replacedStatementsCount = V_2.get_Count() + 1;
return(true);
}
/// <summary>
/// Evaluates an initializer expression.
/// </summary>
/// <param name="expression">The expression to evaluate.</param>
/// <returns>The value obtained by evaluating the initializer expression.</returns>
public T Evaluate <T>(InitializerExpression expression)
{
return((T)Evaluate(expression, ValueHelpers.ToWasmValueType <T>()));
}
public override void VisitInitializerExpression(InitializerExpression node)
{
this.count = this.count - 1;
this.Visit(node.get_Expression());
return;
}
public static Doc Print(SyntaxNode syntaxNode)
{
if (syntaxNode == null)
{
return(Doc.Null);
}
// TODO 0 kill? runtime repo has files that will fail on deep recursion
if (depth > 200)
{
throw new InTooDeepException();
}
depth++;
try
{
switch (syntaxNode)
{
case AliasQualifiedNameSyntax aliasQualifiedNameSyntax:
return(AliasQualifiedName.Print(aliasQualifiedNameSyntax));
case AnonymousMethodExpressionSyntax anonymousMethodExpressionSyntax:
return(AnonymousMethodExpression.Print(anonymousMethodExpressionSyntax));
case AnonymousObjectCreationExpressionSyntax anonymousObjectCreationExpressionSyntax:
return(AnonymousObjectCreationExpression.Print(
anonymousObjectCreationExpressionSyntax
));
case AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax:
return(AnonymousObjectMemberDeclarator.Print(
anonymousObjectMemberDeclaratorSyntax
));
case ArgumentListSyntax argumentListSyntax:
return(ArgumentList.Print(argumentListSyntax));
case ArgumentSyntax argumentSyntax:
return(Argument.Print(argumentSyntax));
case ArrayCreationExpressionSyntax arrayCreationExpressionSyntax:
return(ArrayCreationExpression.Print(arrayCreationExpressionSyntax));
case ArrayRankSpecifierSyntax arrayRankSpecifierSyntax:
return(ArrayRankSpecifier.Print(arrayRankSpecifierSyntax));
case ArrayTypeSyntax arrayTypeSyntax:
return(ArrayType.Print(arrayTypeSyntax));
case ArrowExpressionClauseSyntax arrowExpressionClauseSyntax:
return(ArrowExpressionClause.Print(arrowExpressionClauseSyntax));
case AssignmentExpressionSyntax assignmentExpressionSyntax:
return(AssignmentExpression.Print(assignmentExpressionSyntax));
case AttributeListSyntax attributeListSyntax:
return(AttributeList.Print(attributeListSyntax));
case AwaitExpressionSyntax awaitExpressionSyntax:
return(AwaitExpression.Print(awaitExpressionSyntax));
case BaseExpressionSyntax baseExpressionSyntax:
return(BaseExpression.Print(baseExpressionSyntax));
case BaseFieldDeclarationSyntax baseFieldDeclarationSyntax:
return(BaseFieldDeclaration.Print(baseFieldDeclarationSyntax));
case BaseListSyntax baseListSyntax:
return(BaseList.Print(baseListSyntax));
case BaseMethodDeclarationSyntax baseMethodDeclarationSyntax:
return(BaseMethodDeclaration.Print(baseMethodDeclarationSyntax));
case BasePropertyDeclarationSyntax basePropertyDeclarationSyntax:
return(BasePropertyDeclaration.Print(basePropertyDeclarationSyntax));
case BaseTypeDeclarationSyntax baseTypeDeclarationSyntax:
return(BaseTypeDeclaration.Print(baseTypeDeclarationSyntax));
case BinaryExpressionSyntax binaryExpressionSyntax:
return(BinaryExpression.Print(binaryExpressionSyntax));
case BinaryPatternSyntax binaryPatternSyntax:
return(BinaryPattern.Print(binaryPatternSyntax));
case BlockSyntax blockSyntax:
return(Block.Print(blockSyntax));
case BracketedArgumentListSyntax bracketedArgumentListSyntax:
return(BracketedArgumentList.Print(bracketedArgumentListSyntax));
case BracketedParameterListSyntax bracketedParameterListSyntax:
return(BracketedParameterList.Print(bracketedParameterListSyntax));
case BreakStatementSyntax breakStatementSyntax:
return(BreakStatement.Print(breakStatementSyntax));
case CasePatternSwitchLabelSyntax casePatternSwitchLabelSyntax:
return(CasePatternSwitchLabel.Print(casePatternSwitchLabelSyntax));
case CaseSwitchLabelSyntax caseSwitchLabelSyntax:
return(CaseSwitchLabel.Print(caseSwitchLabelSyntax));
case CastExpressionSyntax castExpressionSyntax:
return(CastExpression.Print(castExpressionSyntax));
case CatchClauseSyntax catchClauseSyntax:
return(CatchClause.Print(catchClauseSyntax));
case CheckedExpressionSyntax checkedExpressionSyntax:
return(CheckedExpression.Print(checkedExpressionSyntax));
case CheckedStatementSyntax checkedStatementSyntax:
return(CheckedStatement.Print(checkedStatementSyntax));
case ClassOrStructConstraintSyntax classOrStructConstraintSyntax:
return(ClassOrStructConstraint.Print(classOrStructConstraintSyntax));
case CompilationUnitSyntax compilationUnitSyntax:
return(CompilationUnit.Print(compilationUnitSyntax));
case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax:
return(ConditionalAccessExpression.Print(conditionalAccessExpressionSyntax));
case ConditionalExpressionSyntax conditionalExpressionSyntax:
return(ConditionalExpression.Print(conditionalExpressionSyntax));
case ConstantPatternSyntax constantPatternSyntax:
return(ConstantPattern.Print(constantPatternSyntax));
case ConstructorConstraintSyntax constructorConstraintSyntax:
return(ConstructorConstraint.Print(constructorConstraintSyntax));
case ConstructorInitializerSyntax constructorInitializerSyntax:
return(ConstructorInitializer.Print(constructorInitializerSyntax));
case ContinueStatementSyntax continueStatementSyntax:
return(ContinueStatement.Print(continueStatementSyntax));
case DeclarationExpressionSyntax declarationExpressionSyntax:
return(DeclarationExpression.Print(declarationExpressionSyntax));
case DeclarationPatternSyntax declarationPatternSyntax:
return(DeclarationPattern.Print(declarationPatternSyntax));
case DefaultConstraintSyntax defaultConstraintSyntax:
return(DefaultConstraint.Print(defaultConstraintSyntax));
case DefaultExpressionSyntax defaultExpressionSyntax:
return(DefaultExpression.Print(defaultExpressionSyntax));
case DefaultSwitchLabelSyntax defaultSwitchLabelSyntax:
return(DefaultSwitchLabel.Print(defaultSwitchLabelSyntax));
case DelegateDeclarationSyntax delegateDeclarationSyntax:
return(DelegateDeclaration.Print(delegateDeclarationSyntax));
case DiscardDesignationSyntax discardDesignationSyntax:
return(DiscardDesignation.Print(discardDesignationSyntax));
case DiscardPatternSyntax discardPatternSyntax:
return(DiscardPattern.Print(discardPatternSyntax));
case DoStatementSyntax doStatementSyntax:
return(DoStatement.Print(doStatementSyntax));
case ElementAccessExpressionSyntax elementAccessExpressionSyntax:
return(ElementAccessExpression.Print(elementAccessExpressionSyntax));
case ElementBindingExpressionSyntax elementBindingExpressionSyntax:
return(ElementBindingExpression.Print(elementBindingExpressionSyntax));
case ElseClauseSyntax elseClauseSyntax:
return(ElseClause.Print(elseClauseSyntax));
case EmptyStatementSyntax emptyStatementSyntax:
return(EmptyStatement.Print(emptyStatementSyntax));
case EnumMemberDeclarationSyntax enumMemberDeclarationSyntax:
return(EnumMemberDeclaration.Print(enumMemberDeclarationSyntax));
case EqualsValueClauseSyntax equalsValueClauseSyntax:
return(EqualsValueClause.Print(equalsValueClauseSyntax));
case ExpressionStatementSyntax expressionStatementSyntax:
return(ExpressionStatement.Print(expressionStatementSyntax));
case ExternAliasDirectiveSyntax externAliasDirectiveSyntax:
return(ExternAliasDirective.Print(externAliasDirectiveSyntax));
case FinallyClauseSyntax finallyClauseSyntax:
return(FinallyClause.Print(finallyClauseSyntax));
case FixedStatementSyntax fixedStatementSyntax:
return(FixedStatement.Print(fixedStatementSyntax));
case ForEachStatementSyntax forEachStatementSyntax:
return(ForEachStatement.Print(forEachStatementSyntax));
case ForEachVariableStatementSyntax forEachVariableStatementSyntax:
return(ForEachVariableStatement.Print(forEachVariableStatementSyntax));
case ForStatementSyntax forStatementSyntax:
return(ForStatement.Print(forStatementSyntax));
case FromClauseSyntax fromClauseSyntax:
return(FromClause.Print(fromClauseSyntax));
case FunctionPointerTypeSyntax functionPointerTypeSyntax:
return(FunctionPointerType.Print(functionPointerTypeSyntax));
case GenericNameSyntax genericNameSyntax:
return(GenericName.Print(genericNameSyntax));
case GlobalStatementSyntax globalStatementSyntax:
return(GlobalStatement.Print(globalStatementSyntax));
case GotoStatementSyntax gotoStatementSyntax:
return(GotoStatement.Print(gotoStatementSyntax));
case GroupClauseSyntax groupClauseSyntax:
return(GroupClause.Print(groupClauseSyntax));
case IdentifierNameSyntax identifierNameSyntax:
return(IdentifierName.Print(identifierNameSyntax));
case IfStatementSyntax ifStatementSyntax:
return(IfStatement.Print(ifStatementSyntax));
case ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax:
return(ImplicitArrayCreationExpression.Print(
implicitArrayCreationExpressionSyntax
));
case ImplicitElementAccessSyntax implicitElementAccessSyntax:
return(ImplicitElementAccess.Print(implicitElementAccessSyntax));
case ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax:
return(ImplicitObjectCreationExpression.Print(
implicitObjectCreationExpressionSyntax
));
case ImplicitStackAllocArrayCreationExpressionSyntax implicitStackAllocArrayCreationExpressionSyntax:
return(ImplicitStackAllocArrayCreationExpression.Print(
implicitStackAllocArrayCreationExpressionSyntax
));
case IncompleteMemberSyntax incompleteMemberSyntax:
return(IncompleteMember.Print(incompleteMemberSyntax));
case InitializerExpressionSyntax initializerExpressionSyntax:
return(InitializerExpression.Print(initializerExpressionSyntax));
case InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax:
return(InterpolatedStringExpression.Print(
interpolatedStringExpressionSyntax
));
case InterpolatedStringTextSyntax interpolatedStringTextSyntax:
return(InterpolatedStringText.Print(interpolatedStringTextSyntax));
case InterpolationSyntax interpolationSyntax:
return(Interpolation.Print(interpolationSyntax));
case InvocationExpressionSyntax invocationExpressionSyntax:
return(InvocationExpression.Print(invocationExpressionSyntax));
case IsPatternExpressionSyntax isPatternExpressionSyntax:
return(IsPatternExpression.Print(isPatternExpressionSyntax));
case JoinClauseSyntax joinClauseSyntax:
return(JoinClause.Print(joinClauseSyntax));
case LabeledStatementSyntax labeledStatementSyntax:
return(LabeledStatement.Print(labeledStatementSyntax));
case LetClauseSyntax letClauseSyntax:
return(LetClause.Print(letClauseSyntax));
case LiteralExpressionSyntax literalExpressionSyntax:
return(LiteralExpression.Print(literalExpressionSyntax));
case LocalDeclarationStatementSyntax localDeclarationStatementSyntax:
return(LocalDeclarationStatement.Print(localDeclarationStatementSyntax));
case LocalFunctionStatementSyntax localFunctionStatementSyntax:
return(LocalFunctionStatement.Print(localFunctionStatementSyntax));
case LockStatementSyntax lockStatementSyntax:
return(LockStatement.Print(lockStatementSyntax));
case MakeRefExpressionSyntax makeRefExpressionSyntax:
return(MakeRefExpression.Print(makeRefExpressionSyntax));
case MemberAccessExpressionSyntax memberAccessExpressionSyntax:
return(MemberAccessExpression.Print(memberAccessExpressionSyntax));
case MemberBindingExpressionSyntax memberBindingExpressionSyntax:
return(MemberBindingExpression.Print(memberBindingExpressionSyntax));
case NameColonSyntax nameColonSyntax:
return(NameColon.Print(nameColonSyntax));
case NameEqualsSyntax nameEqualsSyntax:
return(NameEquals.Print(nameEqualsSyntax));
case NamespaceDeclarationSyntax namespaceDeclarationSyntax:
return(NamespaceDeclaration.Print(namespaceDeclarationSyntax));
case NullableTypeSyntax nullableTypeSyntax:
return(NullableType.Print(nullableTypeSyntax));
case ObjectCreationExpressionSyntax objectCreationExpressionSyntax:
return(ObjectCreationExpression.Print(objectCreationExpressionSyntax));
case OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax:
return(OmittedArraySizeExpression.Print(omittedArraySizeExpressionSyntax));
case OmittedTypeArgumentSyntax omittedTypeArgumentSyntax:
return(OmittedTypeArgument.Print(omittedTypeArgumentSyntax));
case OrderByClauseSyntax orderByClauseSyntax:
return(OrderByClause.Print(orderByClauseSyntax));
case ParameterListSyntax parameterListSyntax:
return(ParameterList.Print(parameterListSyntax));
case ParameterSyntax parameterSyntax:
return(Parameter.Print(parameterSyntax));
case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax:
return(ParenthesizedExpression.Print(parenthesizedExpressionSyntax));
case ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpressionSyntax:
return(ParenthesizedLambdaExpression.Print(
parenthesizedLambdaExpressionSyntax
));
case ParenthesizedPatternSyntax parenthesizedPatternSyntax:
return(ParenthesizedPattern.Print(parenthesizedPatternSyntax));
case ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax:
return(ParenthesizedVariableDesignation.Print(
parenthesizedVariableDesignationSyntax
));
case PointerTypeSyntax pointerTypeSyntax:
return(PointerType.Print(pointerTypeSyntax));
case PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax:
return(PostfixUnaryExpression.Print(postfixUnaryExpressionSyntax));
case PredefinedTypeSyntax predefinedTypeSyntax:
return(PredefinedType.Print(predefinedTypeSyntax));
case PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax:
return(PrefixUnaryExpression.Print(prefixUnaryExpressionSyntax));
case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax:
return(PrimaryConstructorBaseType.Print(primaryConstructorBaseTypeSyntax));
case QualifiedNameSyntax qualifiedNameSyntax:
return(QualifiedName.Print(qualifiedNameSyntax));
case QueryBodySyntax queryBodySyntax:
return(QueryBody.Print(queryBodySyntax));
case QueryContinuationSyntax queryContinuationSyntax:
return(QueryContinuation.Print(queryContinuationSyntax));
case QueryExpressionSyntax queryExpressionSyntax:
return(QueryExpression.Print(queryExpressionSyntax));
case RangeExpressionSyntax rangeExpressionSyntax:
return(RangeExpression.Print(rangeExpressionSyntax));
case RecursivePatternSyntax recursivePatternSyntax:
return(RecursivePattern.Print(recursivePatternSyntax));
case RefExpressionSyntax refExpressionSyntax:
return(RefExpression.Print(refExpressionSyntax));
case RefTypeExpressionSyntax refTypeExpressionSyntax:
return(RefTypeExpression.Print(refTypeExpressionSyntax));
case RefTypeSyntax refTypeSyntax:
return(RefType.Print(refTypeSyntax));
case RefValueExpressionSyntax refValueExpressionSyntax:
return(RefValueExpression.Print(refValueExpressionSyntax));
case RelationalPatternSyntax relationalPatternSyntax:
return(RelationalPattern.Print(relationalPatternSyntax));
case ReturnStatementSyntax returnStatementSyntax:
return(ReturnStatement.Print(returnStatementSyntax));
case SelectClauseSyntax selectClauseSyntax:
return(SelectClause.Print(selectClauseSyntax));
case SimpleBaseTypeSyntax simpleBaseTypeSyntax:
return(SimpleBaseType.Print(simpleBaseTypeSyntax));
case SimpleLambdaExpressionSyntax simpleLambdaExpressionSyntax:
return(SimpleLambdaExpression.Print(simpleLambdaExpressionSyntax));
case SingleVariableDesignationSyntax singleVariableDesignationSyntax:
return(SingleVariableDesignation.Print(singleVariableDesignationSyntax));
case SizeOfExpressionSyntax sizeOfExpressionSyntax:
return(SizeOfExpression.Print(sizeOfExpressionSyntax));
case StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax:
return(StackAllocArrayCreationExpression.Print(
stackAllocArrayCreationExpressionSyntax
));
case SwitchExpressionSyntax switchExpressionSyntax:
return(SwitchExpression.Print(switchExpressionSyntax));
case SwitchSectionSyntax switchSectionSyntax:
return(SwitchSection.Print(switchSectionSyntax));
case SwitchStatementSyntax switchStatementSyntax:
return(SwitchStatement.Print(switchStatementSyntax));
case ThisExpressionSyntax thisExpressionSyntax:
return(ThisExpression.Print(thisExpressionSyntax));
case ThrowExpressionSyntax throwExpressionSyntax:
return(ThrowExpression.Print(throwExpressionSyntax));
case ThrowStatementSyntax throwStatementSyntax:
return(ThrowStatement.Print(throwStatementSyntax));
case TryStatementSyntax tryStatementSyntax:
return(TryStatement.Print(tryStatementSyntax));
case TupleElementSyntax tupleElementSyntax:
return(TupleElement.Print(tupleElementSyntax));
case TupleExpressionSyntax tupleExpressionSyntax:
return(TupleExpression.Print(tupleExpressionSyntax));
case TupleTypeSyntax tupleTypeSyntax:
return(TupleType.Print(tupleTypeSyntax));
case TypeArgumentListSyntax typeArgumentListSyntax:
return(TypeArgumentList.Print(typeArgumentListSyntax));
case TypeConstraintSyntax typeConstraintSyntax:
return(TypeConstraint.Print(typeConstraintSyntax));
case TypeOfExpressionSyntax typeOfExpressionSyntax:
return(TypeOfExpression.Print(typeOfExpressionSyntax));
case TypeParameterConstraintClauseSyntax typeParameterConstraintClauseSyntax:
return(TypeParameterConstraintClause.Print(
typeParameterConstraintClauseSyntax
));
case TypeParameterListSyntax typeParameterListSyntax:
return(TypeParameterList.Print(typeParameterListSyntax));
case TypeParameterSyntax typeParameterSyntax:
return(TypeParameter.Print(typeParameterSyntax));
case TypePatternSyntax typePatternSyntax:
return(TypePattern.Print(typePatternSyntax));
case UnaryPatternSyntax unaryPatternSyntax:
return(UnaryPattern.Print(unaryPatternSyntax));
case UnsafeStatementSyntax unsafeStatementSyntax:
return(UnsafeStatement.Print(unsafeStatementSyntax));
case UsingDirectiveSyntax usingDirectiveSyntax:
return(UsingDirective.Print(usingDirectiveSyntax));
case UsingStatementSyntax usingStatementSyntax:
return(UsingStatement.Print(usingStatementSyntax));
case VariableDeclarationSyntax variableDeclarationSyntax:
return(VariableDeclaration.Print(variableDeclarationSyntax));
case VariableDeclaratorSyntax variableDeclaratorSyntax:
return(VariableDeclarator.Print(variableDeclaratorSyntax));
case VarPatternSyntax varPatternSyntax:
return(VarPattern.Print(varPatternSyntax));
case WhenClauseSyntax whenClauseSyntax:
return(WhenClause.Print(whenClauseSyntax));
case WhereClauseSyntax whereClauseSyntax:
return(WhereClause.Print(whereClauseSyntax));
case WhileStatementSyntax whileStatementSyntax:
return(WhileStatement.Print(whileStatementSyntax));
case WithExpressionSyntax withExpressionSyntax:
return(WithExpression.Print(withExpressionSyntax));
case YieldStatementSyntax yieldStatementSyntax:
return(YieldStatement.Print(yieldStatementSyntax));
default:
throw new Exception("Can't handle " + syntaxNode.GetType().Name);
}
}
finally
{
depth--;
}
}
