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

fix some warnings reported by RE

pull/703/head
Siegfried Pammer 9 years ago
parent
f8ac9823dd
commit
4c3ac47300
2 changed files with 80 additions and 79 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. 4
      ILSpy/VB/ILSpyEnvironmentProvider.cs
  2. 155
      NRefactory.VB/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

4
ILSpy/VB/ILSpyEnvironmentProvider.cs
Unescape View File

@ -129,7 +129,7 @@ namespace ICSharpCode.ILSpy.VB
foreach (var type in interfaces) { foreach (var type in interfaces) {
var def = type.Annotation<TypeReference>().Resolve(); var def = type.Annotation<TypeReference>().Resolve();
if (def == null) continue; if (def == null) continue;
foreach (var method in def.Methods.Where(m => !m.Name.StartsWith("get_") && !m.Name.StartsWith("set_"))) { foreach (var method in def.Methods.Where(m => !m.Name.StartsWith("get_", StringComparison.Ordinal) && !m.Name.StartsWith("set_", StringComparison.Ordinal))) {
yield return new NRefactory.VB.Ast.InterfaceMemberSpecifier((NRefactory.VB.Ast.AstType)type.Clone(), method.Name); yield return new NRefactory.VB.Ast.InterfaceMemberSpecifier((NRefactory.VB.Ast.AstType)type.Clone(), method.Name);
} }
@ -148,7 +148,7 @@ namespace ICSharpCode.ILSpy.VB
{ {
var methodInfo = expression.Annotation<MethodReference>()?.Resolve(); var methodInfo = expression.Annotation<MethodReference>()?.Resolve();
if (methodInfo != null) { if (methodInfo != null) {
return !methodInfo.IsGetter && !methodInfo.IsSetter; return !methodInfo.IsGetter && !methodInfo.IsSetter && !methodInfo.IsAddOn && !methodInfo.IsRemoveOn;
} }
return false; return false;

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

@ -137,10 +137,10 @@ namespace ICSharpCode.NRefactory.VB.Visitors
var right = (Expression)assignmentExpression.Right.AcceptVisitor(this, data); var right = (Expression)assignmentExpression.Right.AcceptVisitor(this, data);
switch (assignmentExpression.Operator) { switch (assignmentExpression.Operator) {
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Assign: case CSharp.AssignmentOperatorType.Assign:
op = AssignmentOperatorType.Assign; op = AssignmentOperatorType.Assign;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Add: case CSharp.AssignmentOperatorType.Add:
if (provider.HasEvent(left)) { if (provider.HasEvent(left)) {
var addHandler = new AddRemoveHandlerStatement { IsAddHandler = true }; var addHandler = new AddRemoveHandlerStatement { IsAddHandler = true };
addHandler.EventExpression = left; addHandler.EventExpression = left;
@ -149,7 +149,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
} }
op = AssignmentOperatorType.Add; op = AssignmentOperatorType.Add;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Subtract: case CSharp.AssignmentOperatorType.Subtract:
if (provider.HasEvent(left)) { if (provider.HasEvent(left)) {
var addHandler = new AddRemoveHandlerStatement { IsAddHandler = false }; var addHandler = new AddRemoveHandlerStatement { IsAddHandler = false };
addHandler.EventExpression = left; addHandler.EventExpression = left;
@ -158,31 +158,31 @@ namespace ICSharpCode.NRefactory.VB.Visitors
} }
op = AssignmentOperatorType.Subtract; op = AssignmentOperatorType.Subtract;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Multiply: case CSharp.AssignmentOperatorType.Multiply:
op = AssignmentOperatorType.Multiply; op = AssignmentOperatorType.Multiply;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Divide: case CSharp.AssignmentOperatorType.Divide:
op = AssignmentOperatorType.Divide; op = AssignmentOperatorType.Divide;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Modulus: case CSharp.AssignmentOperatorType.Modulus:
op = AssignmentOperatorType.Assign; op = AssignmentOperatorType.Assign;
right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.Modulus, right); right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.Modulus, right);
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftLeft: case CSharp.AssignmentOperatorType.ShiftLeft:
op = AssignmentOperatorType.ShiftLeft; op = AssignmentOperatorType.ShiftLeft;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftRight: case CSharp.AssignmentOperatorType.ShiftRight:
op = AssignmentOperatorType.ShiftRight; op = AssignmentOperatorType.ShiftRight;
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseAnd: case CSharp.AssignmentOperatorType.BitwiseAnd:
op = AssignmentOperatorType.Assign; op = AssignmentOperatorType.Assign;
right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.BitwiseAnd, right); right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.BitwiseAnd, right);
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseOr: case CSharp.AssignmentOperatorType.BitwiseOr:
op = AssignmentOperatorType.Assign; op = AssignmentOperatorType.Assign;
right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.BitwiseOr, right); right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.BitwiseOr, right);
break; break;
case ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ExclusiveOr: case CSharp.AssignmentOperatorType.ExclusiveOr:
op = AssignmentOperatorType.Assign; op = AssignmentOperatorType.Assign;
right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.ExclusiveOr, right); right = new BinaryOperatorExpression((Expression)left.Clone(), BinaryOperatorType.ExclusiveOr, right);
break; break;
@ -208,68 +208,68 @@ namespace ICSharpCode.NRefactory.VB.Visitors
var right = (Expression)binaryOperatorExpression.Right.AcceptVisitor(this, data); var right = (Expression)binaryOperatorExpression.Right.AcceptVisitor(this, data);
switch (binaryOperatorExpression.Operator) { switch (binaryOperatorExpression.Operator) {
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseAnd: case CSharp.BinaryOperatorType.BitwiseAnd:
op = BinaryOperatorType.BitwiseAnd; op = BinaryOperatorType.BitwiseAnd;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseOr: case CSharp.BinaryOperatorType.BitwiseOr:
op = BinaryOperatorType.BitwiseOr; op = BinaryOperatorType.BitwiseOr;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalAnd: case CSharp.BinaryOperatorType.ConditionalAnd:
op = BinaryOperatorType.LogicalAnd; op = BinaryOperatorType.LogicalAnd;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalOr: case CSharp.BinaryOperatorType.ConditionalOr:
op = BinaryOperatorType.LogicalOr; op = BinaryOperatorType.LogicalOr;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ExclusiveOr: case CSharp.BinaryOperatorType.ExclusiveOr:
op = BinaryOperatorType.ExclusiveOr; op = BinaryOperatorType.ExclusiveOr;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThan: case CSharp.BinaryOperatorType.GreaterThan:
op = BinaryOperatorType.GreaterThan; op = BinaryOperatorType.GreaterThan;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThanOrEqual: case CSharp.BinaryOperatorType.GreaterThanOrEqual:
op = BinaryOperatorType.GreaterThanOrEqual; op = BinaryOperatorType.GreaterThanOrEqual;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Equality: case CSharp.BinaryOperatorType.Equality:
if (IsReferentialEquality(binaryOperatorExpression)) if (IsReferentialEquality(binaryOperatorExpression))
op = BinaryOperatorType.ReferenceEquality; op = BinaryOperatorType.ReferenceEquality;
else else
op = BinaryOperatorType.Equality; op = BinaryOperatorType.Equality;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.InEquality: case CSharp.BinaryOperatorType.InEquality:
if (IsReferentialEquality(binaryOperatorExpression)) if (IsReferentialEquality(binaryOperatorExpression))
op = BinaryOperatorType.ReferenceInequality; op = BinaryOperatorType.ReferenceInequality;
else else
op = BinaryOperatorType.InEquality; op = BinaryOperatorType.InEquality;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThan: case CSharp.BinaryOperatorType.LessThan:
op = BinaryOperatorType.LessThan; op = BinaryOperatorType.LessThan;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThanOrEqual: case CSharp.BinaryOperatorType.LessThanOrEqual:
op = BinaryOperatorType.LessThanOrEqual; op = BinaryOperatorType.LessThanOrEqual;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Add: case CSharp.BinaryOperatorType.Add:
// TODO might be string concatenation // TODO might be string concatenation
op = BinaryOperatorType.Add; op = BinaryOperatorType.Add;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Subtract: case CSharp.BinaryOperatorType.Subtract:
op = BinaryOperatorType.Subtract; op = BinaryOperatorType.Subtract;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Multiply: case CSharp.BinaryOperatorType.Multiply:
op = BinaryOperatorType.Multiply; op = BinaryOperatorType.Multiply;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Divide: case CSharp.BinaryOperatorType.Divide:
op = BinaryOperatorType.Divide; op = BinaryOperatorType.Divide;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Modulus: case CSharp.BinaryOperatorType.Modulus:
op = BinaryOperatorType.Modulus; op = BinaryOperatorType.Modulus;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftLeft: case CSharp.BinaryOperatorType.ShiftLeft:
op = BinaryOperatorType.ShiftLeft; op = BinaryOperatorType.ShiftLeft;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftRight: case CSharp.BinaryOperatorType.ShiftRight:
op = BinaryOperatorType.ShiftRight; op = BinaryOperatorType.ShiftRight;
break; break;
case ICSharpCode.NRefactory.CSharp.BinaryOperatorType.NullCoalescing: case CSharp.BinaryOperatorType.NullCoalescing:
var nullCoalescing = new ConditionalExpression { var nullCoalescing = new ConditionalExpression {
ConditionExpression = left, ConditionExpression = left,
FalseExpression = right FalseExpression = right
@ -653,57 +653,57 @@ namespace ICSharpCode.NRefactory.VB.Visitors
Expression expr; Expression expr;
switch (unaryOperatorExpression.Operator) { switch (unaryOperatorExpression.Operator) {
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Not: case CSharp.UnaryOperatorType.Not:
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.BitNot: case CSharp.UnaryOperatorType.BitNot:
expr = new UnaryOperatorExpression() { expr = new UnaryOperatorExpression() {
Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data), Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data),
Operator = UnaryOperatorType.Not Operator = UnaryOperatorType.Not
}; };
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Minus: case CSharp.UnaryOperatorType.Minus:
expr = new UnaryOperatorExpression() { expr = new UnaryOperatorExpression() {
Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data), Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data),
Operator = UnaryOperatorType.Minus Operator = UnaryOperatorType.Minus
}; };
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Plus: case CSharp.UnaryOperatorType.Plus:
expr = new UnaryOperatorExpression() { expr = new UnaryOperatorExpression() {
Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data), Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data),
Operator = UnaryOperatorType.Plus Operator = UnaryOperatorType.Plus
}; };
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Increment: case CSharp.UnaryOperatorType.Increment:
expr = new InvocationExpression(); expr = new InvocationExpression();
((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Increment" }; ((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Increment" };
((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); ((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostIncrement: case CSharp.UnaryOperatorType.PostIncrement:
expr = new InvocationExpression(); expr = new InvocationExpression();
((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__PostIncrement" }; ((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__PostIncrement" };
((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); ((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Decrement: case CSharp.UnaryOperatorType.Decrement:
expr = new InvocationExpression(); expr = new InvocationExpression();
((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Decrement" }; ((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Decrement" };
((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); ((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostDecrement: case CSharp.UnaryOperatorType.PostDecrement:
expr = new InvocationExpression(); expr = new InvocationExpression();
((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__PostDecrement" }; ((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__PostDecrement" };
((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); ((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.AddressOf: case CSharp.UnaryOperatorType.AddressOf:
expr = new UnaryOperatorExpression() { expr = new UnaryOperatorExpression() {
Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data), Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data),
Operator = UnaryOperatorType.AddressOf Operator = UnaryOperatorType.AddressOf
}; };
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Dereference: case CSharp.UnaryOperatorType.Dereference:
expr = new InvocationExpression(); expr = new InvocationExpression();
((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Dereference" }; ((InvocationExpression)expr).Target = new IdentifierExpression() { Identifier = "__Dereference" };
((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data)); ((InvocationExpression)expr).Arguments.Add((Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
break; break;
case ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Await: case CSharp.UnaryOperatorType.Await:
expr = new UnaryOperatorExpression() { expr = new UnaryOperatorExpression() {
Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data), Expression = (Expression)unaryOperatorExpression.Expression.AcceptVisitor(this, data),
Operator = UnaryOperatorType.Await Operator = UnaryOperatorType.Await
@ -1482,15 +1482,16 @@ namespace ICSharpCode.NRefactory.VB.Visitors
var result = new EventDeclaration(); var result = new EventDeclaration();
ConvertNodes(eventDeclaration.Attributes, result.Attributes); ConvertNodes(eventDeclaration.Attributes, result.Attributes);
if (types.Any() && types.Peek().ClassType == ClassType.Module) if (types.Any()) {
eventDeclaration.Modifiers &= ~CSharp.Modifiers.Static; if (types.Peek().ClassType == ClassType.Module)
eventDeclaration.Modifiers &= ~CSharp.Modifiers.Static;
types.Peek().Members.Add(result);
}
result.Modifiers = ConvertModifiers(eventDeclaration.Modifiers, eventDeclaration); result.Modifiers = ConvertModifiers(eventDeclaration.Modifiers, eventDeclaration);
result.Name = evt.Name; result.Name = evt.Name;
result.ReturnType = (AstType)eventDeclaration.ReturnType.AcceptVisitor(this, data); result.ReturnType = (AstType)eventDeclaration.ReturnType.AcceptVisitor(this, data);
// CreateImplementsClausesForEvent(result); // CreateImplementsClausesForEvent(result);
types.Peek().Members.Add(result);
} }
members.Pop(); members.Pop();
@ -1768,76 +1769,76 @@ namespace ICSharpCode.NRefactory.VB.Visitors
ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget != "return"), op.Attributes); ConvertNodes(operatorDeclaration.Attributes.Where(section => section.AttributeTarget != "return"), op.Attributes);
ConvertNodes(operatorDeclaration.ModifierTokens, op.ModifierTokens); ConvertNodes(operatorDeclaration.ModifierTokens, op.ModifierTokens);
switch (operatorDeclaration.OperatorType) { switch (operatorDeclaration.OperatorType) {
case ICSharpCode.NRefactory.CSharp.OperatorType.LogicalNot: case CSharp.OperatorType.LogicalNot:
case ICSharpCode.NRefactory.CSharp.OperatorType.OnesComplement: case CSharp.OperatorType.OnesComplement:
op.Operator = OverloadableOperatorType.Not; op.Operator = OverloadableOperatorType.Not;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.True: case CSharp.OperatorType.True:
op.Operator = OverloadableOperatorType.IsTrue; op.Operator = OverloadableOperatorType.IsTrue;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.False: case CSharp.OperatorType.False:
op.Operator = OverloadableOperatorType.IsFalse; op.Operator = OverloadableOperatorType.IsFalse;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Implicit: case CSharp.OperatorType.Implicit:
op.Modifiers |= Modifiers.Widening; op.Modifiers |= Modifiers.Widening;
op.Operator = OverloadableOperatorType.CType; op.Operator = OverloadableOperatorType.CType;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Explicit: case CSharp.OperatorType.Explicit:
op.Modifiers |= Modifiers.Narrowing; op.Modifiers |= Modifiers.Narrowing;
op.Operator = OverloadableOperatorType.CType; op.Operator = OverloadableOperatorType.CType;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Addition: case CSharp.OperatorType.Addition:
op.Operator = OverloadableOperatorType.Add; op.Operator = OverloadableOperatorType.Add;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Subtraction: case CSharp.OperatorType.Subtraction:
op.Operator = OverloadableOperatorType.Subtract; op.Operator = OverloadableOperatorType.Subtract;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryPlus: case CSharp.OperatorType.UnaryPlus:
op.Operator = OverloadableOperatorType.UnaryPlus; op.Operator = OverloadableOperatorType.UnaryPlus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.UnaryNegation: case CSharp.OperatorType.UnaryNegation:
op.Operator = OverloadableOperatorType.UnaryMinus; op.Operator = OverloadableOperatorType.UnaryMinus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Multiply: case CSharp.OperatorType.Multiply:
op.Operator = OverloadableOperatorType.Multiply; op.Operator = OverloadableOperatorType.Multiply;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Division: case CSharp.OperatorType.Division:
op.Operator = OverloadableOperatorType.Divide; op.Operator = OverloadableOperatorType.Divide;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Modulus: case CSharp.OperatorType.Modulus:
op.Operator = OverloadableOperatorType.Modulus; op.Operator = OverloadableOperatorType.Modulus;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseAnd: case CSharp.OperatorType.BitwiseAnd:
op.Operator = OverloadableOperatorType.BitwiseAnd; op.Operator = OverloadableOperatorType.BitwiseAnd;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.BitwiseOr: case CSharp.OperatorType.BitwiseOr:
op.Operator = OverloadableOperatorType.BitwiseOr; op.Operator = OverloadableOperatorType.BitwiseOr;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.ExclusiveOr: case CSharp.OperatorType.ExclusiveOr:
op.Operator = OverloadableOperatorType.ExclusiveOr; op.Operator = OverloadableOperatorType.ExclusiveOr;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LeftShift: case CSharp.OperatorType.LeftShift:
op.Operator = OverloadableOperatorType.ShiftLeft; op.Operator = OverloadableOperatorType.ShiftLeft;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.RightShift: case CSharp.OperatorType.RightShift:
op.Operator = OverloadableOperatorType.ShiftRight; op.Operator = OverloadableOperatorType.ShiftRight;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Equality: case CSharp.OperatorType.Equality:
op.Operator = OverloadableOperatorType.Equality; op.Operator = OverloadableOperatorType.Equality;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.Inequality: case CSharp.OperatorType.Inequality:
op.Operator = OverloadableOperatorType.InEquality; op.Operator = OverloadableOperatorType.InEquality;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThan: case CSharp.OperatorType.GreaterThan:
op.Operator = OverloadableOperatorType.GreaterThan; op.Operator = OverloadableOperatorType.GreaterThan;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThan: case CSharp.OperatorType.LessThan:
op.Operator = OverloadableOperatorType.LessThan; op.Operator = OverloadableOperatorType.LessThan;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.GreaterThanOrEqual: case CSharp.OperatorType.GreaterThanOrEqual:
op.Operator = OverloadableOperatorType.GreaterThanOrEqual; op.Operator = OverloadableOperatorType.GreaterThanOrEqual;
break; break;
case ICSharpCode.NRefactory.CSharp.OperatorType.LessThanOrEqual: case CSharp.OperatorType.LessThanOrEqual:
op.Operator = OverloadableOperatorType.LessThanOrEqual; op.Operator = OverloadableOperatorType.LessThanOrEqual;
break; break;
default: default:
@ -1861,7 +1862,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
ConvertNodes(parameterDeclaration.Attributes, param.Attributes); ConvertNodes(parameterDeclaration.Attributes, param.Attributes);
param.Modifiers = ConvertParamModifiers(parameterDeclaration.ParameterModifier); param.Modifiers = ConvertParamModifiers(parameterDeclaration.ParameterModifier);
if ((parameterDeclaration.ParameterModifier & ICSharpCode.NRefactory.CSharp.ParameterModifier.Out) == ICSharpCode.NRefactory.CSharp.ParameterModifier.Out) { if ((parameterDeclaration.ParameterModifier & CSharp.ParameterModifier.Out) == CSharp.ParameterModifier.Out) {
AttributeBlock block = new AttributeBlock(); AttributeBlock block = new AttributeBlock();
block.Attributes.Add(new Ast.Attribute() { Type = new SimpleType("Out") }); block.Attributes.Add(new Ast.Attribute() { Type = new SimpleType("Out") });
param.Attributes.Add(block); param.Attributes.Add(block);
@ -1878,13 +1879,13 @@ namespace ICSharpCode.NRefactory.VB.Visitors
Modifiers ConvertParamModifiers(CSharp.ParameterModifier mods) Modifiers ConvertParamModifiers(CSharp.ParameterModifier mods)
{ {
switch (mods) { switch (mods) {
case ICSharpCode.NRefactory.CSharp.ParameterModifier.None: case CSharp.ParameterModifier.None:
case ICSharpCode.NRefactory.CSharp.ParameterModifier.This: case CSharp.ParameterModifier.This:
return Modifiers.None; return Modifiers.None;
case ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref: case CSharp.ParameterModifier.Ref:
case ICSharpCode.NRefactory.CSharp.ParameterModifier.Out: case CSharp.ParameterModifier.Out:
return Modifiers.ByRef; return Modifiers.ByRef;
case ICSharpCode.NRefactory.CSharp.ParameterModifier.Params: case CSharp.ParameterModifier.Params:
return Modifiers.ParamArray; return Modifiers.ParamArray;
default: default:
throw new Exception("Invalid value for ParameterModifier"); throw new Exception("Invalid value for ParameterModifier");
@ -1934,7 +1935,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
// look for type in parent // look for type in parent
decl.Type = (AstType)variableInitializer.Parent decl.Type = (AstType)variableInitializer.Parent
.GetChildByRole(ICSharpCode.NRefactory.CSharp.Roles.Type) .GetChildByRole(CSharp.Roles.Type)
.AcceptVisitor(this, data); .AcceptVisitor(this, data);
decl.Identifiers.Add(new VariableIdentifier() { Name = variableInitializer.Name }); decl.Identifiers.Add(new VariableIdentifier() { Name = variableInitializer.Name });
decl.Initializer = (Expression)variableInitializer.Initializer.AcceptVisitor(this, data); decl.Initializer = (Expression)variableInitializer.Initializer.AcceptVisitor(this, data);
@ -2102,7 +2103,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
}; };
var constraint = typeParameterDeclaration.Parent var constraint = typeParameterDeclaration.Parent
.GetChildrenByRole(ICSharpCode.NRefactory.CSharp.Roles.Constraint) .GetChildrenByRole(CSharp.Roles.Constraint)
.SingleOrDefault(c => c.TypeParameter.Identifier == typeParameterDeclaration.Name); .SingleOrDefault(c => c.TypeParameter.Identifier == typeParameterDeclaration.Name);
if (constraint != null) if (constraint != null)

Write Preview
Loading…
Cancel
Save