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