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

convert increment/decrement operator overloads to op_Increment/op_Decrement methods

pull/254/head
Siegfried Pammer 14 years ago
parent
08dfa88aa3
commit
212b993859
1 changed files with 99 additions and 86 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. 185
      NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

185
NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs
Unescape View File

@ -1606,99 +1606,112 @@ namespace ICSharpCode.NRefactory.VB.Visitors
public AstNode VisitOperatorDeclaration(CSharp.OperatorDeclaration operatorDeclaration, object data) public AstNode VisitOperatorDeclaration(CSharp.OperatorDeclaration operatorDeclaration, object data)
{ {
var result = new OperatorDeclaration(); MemberDeclaration result;
members.Push(new MemberInfo()); members.Push(new MemberInfo());
ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget != "return"), result.Attributes); if (operatorDeclaration.OperatorType == CSharp.OperatorType.Increment || operatorDeclaration.OperatorType == CSharp.OperatorType.Decrement) {
ConvertNodes(operatorDeclaration.ModifierTokens, result.ModifierTokens); var m = new MethodDeclaration();
switch (operatorDeclaration.OperatorType) { result = m;
case ICSharpCode.NRefactory.CSharp.OperatorType.LogicalNot:
case ICSharpCode.NRefactory.CSharp.OperatorType.OnesComplement: ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget != "return"), m.Attributes);
result.Operator = OverloadableOperatorType.Not; ConvertNodes(operatorDeclaration.ModifierTokens, m.ModifierTokens);
break; m.Name = operatorDeclaration.OperatorType == CSharp.OperatorType.Increment ? "op_Increment" : "op_Decrement";
case ICSharpCode.NRefactory.CSharp.OperatorType.Increment: ConvertNodes(operatorDeclaration.Parameters, m.Parameters);
case ICSharpCode.NRefactory.CSharp.OperatorType.Decrement: ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget == "return"), m.ReturnTypeAttributes);
throw new NotSupportedException(); m.ReturnType = (AstType)operatorDeclaration.ReturnType.AcceptVisitor(this, data);
case ICSharpCode.NRefactory.CSharp.OperatorType.True: m.Body = (BlockStatement)operatorDeclaration.Body.AcceptVisitor(this, data);
result.Operator = OverloadableOperatorType.IsTrue; } else {
break; var op = new OperatorDeclaration();
case ICSharpCode.NRefactory.CSharp.OperatorType.False: result = op;
result.Operator = OverloadableOperatorType.IsFalse;
break; ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget != "return"), op.Attributes);
case ICSharpCode.NRefactory.CSharp.OperatorType.Implicit: ConvertNodes(operatorDeclaration.ModifierTokens, op.ModifierTokens);
result.Modifiers |= Modifiers.Widening; switch (operatorDeclaration.OperatorType) {
result.Operator = OverloadableOperatorType.CType; case ICSharpCode.NRefactory.CSharp.OperatorType.LogicalNot:
break; case ICSharpCode.NRefactory.CSharp.OperatorType.OnesComplement:
case ICSharpCode.NRefactory.CSharp.OperatorType.Explicit: op.Operator = OverloadableOperatorType.Not;
result.Modifiers |= Modifiers.Narrowing; break;
result.Operator = OverloadableOperatorType.CType; case ICSharpCode.NRefactory.CSharp.OperatorType.True:
break; op.Operator = OverloadableOperatorType.IsTrue;
case ICSharpCode.NRefactory.CSharp.OperatorType.Addition: break;
result.Operator = OverloadableOperatorType.Add; case ICSharpCode.NRefactory.CSharp.OperatorType.False:
break; op.Operator = OverloadableOperatorType.IsFalse;
case ICSharpCode.NRefactory.CSharp.OperatorType.Subtraction: break;
result.Operator = OverloadableOperatorType.Subtract; case ICSharpCode.NRefactory.CSharp.OperatorType.Implicit:
break; op.Modifiers |= Modifiers.Widening;
case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryPlus: op.Operator = OverloadableOperatorType.CType;
result.Operator = OverloadableOperatorType.UnaryPlus; break;
break; case ICSharpCode.NRefactory.CSharp.OperatorType.Explicit:
case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryNegation: op.Modifiers |= Modifiers.Narrowing;
result.Operator = OverloadableOperatorType.UnaryMinus; op.Operator = OverloadableOperatorType.CType;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Multiply: case ICSharpCode.NRefactory.CSharp.OperatorType.Addition:
result.Operator = OverloadableOperatorType.Multiply; op.Operator = OverloadableOperatorType.Add;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Division: case ICSharpCode.NRefactory.CSharp.OperatorType.Subtraction:
result.Operator = OverloadableOperatorType.Divide; op.Operator = OverloadableOperatorType.Subtract;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Modulus: case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryPlus:
result.Operator = OverloadableOperatorType.Modulus; op.Operator = OverloadableOperatorType.UnaryPlus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseAnd: case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryNegation:
result.Operator = OverloadableOperatorType.BitwiseAnd; op.Operator = OverloadableOperatorType.UnaryMinus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseOr: case ICSharpCode.NRefactory.CSharp.OperatorType.Multiply:
result.Operator = OverloadableOperatorType.BitwiseOr; op.Operator = OverloadableOperatorType.Multiply;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.ExclusiveOr: case ICSharpCode.NRefactory.CSharp.OperatorType.Division:
result.Operator = OverloadableOperatorType.ExclusiveOr; op.Operator = OverloadableOperatorType.Divide;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LeftShift: case ICSharpCode.NRefactory.CSharp.OperatorType.Modulus:
result.Operator = OverloadableOperatorType.ShiftLeft; op.Operator = OverloadableOperatorType.Modulus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.RightShift: case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseAnd:
result.Operator = OverloadableOperatorType.ShiftRight; op.Operator = OverloadableOperatorType.BitwiseAnd;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Equality: case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseOr:
result.Operator = OverloadableOperatorType.Equality; op.Operator = OverloadableOperatorType.BitwiseOr;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Inequality: case ICSharpCode.NRefactory.CSharp.OperatorType.ExclusiveOr:
result.Operator = OverloadableOperatorType.InEquality; op.Operator = OverloadableOperatorType.ExclusiveOr;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThan: case ICSharpCode.NRefactory.CSharp.OperatorType.LeftShift:
result.Operator = OverloadableOperatorType.GreaterThan; op.Operator = OverloadableOperatorType.ShiftLeft;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThan: case ICSharpCode.NRefactory.CSharp.OperatorType.RightShift:
result.Operator = OverloadableOperatorType.LessThan; op.Operator = OverloadableOperatorType.ShiftRight;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThanOrEqual: case ICSharpCode.NRefactory.CSharp.OperatorType.Equality:
result.Operator = OverloadableOperatorType.GreaterThanOrEqual; op.Operator = OverloadableOperatorType.Equality;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThanOrEqual: case ICSharpCode.NRefactory.CSharp.OperatorType.Inequality:
result.Operator = OverloadableOperatorType.LessThanOrEqual; op.Operator = OverloadableOperatorType.InEquality;
break; break;
default: case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThan:
throw new Exception("Invalid value for OperatorType"); op.Operator = OverloadableOperatorType.GreaterThan;
break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThan:
op.Operator = OverloadableOperatorType.LessThan;
break;
case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThanOrEqual:
op.Operator = OverloadableOperatorType.GreaterThanOrEqual;
break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThanOrEqual:
op.Operator = OverloadableOperatorType.LessThanOrEqual;
break;
default:
throw new Exception("Invalid value for OperatorType");
}
ConvertNodes(operatorDeclaration.Parameters, op.Parameters);
ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget == "return"), op.ReturnTypeAttributes);
op.ReturnType = (AstType)operatorDeclaration.ReturnType.AcceptVisitor(this, data);
op.Body = (BlockStatement)operatorDeclaration.Body.AcceptVisitor(this, data);
} }
ConvertNodes(operatorDeclaration.Parameters, result.Parameters);
ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget == "return"), result.ReturnTypeAttributes);
result.ReturnType = (AstType)operatorDeclaration.ReturnType.AcceptVisitor(this, data);
result.Body = (BlockStatement)operatorDeclaration.Body.AcceptVisitor(this, data);
members.Pop(); members.Pop();
return EndNode(operatorDeclaration, result); return EndNode(operatorDeclaration, result);
} }
public AstNode VisitParameterDeclaration(CSharp.ParameterDeclaration parameterDeclaration, object data) public AstNode VisitParameterDeclaration(CSharp.ParameterDeclaration parameterDeclaration, object data)

Write Preview
Loading…
Cancel
Save