public CSharpSyntaxNode Convert(PrefixUnaryExpression node)
{
SyntaxKind operatorKind = this.GetPrefixUnaryExpressionKind(node.Operator);
if (operatorKind != SyntaxKind.None)
{
return(SyntaxFactory.PrefixUnaryExpression(operatorKind, node.Operand.ToCsNode <ExpressionSyntax>()));
}
return(null);
}
public override void VisitPrefixUnaryExpression(PrefixUnaryExpression expression)
{
Visit(expression.Operand);
}
public virtual void VisitPrefixUnaryExpression(PrefixUnaryExpression expression)
{
}
public virtual void VisitPrefixUnaryExpression(PrefixUnaryExpression node)
{
node.Operand.Accept(this);
}
/// <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 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--;
}
}
public override T VisitPrefixUnaryExpression(PrefixUnaryExpression node)
{
throw new NotImplementedException();
}
