From e0bfac9bd3bbe501c03268f7914adcde000f4d2d Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Sat, 14 May 2011 07:26:36 +0200 Subject: [PATCH] implement proper conversion of FieldDeclaration --- ICSharpCode.NRefactory.VB/Ast/AstNode.cs | 1 + ICSharpCode.NRefactory.VB/Ast/Enums.cs | 7 - .../Expressions/ObjectCreationExpression.cs | 20 +++ .../Ast/General/ParameterDeclaration.cs | 4 +- .../Ast/General/TypeParameterDeclaration.cs | 2 + .../Ast/TypeMembers/ConstructorDeclaration.cs | 7 +- .../Ast/TypeMembers/MethodDeclaration.cs | 84 ++++++++++- ICSharpCode.NRefactory.VB/IAstVisitor.cs | 3 + .../ICSharpCode.NRefactory.VB.csproj | 1 + .../OutputVisitor/OutputVisitor.cs | 84 ++++++++++- .../Visitors/CSharpToVBConverterVisitor.cs | 137 +++++++++++++++++- 11 files changed, 327 insertions(+), 23 deletions(-) create mode 100644 ICSharpCode.NRefactory.VB/Ast/Expressions/ObjectCreationExpression.cs diff --git a/ICSharpCode.NRefactory.VB/Ast/AstNode.cs b/ICSharpCode.NRefactory.VB/Ast/AstNode.cs index 2d69dc3ec8..6be2284466 100644 --- a/ICSharpCode.NRefactory.VB/Ast/AstNode.cs +++ b/ICSharpCode.NRefactory.VB/Ast/AstNode.cs @@ -702,6 +702,7 @@ namespace ICSharpCode.NRefactory.VB public static readonly Role LChevron = new Role("LChevron", VBTokenNode.Null); public static readonly Role RChevron = new Role("RChevron", VBTokenNode.Null); public static readonly Role Comma = new Role("Comma", VBTokenNode.Null); + public static readonly Role QuestionMark = new Role("QuestionMark", VBTokenNode.Null); public static readonly Role Dot = new Role("Dot", VBTokenNode.Null); public static readonly Role Semicolon = new Role("Semicolon", VBTokenNode.Null); public static readonly Role Assign = new Role("Assign", VBTokenNode.Null); diff --git a/ICSharpCode.NRefactory.VB/Ast/Enums.cs b/ICSharpCode.NRefactory.VB/Ast/Enums.cs index d0fc139296..0746032c2c 100644 --- a/ICSharpCode.NRefactory.VB/Ast/Enums.cs +++ b/ICSharpCode.NRefactory.VB/Ast/Enums.cs @@ -67,13 +67,6 @@ namespace ICSharpCode.NRefactory.VB.Ast Ref } - public enum VarianceModifier - { - Invariant, - Covariant, - Contravariant - }; - public enum AssignmentOperatorType { None, diff --git a/ICSharpCode.NRefactory.VB/Ast/Expressions/ObjectCreationExpression.cs b/ICSharpCode.NRefactory.VB/Ast/Expressions/ObjectCreationExpression.cs new file mode 100644 index 0000000000..f940c71b06 --- /dev/null +++ b/ICSharpCode.NRefactory.VB/Ast/Expressions/ObjectCreationExpression.cs @@ -0,0 +1,20 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) +// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) + +using System; + +namespace ICSharpCode.NRefactory.VB.Ast +{ + public class ObjectCreationExpression : Expression + { + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + throw new NotImplementedException(); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + throw new NotImplementedException(); + } + } +} diff --git a/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs b/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs index 87b4162b4f..f382cfeb5c 100644 --- a/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs +++ b/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs @@ -17,7 +17,7 @@ namespace ICSharpCode.NRefactory.VB.Ast set { SetChildByRole(Roles.Expression, value); } } - public AstType ReturnType { + public AstType Type { get { return GetChildByRole(Roles.Type); } set { SetChildByRole(Roles.Type, value); } } @@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.VB.Ast MatchAttributesAndModifiers(param, match) && Name.DoMatch(param.Name, match) && OptionalValue.DoMatch(param.OptionalValue, match) && - ReturnType.DoMatch(param.ReturnType, match); + Type.DoMatch(param.Type, match); } public override S AcceptVisitor(IAstVisitor visitor, T data) diff --git a/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs b/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs index 794615fc2a..bd3c541efa 100644 --- a/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs +++ b/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs @@ -5,6 +5,8 @@ using System; using System.Collections.Generic; using System.Linq; +using ICSharpCode.NRefactory.TypeSystem; + namespace ICSharpCode.NRefactory.VB.Ast { /// diff --git a/ICSharpCode.NRefactory.VB/Ast/TypeMembers/ConstructorDeclaration.cs b/ICSharpCode.NRefactory.VB/Ast/TypeMembers/ConstructorDeclaration.cs index e5a0b8a9fa..7076d2215a 100644 --- a/ICSharpCode.NRefactory.VB/Ast/TypeMembers/ConstructorDeclaration.cs +++ b/ICSharpCode.NRefactory.VB/Ast/TypeMembers/ConstructorDeclaration.cs @@ -5,10 +5,15 @@ using System; namespace ICSharpCode.NRefactory.VB.Ast { + public abstract class MemberDeclaration : AttributedNode + { + + } + /// /// Description of ConstructorDeclaration. /// - public class ConstructorDeclaration : AttributedNode + public class ConstructorDeclaration : MemberDeclaration { public ConstructorDeclaration() { diff --git a/ICSharpCode.NRefactory.VB/Ast/TypeMembers/MethodDeclaration.cs b/ICSharpCode.NRefactory.VB/Ast/TypeMembers/MethodDeclaration.cs index 4cbe73da28..e3614e2f5f 100644 --- a/ICSharpCode.NRefactory.VB/Ast/TypeMembers/MethodDeclaration.cs +++ b/ICSharpCode.NRefactory.VB/Ast/TypeMembers/MethodDeclaration.cs @@ -5,7 +5,7 @@ using System; namespace ICSharpCode.NRefactory.VB.Ast { - public class MethodDeclaration : AttributedNode + public class MethodDeclaration : MemberDeclaration { public MethodDeclaration() { @@ -69,4 +69,86 @@ namespace ICSharpCode.NRefactory.VB.Ast return visitor.VisitMethodDeclaration(this, data); } } + + /// + /// Attributes? VariableModifier+ VariableDeclarators StatementTerminator + /// + public class FieldDeclaration : MemberDeclaration + { + public AstNodeCollection Variables { + get { return GetChildrenByRole(VariableDeclarator.VariableDeclaratorRole); } + } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + throw new NotImplementedException(); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitFieldDeclaration(this, data); + } + } + + /// + /// VariableIdentifiers As ObjectCreationExpression
+ /// VariableIdentifiers ( As TypeName )? ( Equals Expression )? + /// + public class VariableDeclarator : AstNode + { + public static readonly Role VariableDeclaratorRole = new Role("VariableDeclarator"); + + public AstNodeCollection Identifiers { + get { return GetChildrenByRole(VariableIdentifier.VariableIdentifierRole); } + } + + public AstType Type { + get { return GetChildByRole(Roles.Type); } + set { SetChildByRole(Roles.Type, value); } + } + + public Expression Initializer { + get { return GetChildByRole(Roles.Expression); } + set { SetChildByRole(Roles.Expression, value); } + } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + throw new NotImplementedException(); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitVariableDeclarator(this, data); + } + } + + /// + /// Identifier IdentifierModifiers + /// + public class VariableIdentifier : AstNode + { + public static readonly Role VariableIdentifierRole = new Role("VariableIdentifier"); + + public Identifier Name { + get { return GetChildByRole(Roles.Identifier); } + set { SetChildByRole(Roles.Identifier, value); } + } + + public bool HasNullableSpecifier { get; set; } + + public AstNodeCollection ArraySpecifiers { + get { return GetChildrenByRole(ComposedType.ArraySpecifierRole); } + } + + protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match) + { + throw new NotImplementedException(); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitVariableIdentifier(this, data); + } + } } diff --git a/ICSharpCode.NRefactory.VB/IAstVisitor.cs b/ICSharpCode.NRefactory.VB/IAstVisitor.cs index 1b702c15af..4f2342273a 100644 --- a/ICSharpCode.NRefactory.VB/IAstVisitor.cs +++ b/ICSharpCode.NRefactory.VB/IAstVisitor.cs @@ -34,6 +34,9 @@ namespace ICSharpCode.NRefactory.VB { // TypeMember scope S VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, T data); S VisitMethodDeclaration(MethodDeclaration methodDeclaration, T data); + S VisitFieldDeclaration(FieldDeclaration fieldDeclaration, T data); + S VisitVariableDeclarator(VariableDeclarator variableDeclarator, T data); + S VisitVariableIdentifier(VariableIdentifier variableIdentifier, T data); // Expression scope S VisitIdentifier(Identifier identifier, T data); diff --git a/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj b/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj index d826ea8b5f..4b176c48ad 100644 --- a/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj +++ b/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj @@ -53,6 +53,7 @@ + diff --git a/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs b/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs index 7e26773403..c6f67ebd0c 100644 --- a/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs +++ b/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs @@ -82,7 +82,18 @@ namespace ICSharpCode.NRefactory.VB public object VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data) { - throw new NotImplementedException(); + StartNode(parameterDeclaration); + WriteModifiers(parameterDeclaration.ModifierTokens); + WriteIdentifier(parameterDeclaration.Name.Name); + if (!parameterDeclaration.Type.IsNull) { + WriteKeyword("As"); + parameterDeclaration.Type.AcceptVisitor(this, data); + } + if (!parameterDeclaration.OptionalValue.IsNull) { + WriteToken("=", ParameterDeclaration.Roles.Assign); + parameterDeclaration.OptionalValue.AcceptVisitor(this, data); + } + return EndNode(parameterDeclaration); } public object VisitVBTokenNode(VBTokenNode vBTokenNode, object data) @@ -430,7 +441,11 @@ namespace ICSharpCode.NRefactory.VB #region TypeName public object VisitPrimitiveType(PrimitiveType primitiveType, object data) { - throw new NotImplementedException(); + StartNode(primitiveType); + + WriteKeyword(primitiveType.Keyword); + + return EndNode(primitiveType); } public object VisitQualifiedType(QualifiedType qualifiedType, object data) @@ -452,7 +467,15 @@ namespace ICSharpCode.NRefactory.VB public object VisitArraySpecifier(ArraySpecifier arraySpecifier, object data) { - throw new NotImplementedException(); + StartNode(arraySpecifier); + + LPar(); + for (int i = 0; i < arraySpecifier.Dimensions; i++) { + WriteToken(",", ArraySpecifier.Roles.Comma); + } + RPar(); + + return EndNode(arraySpecifier); } public object VisitSimpleType(SimpleType simpleType, object data) @@ -687,11 +710,14 @@ namespace ICSharpCode.NRefactory.VB if (IsKeyword(identifier, containerStack.Peek())) { if (lastWritten == LastWritten.KeywordOrIdentifier) Space(); // this space is not strictly required, so we call Space() - formatter.WriteToken("@"); + formatter.WriteToken("["); } else if (lastWritten == LastWritten.KeywordOrIdentifier) { formatter.Space(); // this space is strictly required, so we directly call the formatter } formatter.WriteIdentifier(identifier); + if (IsKeyword(identifier, containerStack.Peek())) { + formatter.WriteToken("]"); + } lastWritten = LastWritten.KeywordOrIdentifier; } @@ -887,6 +913,13 @@ namespace ICSharpCode.NRefactory.VB } } + void WriteArraySpecifiers(IEnumerable arraySpecifiers) + { + foreach (ArraySpecifier specifier in arraySpecifiers) { + specifier.AcceptVisitor(this, null); + } + } + void WriteQualifiedIdentifier(IEnumerable identifiers) { bool first = true; @@ -1074,5 +1107,48 @@ namespace ICSharpCode.NRefactory.VB return sb.ToString(); } #endregion + + public object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) + { + StartNode(fieldDeclaration); + + WriteAttributes(fieldDeclaration.Attributes); + WriteModifiers(fieldDeclaration.ModifierTokens); + WriteCommaSeparatedList(fieldDeclaration.Variables); + NewLine(); + + return EndNode(fieldDeclaration); + } + + public object VisitVariableDeclarator(VariableDeclarator variableDeclarator, object data) + { + StartNode(variableDeclarator); + + WriteCommaSeparatedList(variableDeclarator.Identifiers); + WriteKeyword("As"); + if (variableDeclarator.Initializer is ObjectCreationExpression) + variableDeclarator.Initializer.AcceptVisitor(this, data); + else { + variableDeclarator.Type.AcceptVisitor(this, data); + if (!variableDeclarator.Initializer.IsNull) { + WriteToken("=", VariableDeclarator.Roles.Assign); + variableDeclarator.Initializer.AcceptVisitor(this, data); + } + } + + return EndNode(variableDeclarator); + } + + public object VisitVariableIdentifier(VariableIdentifier variableIdentifier, object data) + { + StartNode(variableIdentifier); + + WriteIdentifier(variableIdentifier.Name.Name); + if (variableIdentifier.HasNullableSpecifier) + WriteToken("?", VariableIdentifier.Roles.QuestionMark); + WriteArraySpecifiers(variableIdentifier.ArraySpecifiers); + + return EndNode(variableIdentifier); + } } } diff --git a/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs index 8c38d7ce8c..89f22afbf5 100644 --- a/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs +++ b/ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs @@ -552,7 +552,13 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitFieldDeclaration(CSharp.FieldDeclaration fieldDeclaration, object data) { - throw new NotImplementedException(); + var decl = new FieldDeclaration(); + + ConvertNodes(fieldDeclaration.Attributes, decl.Attributes); + decl.Modifiers = ConvertModifiers(fieldDeclaration.Modifiers, fieldDeclaration); + ConvertNodes(fieldDeclaration.Variables, decl.Variables); + + return EndNode(fieldDeclaration, decl); } public AstNode VisitIndexerDeclaration(CSharp.IndexerDeclaration indexerDeclaration, object data) @@ -593,17 +599,53 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitParameterDeclaration(CSharp.ParameterDeclaration parameterDeclaration, object data) { - throw new NotImplementedException(); + var param = new ParameterDeclaration(); + + ConvertNodes(parameterDeclaration.Attributes, param.Attributes); + param.Modifiers = ConvertParamModifiers(parameterDeclaration.ParameterModifier); + param.Name = new Identifier(parameterDeclaration.Name, AstLocation.Empty); + param.Type = (AstType)parameterDeclaration.Type.AcceptVisitor(this, data); + param.OptionalValue = (Expression)parameterDeclaration.DefaultExpression.AcceptVisitor(this, data); + if (!param.OptionalValue.IsNull) + param.Modifiers |= Modifiers.Optional; + + return EndNode(parameterDeclaration, param); + } + + Modifiers ConvertParamModifiers(CSharp.ParameterModifier mods) + { + switch (mods) { + case ICSharpCode.NRefactory.CSharp.ParameterModifier.None: + case ICSharpCode.NRefactory.CSharp.ParameterModifier.This: + return Modifiers.None; + case ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref: + return Modifiers.ByRef; + case ICSharpCode.NRefactory.CSharp.ParameterModifier.Out: + return Modifiers.ByRef; // TODO verify this! + case ICSharpCode.NRefactory.CSharp.ParameterModifier.Params: + return Modifiers.ParamArray; + default: + throw new Exception("Invalid value for ParameterModifier"); + } } public AstNode VisitPropertyDeclaration(CSharp.PropertyDeclaration propertyDeclaration, object data) { - throw new NotImplementedException(); + return null; } public AstNode VisitVariableInitializer(CSharp.VariableInitializer variableInitializer, object data) { - throw new NotImplementedException(); + var decl = new VariableDeclarator(); + + // look for type in parent + decl.Type = (AstType)variableInitializer.Parent + .GetChildByRole(CSharp.VariableInitializer.Roles.Type) + .AcceptVisitor(this, data); + decl.Identifiers.Add(new VariableIdentifier() { Name = new Identifier(variableInitializer.Name, AstLocation.Empty) }); + decl.Initializer = (Expression)variableInitializer.Initializer.AcceptVisitor(this, data); + + return EndNode(variableInitializer, decl); } public AstNode VisitFixedFieldDeclaration(CSharp.FixedFieldDeclaration fixedFieldDeclaration, object data) @@ -644,23 +686,83 @@ namespace ICSharpCode.NRefactory.VB.Visitors target = (AstType)memberType.Target.AcceptVisitor(this, data); var type = new QualifiedType(target, new Identifier(memberType.MemberName, AstLocation.Empty)); + ConvertNodes(memberType.TypeArguments, type.TypeArguments); return EndNode(memberType, type); } public AstNode VisitComposedType(CSharp.ComposedType composedType, object data) { - throw new NotImplementedException(); + var type = new ComposedType(); + + ConvertNodes(composedType.ArraySpecifiers, type.ArraySpecifiers); + type.BaseType = (AstType)composedType.BaseType.AcceptVisitor(this, data); + type.HasNullableSpecifier = composedType.HasNullableSpecifier; + + return EndNode(composedType, type); } public AstNode VisitArraySpecifier(CSharp.ArraySpecifier arraySpecifier, object data) { - throw new NotImplementedException(); + return EndNode(arraySpecifier, new ArraySpecifier(arraySpecifier.Dimensions)); } public AstNode VisitPrimitiveType(CSharp.PrimitiveType primitiveType, object data) { - throw new NotImplementedException(); + string typeName; + + switch (primitiveType.Keyword) { + case "object": + typeName = "Object"; + break; + case "bool": + typeName = "Boolean"; + break; + case "char": + typeName = "Char"; + break; + case "sbyte": + typeName = "SByte"; + break; + case "byte": + typeName = "Byte"; + break; + case "short": + typeName = "Short"; + break; + case "ushort": + typeName = "UShort"; + break; + case "int": + typeName = "Integer"; + break; + case "uint": + typeName = "UInteger"; + break; + case "long": + typeName = "Long"; + break; + case "ulong": + typeName = "ULong"; + break; + case "float": + typeName = "Single"; + break; + case "double": + typeName = "Double"; + break; + case "decimal": + typeName = "Decimal"; + break; + case "string": + typeName = "String"; + break; + default: + typeName = "unknown"; + break; + } + + return EndNode(primitiveType, new PrimitiveType(typeName)); } public AstNode VisitComment(CSharp.Comment comment, object data) @@ -670,7 +772,17 @@ namespace ICSharpCode.NRefactory.VB.Visitors public AstNode VisitTypeParameterDeclaration(CSharp.TypeParameterDeclaration typeParameterDeclaration, object data) { - throw new NotImplementedException(); + var param = new TypeParameterDeclaration() { + Variance = typeParameterDeclaration.Variance, + Name = typeParameterDeclaration.Name + }; + + // TODO : fetch constraints from parent node + + // TODO : typeParameterDeclaration.Attributes get lost? + //ConvertNodes(typeParameterDeclaration.Attributes + + return EndNode(typeParameterDeclaration, param); } public AstNode VisitConstraint(CSharp.Constraint constraint, object data) @@ -712,6 +824,15 @@ namespace ICSharpCode.NRefactory.VB.Visitors if ((modifier & CSharp.Modifiers.Static) == CSharp.Modifiers.Static) mod |= Modifiers.Shared; + if ((modifier & CSharp.Modifiers.Public) == CSharp.Modifiers.Public) + mod |= Modifiers.Public; + if ((modifier & CSharp.Modifiers.Protected) == CSharp.Modifiers.Protected) + mod |= Modifiers.Protected; + if ((modifier & CSharp.Modifiers.Internal) == CSharp.Modifiers.Internal) + mod |= Modifiers.Friend; + if ((modifier & CSharp.Modifiers.Private) == CSharp.Modifiers.Private) + mod |= Modifiers.Private; + return mod; }