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
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 85
      NRefactory/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

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

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

Write Preview
Loading…
Cancel
Save