| public GetTypeForField ( int fieldIndex ) : ICSharpCode.NRefactory.Ast.TypeReference | ||
| fieldIndex | int | |
| return | ICSharpCode.NRefactory.Ast.TypeReference | |
public object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
for (int i = 0; i < fieldDeclaration.Fields.Count; i++) {
ConvertField(fieldDeclaration.GetTypeForField(i), fieldDeclaration.Fields[i], fieldDeclaration);
}
return null;
}
public override object VisitFieldDeclaration(NRefactoryAST.FieldDeclaration fieldDeclaration, object data)
{
DomRegion region = GetRegion(fieldDeclaration.StartLocation, fieldDeclaration.EndLocation);
DefaultClass c = GetCurrentClass();
ModifierEnum modifier = ConvertModifier(fieldDeclaration.Modifier,
(c.ClassType == ClassType.Struct && this.IsVisualBasic)
? ModifierEnum.Public : ModifierEnum.Private);
string doku = GetDocumentation(region.BeginLine, fieldDeclaration.Attributes);
if (currentClass.Count > 0)
{
for (int i = 0; i < fieldDeclaration.Fields.Count; ++i)
{
NRefactoryAST.VariableDeclaration field = (NRefactoryAST.VariableDeclaration)fieldDeclaration.Fields[i];
IReturnType retType;
if (c.ClassType == ClassType.Enum)
{
retType = c.DefaultReturnType;
}
else
{
retType = CreateReturnType(fieldDeclaration.GetTypeForField(i));
if (!field.FixedArrayInitialization.IsNull)
{
retType = new ArrayReturnType(cu.ProjectContent, retType, 1);
}
}
DefaultField f = new DefaultField(retType, field.Name, modifier, region, c);
ConvertAttributes(fieldDeclaration, f);
f.Documentation = doku;
if (c.ClassType == ClassType.Enum)
{
f.Modifiers = ModifierEnum.Const | ModifierEnum.Public;
}
c.Fields.Add(f);
mapField(fieldDeclaration, f);
}
}
return(null);
}
void TransformWithEventsField(FieldDeclaration fieldDeclaration)
{
if (resolver.CallingClass == null)
return;
INode insertAfter = fieldDeclaration;
for (int i = 0; i < fieldDeclaration.Fields.Count;) {
VariableDeclaration field = fieldDeclaration.Fields[i];
IdentifierExpression backingFieldNameExpression = null;
PropertyDeclaration createdProperty = null;
foreach (IMethod m in resolver.CallingClass.GetCompoundClass().Methods) {
foreach (string handlesClause in m.HandlesClauses) {
int pos = handlesClause.IndexOf('.');
if (pos > 0) {
string fieldName = handlesClause.Substring(0, pos);
string eventName = handlesClause.Substring(pos + 1);
if (resolver.IsSameName(fieldName, field.Name)) {
if (createdProperty == null) {
FieldDeclaration backingField = new FieldDeclaration(null);
backingField.Fields.Add(new VariableDeclaration(
"withEventsField_" + field.Name, field.Initializer, fieldDeclaration.GetTypeForField(i)));
backingField.Modifier = Modifiers.Private;
InsertAfterSibling(insertAfter, backingField);
createdProperty = new PropertyDeclaration(fieldDeclaration.Modifier, null, field.Name, null);
createdProperty.TypeReference = fieldDeclaration.GetTypeForField(i);
createdProperty.StartLocation = fieldDeclaration.StartLocation;
createdProperty.EndLocation = fieldDeclaration.EndLocation;
backingFieldNameExpression = new IdentifierExpression(backingField.Fields[0].Name);
createdProperty.GetRegion = new PropertyGetRegion(new BlockStatement(), null);
createdProperty.GetRegion.Block.AddChild(new ReturnStatement(
backingFieldNameExpression));
Expression backingFieldNotNullTest = new BinaryOperatorExpression(
backingFieldNameExpression,
BinaryOperatorType.InEquality,
new PrimitiveExpression(null, "null"));
createdProperty.SetRegion = new PropertySetRegion(new BlockStatement(), null);
createdProperty.SetRegion.Block.AddChild(new IfElseStatement(
backingFieldNotNullTest, new BlockStatement()
));
createdProperty.SetRegion.Block.AddChild(new ExpressionStatement(
new AssignmentExpression(
backingFieldNameExpression,
AssignmentOperatorType.Assign,
new IdentifierExpression("value"))));
createdProperty.SetRegion.Block.AddChild(new IfElseStatement(
backingFieldNotNullTest, new BlockStatement()
));
InsertAfterSibling(backingField, createdProperty);
insertAfter = createdProperty;
}
// insert code to remove the event handler
IfElseStatement ies = (IfElseStatement)createdProperty.SetRegion.Block.Children[0];
ies.TrueStatement[0].AddChild(new RemoveHandlerStatement(
new MemberReferenceExpression(backingFieldNameExpression, eventName),
new AddressOfExpression(new IdentifierExpression(m.Name))));
// insert code to add the event handler
ies = (IfElseStatement)createdProperty.SetRegion.Block.Children[2];
ies.TrueStatement[0].AddChild(new AddHandlerStatement(
new MemberReferenceExpression(backingFieldNameExpression, eventName),
new AddressOfExpression(new IdentifierExpression(m.Name))));
}
}
}
}
if (createdProperty != null) {
// field replaced with property
fieldDeclaration.Fields.RemoveAt(i);
} else {
i++;
}
}
}
public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
for (int i = 0; i < fieldDeclaration.Fields.Count; ++i) {
VariableDeclaration field = (VariableDeclaration)fieldDeclaration.Fields[i];
if ((fieldDeclaration.Modifier & Modifiers.WithEvents) != 0) {
//this.withEventsFields.Add(field);
}
TypeReference fieldType = fieldDeclaration.GetTypeForField(i);
if (fieldType.IsNull) {
fieldType = new TypeReference(typeDeclarations.Peek().Name);
}
CodeMemberField memberField = new CodeMemberField(ConvType(fieldType), field.Name);
memberField.Attributes = ConvMemberAttributes(fieldDeclaration.Modifier);
if (!field.Initializer.IsNull) {
memberField.InitExpression = (CodeExpression)field.Initializer.AcceptVisitor(this, data);
}
typeDeclarations.Peek().Members.Add(memberField);
}
return null;
}
