protected internal Block(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable<ParameterExpression> parameters = null) : base(scope, visitor) { _blockStatement = blockStatement; InternalType = ResolveType(blockStatement); Parameters = parameters; BuildExpressions(); }
protected internal Block(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable <ParameterExpression> parameters = null) : base(scope, visitor) { _blockStatement = blockStatement; InternalType = ResolveType(blockStatement); Parameters = parameters; BuildExpressions(); }
public static ConstructorBlock ConstructorBlock(NRefactory.BlockStatement blockStatement, ParameterExpression contextParameter, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable <ParameterExpression> parameters = null, IEnumerable <ParameterExpression> baseConstructorParameters = null) { return(new ConstructorBlock(blockStatement, contextParameter, parameters: parameters, scope: scope, visitor: visitor, baseConstructorParameters: baseConstructorParameters)); }
public MethodBlock(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable <ParameterExpression> parameters = null) : base(blockStatement, parameters: parameters, scope: scope, visitor: visitor) { var registry = RootScope.BranchingRegistry; if (registry.HasReturnLabel) { AddReturnLabelExpression(); } }
public override Type ResolveType(NRefactory.BlockStatement blockStatement) { var methodDeclaration = blockStatement.Parent as NRefactory.MethodDeclaration; if (methodDeclaration != null) { return(methodDeclaration.GetReturnType()); } return(null); }
protected override Expression CreateBody(NRefactory.BlockStatement blockStatement, IEnumerable <ParameterExpression> parameters, IScope scope, INRefcatoryExpressionVisitor visitor) { IEnumerable <ParameterExpression> baseExpressionsParameters = null; if (!BaseConstructorParameters.IsNullOrEmpty()) { baseExpressionsParameters = BaseConstructorParameters.Select(p => Expression.Parameter(p.Type, p.Name)); } return(AstExpression.ConstructorBlock(blockStatement, ContextParameter, parameters: parameters, scope: scope, visitor: visitor, baseConstructorParameters: baseExpressionsParameters)); }
public ConstructorBlock(NRefactory.BlockStatement blockStatement, ParameterExpression contextParameter, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable <ParameterExpression> parameters, IEnumerable <ParameterExpression> baseConstructorParameters) : base(blockStatement, parameters: parameters, scope: scope, visitor: visitor) { _baseConstructorParameters = baseConstructorParameters; AddNewContextCreationExpression(contextParameter); InternalType = contextParameter.Type; AddReturnLabelExpression(); }
private static NRefactory.ConstructorDeclaration FiltertConstructorStatements(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType) { var block = new NRefactory.BlockStatement(); foreach (var statement in constructorDeclaration.Body.Statements) { var expression = statement as NRefactory.ExpressionStatement; if (expression != null) { if (expression.Expression is NRefactory.AssignmentExpression) { continue; } var invocation = expression.Expression as NRefactory.InvocationExpression; block.Add(statement.Clone()); if (invocation != null && invocation.HasAnnotationOf <Cecil.MethodReference>()) { var methodReference = invocation.Annotation <Cecil.MethodReference>(); if (methodReference.Name.Equals(".ctor") && methodReference.DeclaringType.GetActualType().Equals(baseType)) { block.AddReturnStatement(new NRefactory.ThisReferenceExpression()); constructorDeclaration.Body = block; break; } } } else { block.Add(statement.Clone()); } } return(constructorDeclaration); }
protected virtual Expression CreateBody(NRefactory.BlockStatement blockStatement, IEnumerable <ParameterExpression> parameters, IScope scope, INRefcatoryExpressionVisitor visitor) { return(AstExpression.MethodBlock(blockStatement, parameters: parameters, scope: this, visitor: visitor)); }
public virtual S VisitBlockStatement(BlockStatement blockStatement, T data) { return(VisitChildren(blockStatement, data)); }
public AnonymousMethodExpression(BlockStatement body, params ParameterDeclaration[] parameters) : this(body, (IEnumerable <ParameterDeclaration>)parameters) { }
private void BuildTryBlock(NRefactory.BlockStatement tryBlock) { Body = tryBlock.AcceptVisitor(Visitor, this); }
private void BuildFinallyBlock(NRefactory.BlockStatement finallyBlack) { Finally = finallyBlack.AcceptVisitor(Visitor, this); }
private static NRefactory.ConstructorDeclaration FiltertConstructorStatements(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType) { var block = new NRefactory.BlockStatement(); foreach (var statement in constructorDeclaration.Body.Statements) { var expression = statement as NRefactory.ExpressionStatement; if (expression != null) { if (expression.Expression is NRefactory.AssignmentExpression) { continue; } var invocation = expression.Expression as NRefactory.InvocationExpression; block.Add(statement.Clone()); if (invocation != null && invocation.HasAnnotationOf<Cecil.MethodReference>()) { var methodReference = invocation.Annotation<Cecil.MethodReference>(); if (methodReference.Name.Equals(".ctor") && methodReference.DeclaringType.GetActualType().Equals(baseType)) { block.AddReturnStatement(new NRefactory.ThisReferenceExpression()); constructorDeclaration.Body = block; break; } } } else { block.Add(statement.Clone()); } } return constructorDeclaration; }
public virtual Type ResolveType(NRefactory.BlockStatement blockStatement) { return(TypeSystem.Void); }
public virtual S VisitBlockStatement(BlockStatement blockStatement, T data) { throw new NotImplementedException(); }
void IAstVisitor.VisitBlockStatement(BlockStatement blockStatement) { Visit(EnterBlockStatement, LeaveBlockStatement, blockStatement); }
public override void VisitBlockStatement(BlockStatement blockStatement) { FixIndentation(blockStatement); VisitBlockWithoutFixingBraces(blockStatement, policy.IndentBlocks); FixIndentation(blockStatement.RBraceToken); }
void FixEmbeddedStatment(BraceStyle braceStyle, CSharpTokenNode token, bool allowInLine, AstNode node, bool statementAlreadyIndented = false) { if (node == null) { return; } bool isBlock = node is BlockStatement; FormattingChanges.TextReplaceAction beginBraceAction = null; FormattingChanges.TextReplaceAction endBraceAction = null; BlockStatement closeBlockToBeFixed = null; if (isBlock) { BlockStatement block = node as BlockStatement; if (allowInLine && block.StartLocation.Line == block.EndLocation.Line && block.Statements.Count() <= 1) { if (block.Statements.Count() == 1) { nextStatementIndent = " "; } } else { if (!statementAlreadyIndented) { FixOpenBrace(braceStyle, block.LBraceToken); } closeBlockToBeFixed = block; } if (braceStyle == BraceStyle.NextLineShifted2) { curIndent.Push(IndentType.Block); } } else { if (allowInLine && token.StartLocation.Line == node.EndLocation.Line) { nextStatementIndent = " "; } } bool pushed = false; if (policy.IndentBlocks && !(policy.AlignEmbeddedIfStatements && node is IfElseStatement && node.Parent is IfElseStatement || policy.AlignEmbeddedUsingStatements && node is UsingStatement && node.Parent is UsingStatement)) { curIndent.Push(IndentType.Block); pushed = true; } if (isBlock) { VisitBlockWithoutFixingBraces((BlockStatement)node, false); } else { if (!statementAlreadyIndented) { PlaceOnNewLine(policy.EmbeddedStatementPlacement, node); nextStatementIndent = null; } node.AcceptVisitor(this); } if (pushed) { curIndent.Pop(); } if (beginBraceAction != null && endBraceAction != null) { beginBraceAction.DependsOn = endBraceAction; endBraceAction.DependsOn = beginBraceAction; } if (isBlock && braceStyle == BraceStyle.NextLineShifted2) { curIndent.Pop(); } if (closeBlockToBeFixed != null) { FixClosingBrace(braceStyle, closeBlockToBeFixed.RBraceToken); } }
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) { BlockStatement o = other as BlockStatement; return(o != null && !o.IsNull && this.Statements.DoMatch(o.Statements, match)); }
public static MethodBlock MethodBlock(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable <ParameterExpression> parameters = null) { return(new MethodBlock(blockStatement, parameters: parameters, scope: scope, visitor: visitor)); }
public override AstExpression VisitBlockStatement(NRefactory.BlockStatement blockStatement, IScope scope) { return(AstExpression.Block(blockStatement, scope, this)); }