public override void VisitSafeCastExpression(SafeCastExpression node)
{
Visit(node.Expression);
WriteSpace();
WriteKeyword("as");
WriteSpace();
WriteReference(node.TargetType);
}
protected override bool OnMatch(MatchContext context, SafeCastExpression node)
{
if (!TargetType.TryMatch(context, node.TargetType))
{
return(false);
}
return(Expression.TryMatch(context, node.Expression));
}
private void CreateMethod(CatchClause catchClause, VariableDeclarationExpression variable, out Expression methodInvocationExpression)
{
methodInvocationExpression = null;
BlockStatement filter = catchClause.Filter as BlockStatement;
// Fixes the variable definition in the first statement.
ExpressionStatement firstStatement = filter.Statements.First() as ExpressionStatement;
BinaryExpression assignment = firstStatement.Expression as BinaryExpression;
SafeCastExpression safeCast = assignment.Right as SafeCastExpression;
VariableReferenceExpression variableReference = safeCast.Expression as VariableReferenceExpression;
variableReference.Variable = variable.Variable;
// Replace the variable reference in the last statement with return statement.
ExpressionStatement lastStatement = filter.Statements.Last() as ExpressionStatement;
lastStatement.Expression = new ReturnExpression(lastStatement.Expression, lastStatement.Expression.MappedInstructions);
int methodNumber = this.context.TypeContext.GeneratedFilterMethods.Count + this.methodsToBeDecompiled.Count;
string methodName = string.Format(Constants.JustDecompileGeneratedFilterPattern, methodNumber);
MethodDefinition method = new MethodDefinition(methodName, Mono.Cecil.MethodAttributes.Private, this.context.MethodContext.Method.Module.TypeSystem.Boolean);
method.Body = new MethodBody(method);
// Practically no chance for duplicates, because of decrementing the MaxRID
method.MetadataToken = new MetadataToken(TokenType.Method, MaxRID - (uint)methodNumber);
method.IsStatic = this.context.MethodContext.Method.IsStatic;
method.HasThis = !method.IsStatic;
method.DeclaringType = context.MethodContext.Method.DeclaringType;
method.SemanticsAttributes = MethodSemanticsAttributes.None;
method.IsJustDecompileGenerated = true;
DecompilationContext newContext = new DecompilationContext(CloneAndReplaceMethodBody(this.context.MethodContext, method.Body), this.context.TypeContext);
VariableDefinition variableDefinition = variableReference.Variable.Resolve();
if (!newContext.MethodContext.VariableDefinitionToNameMap.ContainsKey(variableDefinition))
{
newContext.MethodContext.VariableDefinitionToNameMap[variableDefinition] = Constants.JustDecompileGeneratedException;
}
else
{
newContext.MethodContext.VariableDefinitionToNameMap.Add(variableDefinition, Constants.JustDecompileGeneratedException);
}
newContext.MethodContext.VariablesToNotDeclare.Add(variable.Variable);
methodsToBeDecompiled.Add(new FilterMethodToBeDecompiled(method, catchClause, newContext, catchClause.Filter as BlockStatement));
List <Expression> parameters = AddAllParameters(catchClause, method, variable);
methodInvocationExpression = CreateMethodInvocation(method, parameters);
}
private CanCastExpression CreateCanCastExpression(Pattern.MatchContext matchContext, BinaryExpression node)
{
SafeCastExpression safeCast = (SafeCastExpression)matchContext[SafeCastKey];
List <Instruction> instructions = new List <Instruction>();
instructions.AddRange(safeCast.MappedInstructions);
instructions.AddRange(node.MappedInstructions);
instructions.AddRange(node.Right.UnderlyingSameMethodInstructions);
return(new CanCastExpression(
(Expression)codeTransformer.Visit(safeCast.Expression),
safeCast.TargetType,
instructions));
}
public virtual void VisitSafeCastExpression(SafeCastExpression node)
{
Visit(node.Expression);
}
public virtual ICodeNode VisitSafeCastExpression(SafeCastExpression node)
{
node.Expression = (Expression)Visit(node.Expression);
return(node);
}
public virtual void VisitSafeCastExpression(SafeCastExpression node)
{
this.Visit(node.get_Expression());
return;
}
public void VisitSafeCastExpression(SafeCastExpression expression)
{
Formatter.StartNode(expression);
expression.TargetExpression.AcceptVisitor(this);
Formatter.WriteSpace();
Formatter.WriteKeyword("as");
Formatter.WriteSpace();
expression.TargetType.AcceptVisitor(this);
Formatter.EndNode();
}
private static bool TryMatchVariableDeclaration(BlockStatement filter, out VariableDeclarationExpression variableDeclaration)
{
variableDeclaration = null;
ExpressionStatement firstExpressionStatement = filter.Statements[0] as ExpressionStatement;
if (firstExpressionStatement == null)
{
return(false);
}
BinaryExpression binaryExpression = firstExpressionStatement.Expression as BinaryExpression;
if (binaryExpression == null || !binaryExpression.IsAssignmentExpression)
{
return(false);
}
VariableReferenceExpression variableReference = binaryExpression.Left as VariableReferenceExpression;
if (variableReference == null)
{
return(false);
}
SafeCastExpression safeCast = binaryExpression.Right as SafeCastExpression;
if (safeCast == null)
{
return(false);
}
IfStatement ifStatement = filter.Statements[1] as IfStatement;
if (ifStatement == null)
{
return(false);
}
BinaryExpression condition = ifStatement.Condition as BinaryExpression;
if (condition == null)
{
return(false);
}
VariableReferenceExpression conditionLeft = condition.Left as VariableReferenceExpression;
if (conditionLeft == null)
{
return(false);
}
LiteralExpression conditionRight = condition.Right as LiteralExpression;
if (conditionRight == null)
{
return(false);
}
if (!conditionLeft.Equals(variableReference) || conditionRight.Value != null ||
(condition.Operator != BinaryOperator.ValueEquality && condition.Operator != BinaryOperator.ValueInequality))
{
return(false);
}
// At this point we know the type of the exception
VariableDefinition variableDefinition = variableReference.Variable.Resolve();
IEnumerable <Instruction> instructions = variableReference.MappedInstructions;
BlockStatement exceptionVariableAssignmentBlock;
if (condition.Operator == BinaryOperator.ValueInequality)
{
exceptionVariableAssignmentBlock = ifStatement.Then;
}
else // BinaryOperator.ValueEquality
{
exceptionVariableAssignmentBlock = ifStatement.Else;
}
ExpressionStatement expressionStatement = exceptionVariableAssignmentBlock.Statements[0] as ExpressionStatement;
if (!TryGetVariableDeclaration(expressionStatement, variableReference, ref variableDefinition, ref instructions))
{
if (exceptionVariableAssignmentBlock.Statements.Count >= 2)
{
expressionStatement = exceptionVariableAssignmentBlock.Statements[1] as ExpressionStatement;
TryGetVariableDeclaration(expressionStatement, variableReference, ref variableDefinition, ref instructions);
}
}
variableDeclaration = new VariableDeclarationExpression(variableDefinition, instructions);
return(true);
}
public override void VisitSafeCastExpression(SafeCastExpression node)
{
this.get_TypesDependingOn().UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.get_ExpressionType()));
this.VisitSafeCastExpression(node);
return;
}
public virtual ICodeNode VisitSafeCastExpression(SafeCastExpression node)
{
node.set_Expression((Expression)this.Visit(node.get_Expression()));
return(node);
}
public override void VisitSafeCastExpression(SafeCastExpression node)
{
TypesDependingOn.UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.ExpressionType));
base.VisitSafeCastExpression(node);
}
