pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

rename ConvertedExpression to TranslatedExpression and Convert to Translate, etc.

pull/728/head
Siegfried Pammer 11 years ago
parent
7f36725b6f
commit
bc68339ac4
6 changed files with 93 additions and 95 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      ICSharpCode.Decompiler/CSharp/Annotations.cs
  2. 130
      ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
  3. 12
      ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
  4. 4
      ICSharpCode.Decompiler/CSharp/Transforms/ConvertConstructorCallIntoInitializer.cs
  5. 24
      ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs
  6. 6
      ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

12
ICSharpCode.Decompiler/CSharp/Annotations.cs
Unescape View File

@ -51,15 +51,15 @@ namespace ICSharpCode.Decompiler.CSharp
return new ExpressionWithILInstruction(expression); return new ExpressionWithILInstruction(expression);
} }
public static ConvertedExpression WithILInstruction(this ExpressionWithResolveResult expression, ILInstruction instruction) public static TranslatedExpression WithILInstruction(this ExpressionWithResolveResult expression, ILInstruction instruction)
{ {
expression.Expression.AddAnnotation(instruction); expression.Expression.AddAnnotation(instruction);
return new ConvertedExpression(expression.Expression, expression.ResolveResult); return new TranslatedExpression(expression.Expression, expression.ResolveResult);
} }
public static ConvertedExpression WithoutILInstruction(this ExpressionWithResolveResult expression) public static TranslatedExpression WithoutILInstruction(this ExpressionWithResolveResult expression)
{ {
return new ConvertedExpression(expression.Expression, expression.ResolveResult); return new TranslatedExpression(expression.Expression, expression.ResolveResult);
} }
public static ExpressionWithResolveResult WithRR(this Expression expression, ResolveResult resolveResult) public static ExpressionWithResolveResult WithRR(this Expression expression, ResolveResult resolveResult)
@ -68,10 +68,10 @@ namespace ICSharpCode.Decompiler.CSharp
return new ExpressionWithResolveResult(expression, resolveResult); return new ExpressionWithResolveResult(expression, resolveResult);
} }
public static ConvertedExpression WithRR(this ExpressionWithILInstruction expression, ResolveResult resolveResult) public static TranslatedExpression WithRR(this ExpressionWithILInstruction expression, ResolveResult resolveResult)
{ {
expression.Expression.AddAnnotation(resolveResult); expression.Expression.AddAnnotation(resolveResult);
return new ConvertedExpression(expression, resolveResult); return new TranslatedExpression(expression, resolveResult);
} }
/// <summary> /// <summary>

130
ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs
Unescape View File

@ -35,7 +35,7 @@ namespace ICSharpCode.Decompiler.CSharp
/// <summary> /// <summary>
/// Translates from ILAst to C# expressions. /// Translates from ILAst to C# expressions.
/// </summary> /// </summary>
class ExpressionBuilder : ILVisitor<ConvertedExpression> class ExpressionBuilder : ILVisitor<TranslatedExpression>
{ {
internal readonly ICompilation compilation; internal readonly ICompilation compilation;
internal readonly NRefactoryCecilMapper cecilMapper; internal readonly NRefactoryCecilMapper cecilMapper;
@ -67,7 +67,7 @@ namespace ICSharpCode.Decompiler.CSharp
return astType; return astType;
} }
public ConvertedExpression Convert(ILInstruction inst) public TranslatedExpression Translate(ILInstruction inst)
{ {
Debug.Assert(inst != null); Debug.Assert(inst != null);
var cexpr = inst.AcceptVisitor(this); var cexpr = inst.AcceptVisitor(this);
@ -75,9 +75,9 @@ namespace ICSharpCode.Decompiler.CSharp
return cexpr; return cexpr;
} }
public ConvertedExpression ConvertCondition(ILInstruction condition) public TranslatedExpression TranslateCondition(ILInstruction condition)
{ {
var expr = Convert(condition); var expr = Translate(condition);
return expr.ConvertToBoolean(this); return expr.ConvertToBoolean(this);
} }
@ -103,81 +103,81 @@ namespace ICSharpCode.Decompiler.CSharp
return expr.WithRR(new ResolveResult(cecilMapper.GetType(variable.Type))); return expr.WithRR(new ResolveResult(cecilMapper.GetType(variable.Type)));
} }
ConvertedExpression IsType(IsInst inst) TranslatedExpression IsType(IsInst inst)
{ {
var arg = Convert(inst.Argument); var arg = Translate(inst.Argument);
var type = cecilMapper.GetType(inst.Type); var type = cecilMapper.GetType(inst.Type);
return new IsExpression(arg.Expression, ConvertType(type)) return new IsExpression(arg.Expression, ConvertType(type))
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new TypeIsResolveResult(arg.ResolveResult, type, compilation.FindType(TypeCode.Boolean))); .WithRR(new TypeIsResolveResult(arg.ResolveResult, type, compilation.FindType(TypeCode.Boolean)));
} }
protected internal override ConvertedExpression VisitIsInst(IsInst inst) protected internal override TranslatedExpression VisitIsInst(IsInst inst)
{ {
var arg = Convert(inst.Argument); var arg = Translate(inst.Argument);
var type = cecilMapper.GetType(inst.Type); var type = cecilMapper.GetType(inst.Type);
return new AsExpression(arg.Expression, ConvertType(type)) return new AsExpression(arg.Expression, ConvertType(type))
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConversionResolveResult(type, arg.ResolveResult, Conversion.TryCast)); .WithRR(new ConversionResolveResult(type, arg.ResolveResult, Conversion.TryCast));
} }
protected internal override ConvertedExpression VisitNewObj(NewObj inst) protected internal override TranslatedExpression VisitNewObj(NewObj inst)
{ {
return HandleCallInstruction(inst); return HandleCallInstruction(inst);
} }
protected internal override ConvertedExpression VisitLdcI4(LdcI4 inst) protected internal override TranslatedExpression VisitLdcI4(LdcI4 inst)
{ {
return new PrimitiveExpression(inst.Value) return new PrimitiveExpression(inst.Value)
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), inst.Value)); .WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), inst.Value));
} }
protected internal override ConvertedExpression VisitLdcI8(LdcI8 inst) protected internal override TranslatedExpression VisitLdcI8(LdcI8 inst)
{ {
return new PrimitiveExpression(inst.Value) return new PrimitiveExpression(inst.Value)
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int64), inst.Value)); .WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int64), inst.Value));
} }
protected internal override ConvertedExpression VisitLdcF(LdcF inst) protected internal override TranslatedExpression VisitLdcF(LdcF inst)
{ {
return new PrimitiveExpression(inst.Value) return new PrimitiveExpression(inst.Value)
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Double), inst.Value)); .WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.Double), inst.Value));
} }
protected internal override ConvertedExpression VisitLdStr(LdStr inst) protected internal override TranslatedExpression VisitLdStr(LdStr inst)
{ {
return new PrimitiveExpression(inst.Value) return new PrimitiveExpression(inst.Value)
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.String), inst.Value)); .WithRR(new ConstantResolveResult(compilation.FindType(KnownTypeCode.String), inst.Value));
} }
protected internal override ConvertedExpression VisitLdNull(LdNull inst) protected internal override TranslatedExpression VisitLdNull(LdNull inst)
{ {
return new NullReferenceExpression() return new NullReferenceExpression()
.WithILInstruction(inst) .WithILInstruction(inst)
.WithRR(new ConstantResolveResult(SpecialType.UnknownType, null)); .WithRR(new ConstantResolveResult(SpecialType.UnknownType, null));
} }
protected internal override ConvertedExpression VisitLogicNot(LogicNot inst) protected internal override TranslatedExpression VisitLogicNot(LogicNot inst)
{ {
return LogicNot(ConvertCondition(inst.Argument)).WithILInstruction(inst); return LogicNot(TranslateCondition(inst.Argument)).WithILInstruction(inst);
} }
ExpressionWithResolveResult LogicNot(ConvertedExpression expr) ExpressionWithResolveResult LogicNot(TranslatedExpression expr)
{ {
return new UnaryOperatorExpression(UnaryOperatorType.Not, expr.Expression) return new UnaryOperatorExpression(UnaryOperatorType.Not, expr.Expression)
.WithRR(new OperatorResolveResult(compilation.FindType(KnownTypeCode.Boolean), ExpressionType.Not)); .WithRR(new OperatorResolveResult(compilation.FindType(KnownTypeCode.Boolean), ExpressionType.Not));
} }
protected internal override ConvertedExpression VisitLdLoc(LdLoc inst) protected internal override TranslatedExpression VisitLdLoc(LdLoc inst)
{ {
return ConvertVariable(inst.Variable).WithILInstruction(inst); return ConvertVariable(inst.Variable).WithILInstruction(inst);
} }
protected internal override ConvertedExpression VisitLdLoca(LdLoca inst) protected internal override TranslatedExpression VisitLdLoca(LdLoca inst)
{ {
var expr = ConvertVariable(inst.Variable).WithILInstruction(inst); var expr = ConvertVariable(inst.Variable).WithILInstruction(inst);
// Note that we put the instruction on the IdentifierExpression instead of the DirectionExpression, // Note that we put the instruction on the IdentifierExpression instead of the DirectionExpression,
@ -187,12 +187,12 @@ namespace ICSharpCode.Decompiler.CSharp
.WithRR(new ByReferenceResolveResult(expr.ResolveResult, isOut: false)); .WithRR(new ByReferenceResolveResult(expr.ResolveResult, isOut: false));
} }
protected internal override ConvertedExpression VisitStLoc(StLoc inst) protected internal override TranslatedExpression VisitStLoc(StLoc inst)
{ {
return Assignment(ConvertVariable(inst.Variable).WithoutILInstruction(), Convert(inst.Value)).WithILInstruction(inst); return Assignment(ConvertVariable(inst.Variable).WithoutILInstruction(), Translate(inst.Value)).WithILInstruction(inst);
} }
protected internal override ConvertedExpression VisitCeq(Ceq inst) protected internal override TranslatedExpression VisitCeq(Ceq inst)
{ {
// Translate '(e as T) == null' to '!(e is T)'. // Translate '(e as T) == null' to '!(e is T)'.
// This is necessary for correctness when T is a value type. // This is necessary for correctness when T is a value type.
@ -202,8 +202,8 @@ namespace ICSharpCode.Decompiler.CSharp
return LogicNot(IsType((IsInst)inst.Right)).WithILInstruction(inst); return LogicNot(IsType((IsInst)inst.Right)).WithILInstruction(inst);
} }
var left = Convert(inst.Left); var left = Translate(inst.Left);
var right = Convert(inst.Right); var right = Translate(inst.Right);
// Remove redundant bool comparisons // Remove redundant bool comparisons
if (left.Type.IsKnownType(KnownTypeCode.Boolean)) { if (left.Type.IsKnownType(KnownTypeCode.Boolean)) {
@ -227,30 +227,30 @@ namespace ICSharpCode.Decompiler.CSharp
.WithRR(rr); .WithRR(rr);
} }
protected internal override ConvertedExpression VisitClt(Clt inst) protected internal override TranslatedExpression VisitClt(Clt inst)
{ {
return Comparison(inst, BinaryOperatorType.LessThan); return Comparison(inst, BinaryOperatorType.LessThan);
} }
protected internal override ConvertedExpression VisitCgt(Cgt inst) protected internal override TranslatedExpression VisitCgt(Cgt inst)
{ {
return Comparison(inst, BinaryOperatorType.GreaterThan); return Comparison(inst, BinaryOperatorType.GreaterThan);
} }
protected internal override ConvertedExpression VisitClt_Un(Clt_Un inst) protected internal override TranslatedExpression VisitClt_Un(Clt_Un inst)
{ {
return Comparison(inst, BinaryOperatorType.LessThan, un: true); return Comparison(inst, BinaryOperatorType.LessThan, un: true);
} }
protected internal override ConvertedExpression VisitCgt_Un(Cgt_Un inst) protected internal override TranslatedExpression VisitCgt_Un(Cgt_Un inst)
{ {
return Comparison(inst, BinaryOperatorType.GreaterThan, un: true); return Comparison(inst, BinaryOperatorType.GreaterThan, un: true);
} }
ConvertedExpression Comparison(BinaryComparisonInstruction inst, BinaryOperatorType op, bool un = false) TranslatedExpression Comparison(BinaryComparisonInstruction inst, BinaryOperatorType op, bool un = false)
{ {
var left = Convert(inst.Left); var left = Translate(inst.Left);
var right = Convert(inst.Right); var right = Translate(inst.Right);
// TODO: ensure the arguments are signed // TODO: ensure the arguments are signed
// or with _Un: ensure the arguments are unsigned; and that float comparisons are performed unordered // or with _Un: ensure the arguments are unsigned; and that float comparisons are performed unordered
return new BinaryOperatorExpression(left.Expression, op, right.Expression) return new BinaryOperatorExpression(left.Expression, op, right.Expression)
@ -260,68 +260,68 @@ namespace ICSharpCode.Decompiler.CSharp
left.ResolveResult, right.ResolveResult)); left.ResolveResult, right.ResolveResult));
} }
ExpressionWithResolveResult Assignment(ConvertedExpression left, ConvertedExpression right) ExpressionWithResolveResult Assignment(TranslatedExpression left, TranslatedExpression right)
{ {
right = right.ConvertTo(left.Type, this); right = right.ConvertTo(left.Type, this);
return new AssignmentExpression(left.Expression, right.Expression) return new AssignmentExpression(left.Expression, right.Expression)
.WithRR(new OperatorResolveResult(left.Type, ExpressionType.Assign, left.ResolveResult, right.ResolveResult)); .WithRR(new OperatorResolveResult(left.Type, ExpressionType.Assign, left.ResolveResult, right.ResolveResult));
} }
protected internal override ConvertedExpression VisitAdd(Add inst) protected internal override TranslatedExpression VisitAdd(Add inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.Add); return HandleBinaryNumeric(inst, BinaryOperatorType.Add);
} }
protected internal override ConvertedExpression VisitSub(Sub inst) protected internal override TranslatedExpression VisitSub(Sub inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.Subtract); return HandleBinaryNumeric(inst, BinaryOperatorType.Subtract);
} }
protected internal override ConvertedExpression VisitMul(Mul inst) protected internal override TranslatedExpression VisitMul(Mul inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.Multiply); return HandleBinaryNumeric(inst, BinaryOperatorType.Multiply);
} }
protected internal override ConvertedExpression VisitDiv(Div inst) protected internal override TranslatedExpression VisitDiv(Div inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.Divide); return HandleBinaryNumeric(inst, BinaryOperatorType.Divide);
} }
protected internal override ConvertedExpression VisitRem(Rem inst) protected internal override TranslatedExpression VisitRem(Rem inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.Modulus); return HandleBinaryNumeric(inst, BinaryOperatorType.Modulus);
} }
protected internal override ConvertedExpression VisitBitXor(BitXor inst) protected internal override TranslatedExpression VisitBitXor(BitXor inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.ExclusiveOr); return HandleBinaryNumeric(inst, BinaryOperatorType.ExclusiveOr);
} }
protected internal override ConvertedExpression VisitBitAnd(BitAnd inst) protected internal override TranslatedExpression VisitBitAnd(BitAnd inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.BitwiseAnd); return HandleBinaryNumeric(inst, BinaryOperatorType.BitwiseAnd);
} }
protected internal override ConvertedExpression VisitBitOr(BitOr inst) protected internal override TranslatedExpression VisitBitOr(BitOr inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.BitwiseOr); return HandleBinaryNumeric(inst, BinaryOperatorType.BitwiseOr);
} }
protected internal override ConvertedExpression VisitShl(Shl inst) protected internal override TranslatedExpression VisitShl(Shl inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.ShiftLeft); return HandleBinaryNumeric(inst, BinaryOperatorType.ShiftLeft);
} }
protected internal override ConvertedExpression VisitShr(Shr inst) protected internal override TranslatedExpression VisitShr(Shr inst)
{ {
return HandleBinaryNumeric(inst, BinaryOperatorType.ShiftRight); return HandleBinaryNumeric(inst, BinaryOperatorType.ShiftRight);
} }
ConvertedExpression HandleBinaryNumeric(BinaryNumericInstruction inst, BinaryOperatorType op) TranslatedExpression HandleBinaryNumeric(BinaryNumericInstruction inst, BinaryOperatorType op)
{ {
var resolverWithOverflowCheck = resolver.WithCheckForOverflow(inst.CheckForOverflow); var resolverWithOverflowCheck = resolver.WithCheckForOverflow(inst.CheckForOverflow);
var left = Convert(inst.Left); var left = Translate(inst.Left);
var right = Convert(inst.Right); var right = Translate(inst.Right);
var rr = resolverWithOverflowCheck.ResolveBinaryOperator(op, left.ResolveResult, right.ResolveResult); var rr = resolverWithOverflowCheck.ResolveBinaryOperator(op, left.ResolveResult, right.ResolveResult);
if (rr.IsError || rr.Type.GetStackType() != inst.ResultType if (rr.IsError || rr.Type.GetStackType() != inst.ResultType
|| !IsCompatibleWithSign(left.Type, inst.Sign) || !IsCompatibleWithSign(right.Type, inst.Sign)) || !IsCompatibleWithSign(left.Type, inst.Sign) || !IsCompatibleWithSign(right.Type, inst.Sign))
@ -346,9 +346,9 @@ namespace ICSharpCode.Decompiler.CSharp
return sign == Sign.None || type.GetSign() == sign; return sign == Sign.None || type.GetSign() == sign;
} }
protected internal override ConvertedExpression VisitConv(Conv inst) protected internal override TranslatedExpression VisitConv(Conv inst)
{ {
var arg = Convert(inst.Argument); var arg = Translate(inst.Argument);
if (arg.Type.GetSign() != inst.Sign) { if (arg.Type.GetSign() != inst.Sign) {
// we need to cast the input to a type of appropriate sign // we need to cast the input to a type of appropriate sign
var inputType = inst.Argument.ResultType.ToKnownTypeCode(inst.Sign); var inputType = inst.Argument.ResultType.ToKnownTypeCode(inst.Sign);
@ -361,23 +361,23 @@ namespace ICSharpCode.Decompiler.CSharp
.WithRR(rr); .WithRR(rr);
} }
protected internal override ConvertedExpression VisitCall(Call inst) protected internal override TranslatedExpression VisitCall(Call inst)
{ {
return HandleCallInstruction(inst); return HandleCallInstruction(inst);
} }
protected internal override ConvertedExpression VisitCallVirt(CallVirt inst) protected internal override TranslatedExpression VisitCallVirt(CallVirt inst)
{ {
return HandleCallInstruction(inst); return HandleCallInstruction(inst);
} }
ConvertedExpression HandleCallInstruction(CallInstruction inst) TranslatedExpression HandleCallInstruction(CallInstruction inst)
{ {
// Used for Call, CallVirt and NewObj // Used for Call, CallVirt and NewObj
var method = cecilMapper.GetMethod(inst.Method); var method = cecilMapper.GetMethod(inst.Method);
ConvertedExpression target; TranslatedExpression target;
if (inst.OpCode == OpCode.NewObj) { if (inst.OpCode == OpCode.NewObj) {
target = default(ConvertedExpression); // no target target = default(TranslatedExpression); // no target
} else if (inst.Method.HasThis) { } else if (inst.Method.HasThis) {
var argInstruction = inst.Arguments[0]; var argInstruction = inst.Arguments[0];
if (inst.OpCode == OpCode.Call && argInstruction.MatchLdThis()) { if (inst.OpCode == OpCode.Call && argInstruction.MatchLdThis()) {
@ -385,7 +385,7 @@ namespace ICSharpCode.Decompiler.CSharp
.WithILInstruction(argInstruction) .WithILInstruction(argInstruction)
.WithRR(new ThisResolveResult(cecilMapper.GetType(inst.Method.DeclaringType), causesNonVirtualInvocation: true)); .WithRR(new ThisResolveResult(cecilMapper.GetType(inst.Method.DeclaringType), causesNonVirtualInvocation: true));
} else { } else {
target = Convert(argInstruction); target = Translate(argInstruction);
} }
} else { } else {
var declaringType = cecilMapper.GetType(inst.Method.DeclaringType); var declaringType = cecilMapper.GetType(inst.Method.DeclaringType);
@ -394,12 +394,12 @@ namespace ICSharpCode.Decompiler.CSharp
.WithRR(new TypeResolveResult(declaringType)); .WithRR(new TypeResolveResult(declaringType));
} }
var arguments = inst.Arguments.SelectArray(Convert); var arguments = inst.Arguments.SelectArray(Translate);
int firstParamIndex = (inst.Method.HasThis && inst.OpCode != OpCode.NewObj) ? 1 : 0; int firstParamIndex = (inst.Method.HasThis && inst.OpCode != OpCode.NewObj) ? 1 : 0;
Debug.Assert(arguments.Length == firstParamIndex + inst.Method.Parameters.Count); Debug.Assert(arguments.Length == firstParamIndex + inst.Method.Parameters.Count);
ResolveResult rr; ResolveResult rr;
if (method != null) { if (method != null) {
// Convert arguments to the expected parameter types // Translate arguments to the expected parameter types
Debug.Assert(arguments.Length == firstParamIndex + method.Parameters.Count); Debug.Assert(arguments.Length == firstParamIndex + method.Parameters.Count);
for (int i = firstParamIndex; i < arguments.Length; i++) { for (int i = firstParamIndex; i < arguments.Length; i++) {
var parameter = method.Parameters[i - firstParamIndex]; var parameter = method.Parameters[i - firstParamIndex];
@ -432,9 +432,9 @@ namespace ICSharpCode.Decompiler.CSharp
} }
} }
protected internal override ConvertedExpression VisitLdObj(LdObj inst) protected internal override TranslatedExpression VisitLdObj(LdObj inst)
{ {
var target = Convert(inst.Target); var target = Translate(inst.Target);
var type = cecilMapper.GetType(inst.Type); var type = cecilMapper.GetType(inst.Type);
if (target.Type.Equals(new ByReferenceType(type)) && target.Expression is DirectionExpression) { if (target.Type.Equals(new ByReferenceType(type)) && target.Expression is DirectionExpression) {
// we can deference the managed reference by stripping away the 'ref' // we can deference the managed reference by stripping away the 'ref'
@ -451,12 +451,12 @@ namespace ICSharpCode.Decompiler.CSharp
} }
} }
protected internal override ConvertedExpression VisitStObj(StObj inst) protected internal override TranslatedExpression VisitStObj(StObj inst)
{ {
var target = Convert(inst.Target); var target = Translate(inst.Target);
var value = Convert(inst.Value); var value = Translate(inst.Value);
var type = cecilMapper.GetType(inst.Type); var type = cecilMapper.GetType(inst.Type);
ConvertedExpression result; TranslatedExpression result;
if (target.Type.Equals(new ByReferenceType(type)) && target.Expression is DirectionExpression) { if (target.Type.Equals(new ByReferenceType(type)) && target.Expression is DirectionExpression) {
// we can deference the managed reference by stripping away the 'ref' // we can deference the managed reference by stripping away the 'ref'
result = target.UnwrapChild(((DirectionExpression)target.Expression).Expression); result = target.UnwrapChild(((DirectionExpression)target.Expression).Expression);
@ -470,9 +470,9 @@ namespace ICSharpCode.Decompiler.CSharp
return Assignment(result, value).WithILInstruction(inst); return Assignment(result, value).WithILInstruction(inst);
} }
protected internal override ConvertedExpression VisitUnboxAny(UnboxAny inst) protected internal override TranslatedExpression VisitUnboxAny(UnboxAny inst)
{ {
var arg = Convert(inst.Argument); var arg = Translate(inst.Argument);
if (arg.Type.IsReferenceType != true) { if (arg.Type.IsReferenceType != true) {
// ensure we treat the input as a reference type // ensure we treat the input as a reference type
arg = arg.ConvertTo(compilation.FindType(KnownTypeCode.Object), this); arg = arg.ConvertTo(compilation.FindType(KnownTypeCode.Object), this);
@ -482,12 +482,12 @@ namespace ICSharpCode.Decompiler.CSharp
.WithRR(new ConversionResolveResult(cecilMapper.GetType(inst.Type), arg.ResolveResult, Conversion.UnboxingConversion)); .WithRR(new ConversionResolveResult(cecilMapper.GetType(inst.Type), arg.ResolveResult, Conversion.UnboxingConversion));
} }
protected override ConvertedExpression Default(ILInstruction inst) protected override TranslatedExpression Default(ILInstruction inst)
{ {
return ErrorExpression("OpCode not supported: " + inst.OpCode); return ErrorExpression("OpCode not supported: " + inst.OpCode);
} }
static ConvertedExpression ErrorExpression(string message) static TranslatedExpression ErrorExpression(string message)
{ {
var e = new ErrorExpression(); var e = new ErrorExpression();
e.AddChild(new Comment(message, CommentType.MultiLine), Roles.Comment); e.AddChild(new Comment(message, CommentType.MultiLine), Roles.Comment);

12
ICSharpCode.Decompiler/CSharp/StatementBuilder.cs
Unescape View File

@ -51,7 +51,7 @@ namespace ICSharpCode.Decompiler.CSharp
protected override Statement Default(ILInstruction inst) protected override Statement Default(ILInstruction inst)
{ {
return new ExpressionStatement(exprBuilder.Convert(inst)); return new ExpressionStatement(exprBuilder.Translate(inst));
} }
protected internal override Statement VisitNop(Nop inst) protected internal override Statement VisitNop(Nop inst)
@ -61,12 +61,12 @@ namespace ICSharpCode.Decompiler.CSharp
protected internal override Statement VisitVoid(ICSharpCode.Decompiler.IL.Void inst) protected internal override Statement VisitVoid(ICSharpCode.Decompiler.IL.Void inst)
{ {
return new ExpressionStatement(exprBuilder.Convert(inst.Argument)); return new ExpressionStatement(exprBuilder.Translate(inst.Argument));
} }
protected internal override Statement VisitIfInstruction(IfInstruction inst) protected internal override Statement VisitIfInstruction(IfInstruction inst)
{ {
var condition = exprBuilder.ConvertCondition(inst.Condition); var condition = exprBuilder.TranslateCondition(inst.Condition);
var trueStatement = Convert(inst.TrueInst); var trueStatement = Convert(inst.TrueInst);
var falseStatement = inst.FalseInst.OpCode == OpCode.Nop ? null : Convert(inst.FalseInst); var falseStatement = inst.FalseInst.OpCode == OpCode.Nop ? null : Convert(inst.FalseInst);
return new IfElseStatement(condition, trueStatement, falseStatement); return new IfElseStatement(condition, trueStatement, falseStatement);
@ -79,14 +79,14 @@ namespace ICSharpCode.Decompiler.CSharp
protected internal override Statement VisitThrow(Throw inst) protected internal override Statement VisitThrow(Throw inst)
{ {
return new ThrowStatement(exprBuilder.Convert(inst.Argument)); return new ThrowStatement(exprBuilder.Translate(inst.Argument));
} }
protected internal override Statement VisitReturn(Return inst) protected internal override Statement VisitReturn(Return inst)
{ {
if (inst.ReturnValue == null) if (inst.ReturnValue == null)
return new ReturnStatement(); return new ReturnStatement();
return new ReturnStatement(exprBuilder.Convert(inst.ReturnValue).ConvertTo(currentMethod.ReturnType, exprBuilder)); return new ReturnStatement(exprBuilder.Translate(inst.ReturnValue).ConvertTo(currentMethod.ReturnType, exprBuilder));
} }
TryCatchStatement MakeTryCatch(ILInstruction tryBlock) TryCatchStatement MakeTryCatch(ILInstruction tryBlock)
@ -111,7 +111,7 @@ namespace ICSharpCode.Decompiler.CSharp
catchClause.VariableName = handler.Variable.Name; catchClause.VariableName = handler.Variable.Name;
} }
if (!handler.Filter.MatchLdcI4(1)) if (!handler.Filter.MatchLdcI4(1))
catchClause.Condition = exprBuilder.ConvertCondition(handler.Filter); catchClause.Condition = exprBuilder.TranslateCondition(handler.Filter);
catchClause.Body = ConvertAsBlock(handler.Body); catchClause.Body = ConvertAsBlock(handler.Body);
tryCatch.CatchClauses.Add(catchClause); tryCatch.CatchClauses.Add(catchClause);
} }

4
ICSharpCode.Decompiler/CSharp/Transforms/ConvertConstructorCallIntoInitializer.cs
Unescape View File

@ -100,7 +100,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
return; return;
// Recognize field initializers: // Recognize field initializers:
// Convert first statement in all ctors (if all ctors have the same statement) into a field initializer. // Translate first statement in all ctors (if all ctors have the same statement) into a field initializer.
bool allSame; bool allSame;
do { do {
Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault()); Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault());
@ -146,7 +146,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms
void HandleStaticFieldInitializers(IEnumerable<AstNode> members, TransformContext context) void HandleStaticFieldInitializers(IEnumerable<AstNode> members, TransformContext context)
{ {
// Convert static constructor into field initializers if the class is BeforeFieldInit // Translate static constructor into field initializers if the class is BeforeFieldInit
var staticCtor = members.OfType<ConstructorDeclaration>().FirstOrDefault(c => (c.Modifiers & Modifiers.Static) == Modifiers.Static); var staticCtor = members.OfType<ConstructorDeclaration>().FirstOrDefault(c => (c.Modifiers & Modifiers.Static) == Modifiers.Static);
if (staticCtor != null) { if (staticCtor != null) {
IMethod ctorMethod = staticCtor.GetSymbol() as IMethod; IMethod ctorMethod = staticCtor.GetSymbol() as IMethod;

24
ICSharpCode.Decompiler/CSharp/ConvertedExpression.cs → ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs
Unescape View File

@ -86,10 +86,10 @@ namespace ICSharpCode.Decompiler.CSharp
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// The resolve result is also always available as annotation on the expression, but having /// The resolve result is also always available as annotation on the expression, but having
/// ConvertedExpression as a separate type is still useful to ensure that no case in the expression builder /// TranslatedExpression as a separate type is still useful to ensure that no case in the expression builder
/// forgets to add the annotation. /// forgets to add the annotation.
/// </remarks> /// </remarks>
struct ConvertedExpression struct TranslatedExpression
{ {
public readonly Expression Expression; public readonly Expression Expression;
@ -105,14 +105,14 @@ namespace ICSharpCode.Decompiler.CSharp
get { return ResolveResult.Type; } get { return ResolveResult.Type; }
} }
internal ConvertedExpression(Expression expression) internal TranslatedExpression(Expression expression)
{ {
Debug.Assert(expression != null); Debug.Assert(expression != null);
this.Expression = expression; this.Expression = expression;
this.ResolveResult = expression.Annotation<ResolveResult>() ?? ErrorResolveResult.UnknownError; this.ResolveResult = expression.Annotation<ResolveResult>() ?? ErrorResolveResult.UnknownError;
} }
internal ConvertedExpression(Expression expression, ResolveResult resolveResult) internal TranslatedExpression(Expression expression, ResolveResult resolveResult)
{ {
Debug.Assert(expression != null && resolveResult != null); Debug.Assert(expression != null && resolveResult != null);
Debug.Assert(expression.Annotation<ResolveResult>() == resolveResult); Debug.Assert(expression.Annotation<ResolveResult>() == resolveResult);
@ -120,27 +120,27 @@ namespace ICSharpCode.Decompiler.CSharp
this.Expression = expression; this.Expression = expression;
} }
public static implicit operator Expression(ConvertedExpression expression) public static implicit operator Expression(TranslatedExpression expression)
{ {
return expression.Expression; return expression.Expression;
} }
public static implicit operator ExpressionWithResolveResult(ConvertedExpression expression) public static implicit operator ExpressionWithResolveResult(TranslatedExpression expression)
{ {
return new ExpressionWithResolveResult(expression.Expression, expression.ResolveResult); return new ExpressionWithResolveResult(expression.Expression, expression.ResolveResult);
} }
public static implicit operator ExpressionWithILInstruction(ConvertedExpression expression) public static implicit operator ExpressionWithILInstruction(TranslatedExpression expression)
{ {
return new ExpressionWithILInstruction(expression.Expression); return new ExpressionWithILInstruction(expression.Expression);
} }
/// <summary> /// <summary>
/// Returns a new ConvertedExpression that represents the specified descendant expression. /// Returns a new TranslatedExpression that represents the specified descendant expression.
/// All ILInstruction annotations from the current expression are copied to the descendant expression. /// All ILInstruction annotations from the current expression are copied to the descendant expression.
/// The descendant expression is detached from the AST. /// The descendant expression is detached from the AST.
/// </summary> /// </summary>
public ConvertedExpression UnwrapChild(Expression descendant) public TranslatedExpression UnwrapChild(Expression descendant)
{ {
if (descendant == Expression) if (descendant == Expression)
return this; return this;
@ -148,12 +148,12 @@ namespace ICSharpCode.Decompiler.CSharp
foreach (var inst in parent.Annotations.OfType<ILInstruction>()) foreach (var inst in parent.Annotations.OfType<ILInstruction>())
descendant.AddAnnotation(inst); descendant.AddAnnotation(inst);
if (parent == Expression) if (parent == Expression)
return new ConvertedExpression(descendant.Detach()); return new TranslatedExpression(descendant.Detach());
} }
throw new ArgumentException("descendant must be a descendant of the current node"); throw new ArgumentException("descendant must be a descendant of the current node");
} }
public ConvertedExpression ConvertTo(IType targetType, ExpressionBuilder expressionBuilder) public TranslatedExpression ConvertTo(IType targetType, ExpressionBuilder expressionBuilder)
{ {
var type = this.Type; var type = this.Type;
if (targetType.IsKnownType(KnownTypeCode.Boolean)) if (targetType.IsKnownType(KnownTypeCode.Boolean))
@ -180,7 +180,7 @@ namespace ICSharpCode.Decompiler.CSharp
.WithoutILInstruction().WithRR(rr); .WithoutILInstruction().WithRR(rr);
} }
public ConvertedExpression ConvertToBoolean(ExpressionBuilder expressionBuilder) public TranslatedExpression ConvertToBoolean(ExpressionBuilder expressionBuilder)
{ {
if (Type.IsKnownType(KnownTypeCode.Boolean) || Type.Kind == TypeKind.Unknown) { if (Type.IsKnownType(KnownTypeCode.Boolean) || Type.Kind == TypeKind.Unknown) {
return this; return this;

6
ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj
Unescape View File

@ -63,7 +63,7 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="CSharp\Annotations.cs" /> <Compile Include="CSharp\Annotations.cs" />
<Compile Include="CSharp\ConvertedExpression.cs" /> <Compile Include="CSharp\TranslatedExpression.cs" />
<Compile Include="CSharp\NRefactoryCecilMapper.cs" /> <Compile Include="CSharp\NRefactoryCecilMapper.cs" />
<Compile Include="CSharp\CSharpDecompiler.cs" /> <Compile Include="CSharp\CSharpDecompiler.cs" />
<Compile Include="CSharp\ExpressionBuilder.cs" /> <Compile Include="CSharp\ExpressionBuilder.cs" />
@ -160,9 +160,7 @@
<ItemGroup> <ItemGroup>
<Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" /> <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup />
<Folder Include="CSharp\Transforms" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" /> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
<Target Name="BeforeBuild"> <Target Name="BeforeBuild">
<MSBuild Projects="$(MSBuildProjectDirectory)\..\BuildTools\UpdateAssemblyInfo\UpdateAssemblyInfo.csproj" Targets="Build" Properties="Configuration=Debug" /> <MSBuild Projects="$(MSBuildProjectDirectory)\..\BuildTools\UpdateAssemblyInfo\UpdateAssemblyInfo.csproj" Targets="Build" Properties="Configuration=Debug" />

Write Preview
Loading…
Cancel
Save