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));
}
