static dynamic handle(ElementAccessExpression v) { var index = handle_dyn(v.Expressions[0]); //1-dimensional arrays only dynamic array = null; if (!(v is PrimaryExpression)) { string Identifier = ((dynamic)v.LeftSide).Identifier; if (executingFunction.Localvars.has(Identifier)) { array = executingFunction.Localvars[Identifier].value; } else if (executingFunction.Params.has(Identifier)) { array = executingFunction.Params[Identifier].value; } else if (executingClass.fields.has(Identifier)) { array = executingClass.fields[Identifier].value; } } else //evaluate something like creating a new array right there. { array = handle_dyn(v.LeftSide); } return(array[index]); }
protected override IPhpValue VisitElementAccessExpression(ElementAccessExpression src) { var expression = TransValue(src.Expression); var arg = src.Arguments.Select(i => TransValue(i)).ToArray(); var a = new PhpElementAccessExpression(expression, arg); return(SimplifyPhpExpression(a)); }
protected override IValue VisitElementAccessExpression(ElementAccessExpressionSyntax node) { var expression = Visit(node.Expression); var aa = _internalVisitArgumentList(node.ArgumentList); Type elementType = TypesUtil.GetElementType(expression.ValueType); var g = new ElementAccessExpression(expression, aa, elementType); return(Simplify(g)); }
public CSharpSyntaxNode Convert(ElementAccessExpression node) { return(SyntaxFactory .ElementAccessExpression(node.Expression.ToCsNode <ExpressionSyntax>()) .AddArgumentListArguments(this.ToArgumentList(new List <Node>() { node.ArgumentExpression }))); }
public CSharpSyntaxNode Convert(DeleteExpression node) { if (node.Expression.Kind == NodeKind.ElementAccessExpression) { ElementAccessExpression elementAccessNode = node.Expression as ElementAccessExpression; MemberAccessExpressionSyntax csPropertyAccess = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, elementAccessNode.Expression.ToCsNode <ExpressionSyntax>(), SyntaxFactory.IdentifierName("Remove")); return(SyntaxFactory .InvocationExpression(csPropertyAccess) .AddArgumentListArguments(this.ToArgumentList(new List <Node>() { elementAccessNode.ArgumentExpression }))); } //TODO: NOT SUPPORT return(SyntaxFactory.ParseExpression(this.CommentText(node.Text))); }
/// <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 Expression parse(int precedence = 0, bool required = true) { this.reader.skipWhitespace(); var leftStart = this.reader.offset; var left = this.parseLeft(required); if (left == null) { return(null); } this.addNode(left, leftStart); while (true) { if (this.hooks != null) { var parsed = this.hooks.infixPrehook(left); if (parsed != null) { left = parsed; this.addNode(left, leftStart); continue; } } var op = this.parseOperator(); if (op == null || op.precedence <= precedence) { break; } this.reader.expectToken(op.text); var opText = this.config.aliases.hasKey(op.text) ? this.config.aliases.get(op.text) : op.text; if (op.isBinary) { var right = this.parse(op.isRightAssoc ? op.precedence - 1 : op.precedence); left = new BinaryExpression(left, opText, right); } else if (op.isPostfix) { left = new UnaryExpression(UnaryType.Postfix, opText, left); } else if (op.text == "?") { var whenTrue = this.parse(); this.reader.expectToken(":"); var whenFalse = this.parse(op.precedence - 1); left = new ConditionalExpression(left, whenTrue, whenFalse); } else if (op.text == "(") { var args = this.parseCallArguments(); left = new UnresolvedCallExpression(left, new IType[0], args); } else if (op.text == "[") { var elementExpr = this.parse(); this.reader.expectToken("]"); left = new ElementAccessExpression(left, elementExpr); } else if (this.config.propertyAccessOps.includes(op.text)) { var prop = this.reader.expectIdentifier("expected identifier as property name"); left = new PropertyAccessExpression(left, prop); } else { this.reader.fail($"parsing '{op.text}' is not yet implemented"); } this.addNode(left, leftStart); } if (left is ParenthesizedExpression parExpr && parExpr.expression is Identifier ident) { var expr = this.parse(0, false); if (expr != null) { return(new CastExpression(new UnresolvedType(ident.text, new IType[0]), expr)); } } return(left); }
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--; } }