private void CombineGetSetAccess(ClassDeclaration classNode)
{
List <Node> removedNodes = new List <Node>();
for (int i = 0; i < classNode.Members.Count; i++)
{
if (classNode.Members[i].Kind != NodeKind.GetAccessor)
{
continue;
}
GetAccessor getAccessor = classNode.Members[i] as GetAccessor;
SetAccessor setAccessor = classNode.Members.Find(c =>
(c.Kind == NodeKind.SetAccessor) &&
((c as SetAccessor).Name.Text == getAccessor.Name.Text)) as SetAccessor;
if (setAccessor != null)
{
removedNodes.Add(getAccessor);
removedNodes.Add(setAccessor);
Node getSestAccessor = NodeHelper.CreateNode(NodeKind.GetSetAccessor);
getSestAccessor.Parent = classNode;
getSestAccessor.AddChild(getAccessor.TsNode);
getSestAccessor.AddChild(setAccessor.TsNode);
classNode.InsertMember(i++, getSestAccessor);
}
}
classNode.RemoveAllMembers(m => removedNodes.IndexOf(m) >= 0);
}
private void InferType(GetAccessor node)
{
if (node.Type == null)
{
node.SetType(NodeHelper.CreateNode(NodeKind.AnyKeyword));
}
}
public DelegatedEncodingMember(
string name,
GetAccessor <TInstance, TMember> getAccessor,
SetAccessor <TInstance, TMember> setAccessor)
{
this.name = name;
this.getAccessor = getAccessor;
this.setAccessor = setAccessor;
}
public GetAccessor[] GetAllGetAccessors(Type type)
{
Dictionary <RuntimeMethodHandle, GetAccessor> propertyTable = new Dictionary <RuntimeMethodHandle, GetAccessor>();
var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < properties.Length; i++)
{
var property = properties[i];
var method = property.GetGetMethod();
GetAccessor getAccessor = new GetAccessor()
{
MethodBase = method,
ReturnType = property.PropertyType
};
if (!propertyTable.ContainsKey(method.MethodHandle))
{
propertyTable.Add(method.MethodHandle, getAccessor);
}
}
var interfaces = type.GetInterfaces();
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < interfaces.Length; i++)
{
var interfaceDeclaration = interfaces[i];
properties = interfaceDeclaration.GetProperties(BindingFlags.Public | BindingFlags.Instance);
// ReSharper disable once ForCanBeConvertedToForeach
for (var j = 0; j < properties.Length; j++)
{
var property = properties[j];
var method = property.GetGetMethod(true);
if (!propertyTable.ContainsKey(method.MethodHandle))
{
GetAccessor getAccessor = new GetAccessor()
{
MethodBase = method,
ReturnType = property.PropertyType
};
propertyTable.Add(method.MethodHandle, getAccessor);
}
}
}
return(propertyTable.Values.ToArray());
}
private bool IsTheSame(Indexer comparisonIndexer, ComparisonDepth depth)
{
if (comparisonIndexer == null)
{
return(false);
}
if (Name == comparisonIndexer.Name &&
DataType == comparisonIndexer.DataType &&
Parameters.Count == comparisonIndexer.Parameters.Count)
{
for (int i = 0; i < Parameters.Count; i++)
{
if (Parameters[i].Name != comparisonIndexer.Parameters[i].Name ||
Parameters[i].DataType != comparisonIndexer.Parameters[i].DataType)
{
return(false);
}
}
// Function names are the same, so now compare the class names
// TODO: Parent object comparison
//if (ParentObject.IsTheSame(comparisonIndexer.ParentObject))
{
if (depth == ComparisonDepth.Signature)
{
return(true);
}
if (!base.IsTheSame(comparisonIndexer, depth))
{
return(false);
}
if (depth == ComparisonDepth.Outer)
{
return(true);
}
if (!GetAccessor.IsTheSame(comparisonIndexer.GetAccessor))
{
ComparisonDifference += GetType().Name + ".GetAccessor";
return(false);
}
if (!SetAccessor.IsTheSame(comparisonIndexer.SetAccessor))
{
ComparisonDifference += GetType().Name + ".SetAccessor";
return(false);
}
return(true);
}
}
return(false);
}
public CSharpSyntaxNode Convert(GetAccessor node)
{
PropertyDeclarationSyntax csProperty = SyntaxFactory
.PropertyDeclaration(node.Type.ToCsNode <TypeSyntax>(), node.Name.Text)
.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>());
if (node.JsDoc.Count > 0)
{
csProperty = csProperty.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>()));
}
AccessorDeclarationSyntax csGetAccess = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration);
if (node.Body != null)
{
csGetAccess = csGetAccess.WithBody(node.Body.ToCsNode <BlockSyntax>());
}
else
{
csGetAccess = csGetAccess.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
return(csProperty.AddAccessorListAccessors(csGetAccess));
}
/// <summary> /// Accesses a field for an object by name. /// </summary> /// <param name="obj">the object to access the field of</param> /// <param name="name">the name of the field to access</param> /// <returns>a reference to the object at the field</returns> /// <exception cref="MissingFieldException">if the field does not exist on <typeparamref name="T"/></exception> /// <seealso cref="GetAccessor(string)"/> public static ref U Access(ref T obj, string name) => ref GetAccessor(name)(ref obj);
