public override List <IPropertyDefinition> Rewrite(List <IPropertyDefinition> propertyDefinitions)
{
TrimType currentType = CurrentTrimElement as TrimType;
List <IPropertyDefinition> newList = new List <IPropertyDefinition>();
if (propertyDefinitions == null)
{
return(newList);
}
foreach (IPropertyDefinition property in propertyDefinitions)
{
MemberElement currentElement = currentType.GetMemberElementFromMember(property);
if (currentElement != null)
{
_trimElements.Push(currentElement);
IPropertyDefinition newProperty = Rewrite(property);
newList.Add(newProperty);
_trimElements.Pop();
}
}
return(newList);
}
/// <summary>
/// Find the best match from a set of overloaded methods
/// </summary>
/// <param name="customInfoArray"></param>
/// <param name="previous"></param>
/// <param name="argTypes"></param>
private void ResolveOverloads(CustomMethodInfo[] customInfoArray, MemberElement previous, Type[] argTypes)
{
// Compute a score for each candidate
foreach (var customMethodInfo in customInfoArray)
{
customMethodInfo.ComputeScore(argTypes);
}
// Sort array from best to worst matches
Array.Sort(customInfoArray);
// Discard any matches that aren't accessible
customInfoArray = GetAccessibleInfos(customInfoArray);
// No accessible methods left
if (customInfoArray.Length == 0)
{
ThrowNoAccessibleMethodsException(previous);
}
// Handle case where we have more than one match with the same score
DetectAmbiguousMatches(customInfoArray);
// If we get here, then there is only one best match
targetMethodInfo = customInfoArray[0];
}
public InvocationListElement(IList elements, IServiceProvider services)
{
this.HandleFirstElement(elements, services);
LinkElements(elements);
Resolve(elements, services);
_myTail = (MemberElement)elements[elements.Count - 1];
}
/// <summary>
/// Try to find a match from a set of methods
/// </summary>
/// <param name="methods"></param>
/// <param name="previous"></param>
/// <param name="argTypes"></param>
private void BindToMethod(ICollection <MethodInfo> methods, MemberElement previous, Type[] argTypes)
{
List <CustomMethodInfo> customInfos = new List <CustomMethodInfo>();
// Wrap the MethodInfos in our custom class
foreach (MethodInfo mi in methods)
{
CustomMethodInfo cmi = new CustomMethodInfo(mi);
customInfos.Add(cmi);
}
// Discard any methods that cannot qualify as overloads
CustomMethodInfo[] arr = customInfos.ToArray();
customInfos.Clear();
foreach (CustomMethodInfo cmi in arr)
{
if (cmi.IsMatch(argTypes, MyPrevious, MyContext) == true)
{
customInfos.Add(cmi);
}
}
if (customInfos.Count == 0)
{
// We have no methods that can qualify as overloads; throw exception
this.ThrowFunctionNotFoundException(previous);
}
else
{
// At least one method matches our criteria; do our custom overload resolution
this.ResolveOverloads(customInfos.ToArray(), previous, argTypes);
}
}
public override List <IEventDefinition> Rewrite(List <IEventDefinition> eventDefinitions)
{
TrimType currentType = CurrentTrimElement as TrimType;
List <IEventDefinition> newList = new List <IEventDefinition>();
if (eventDefinitions == null)
{
return(newList);
}
foreach (IEventDefinition evnt in eventDefinitions)
{
MemberElement currentElement = currentType.GetMemberElementFromMember(evnt);
if (currentElement != null)
{
_trimElements.Push(currentElement);
IEventDefinition newEvnt = Rewrite(evnt);
newList.Add(newEvnt);
_trimElements.Pop();
}
}
return(newList);
}
/// <summary>
/// Try to find a match from a set of methods
/// </summary>
/// <param name="methods"></param>
/// <param name="previous"></param>
/// <param name="argTypes"></param>
private void BindToMethod(ICollection <MethodInfo> methods, MemberElement previous, Type[] argTypes)
{
var customInfoList = new List <CustomMethodInfo>();
// Wrap the MethodInfo in our custom class
foreach (var methodInfo in methods)
{
var customMethodInfo = new CustomMethodInfo(methodInfo);
customInfoList.Add(customMethodInfo);
}
// Discard any methods that cannot qualify as overloads
var infoArray = customInfoList.ToArray();
customInfoList.Clear();
foreach (var methodInfo in infoArray)
{
if (methodInfo.IsMatch(argTypes))
{
customInfoList.Add(methodInfo);
}
}
if (customInfoList.Count == 0)
{
// We have no methods that can qualify as overloads; throw exception
ThrowFunctionNotFoundException(previous);
}
else
{
// At least one method matches our criteria; do our custom overload resolution
ResolveOverloads(customInfoList.ToArray(), previous, argTypes);
}
}
public override List <IMethodDefinition> Rewrite(List <IMethodDefinition> methodDefinitions)
{
TrimType currentType = CurrentTrimElement as TrimType;
List <IMethodDefinition> newList = new List <IMethodDefinition>();
if (methodDefinitions == null)
{
return(newList);
}
foreach (IMethodDefinition method in methodDefinitions)
{
MemberElement currentElement = currentType.GetMemberElementFromMember(method);
if (currentElement != null)
{
_trimElements.Push(currentElement);
IMethodDefinition newMethod = Rewrite(method);
newList.Add(newMethod);
_trimElements.Pop();
}
}
return(newList);
}
/// <summary>
/// Find the best match from a set of overloaded methods
/// </summary>
/// <param name="infos"></param>
/// <param name="previous"></param>
/// <param name="argTypes"></param>
private void ResolveOverloads(CustomMethodInfo[] infos, MemberElement previous, Type[] argTypes)
{
// Compute a score for each candidate
foreach (CustomMethodInfo cmi in infos)
{
cmi.ComputeScore(argTypes);
}
// Sort array from best to worst matches
Array.Sort <CustomMethodInfo>(infos);
// Discard any matches that aren't accessible
infos = this.GetAccessibleInfos(infos);
// No accessible methods left
if (infos.Length == 0)
{
this.ThrowNoAccessibleMethodsException(previous);
}
// Handle case where we have more than one match with the same score
this.DetectAmbiguousMatches(infos);
// If we get here, then there is only one best match
_myTargetMethodInfo = infos[0];
}
public void TestMarkdownOutput()
{
reader.MoveToContent();
IElement element = new MemberElement(reader).Create("member");
Assert.AreEqual($@"#### T:TestDoc.TestClass \n\n", element.ToMarkdown());
}
private static bool AreValidExtensionMethodArgumentsForParameters(Type[] argTypes, ParameterInfo[] parameters,
MemberElement previous, ExpressionContext context)
{
Debug.Assert(argTypes.Length + 1 == parameters.Length);
if (previous != null)
{
if (ImplicitConverter.EmitImplicitConvert(previous.ResultType, parameters[0].ParameterType, null) == false)
{
return(false);
}
}
else if (context.ExpressionOwner != null)
{
if (ImplicitConverter.EmitImplicitConvert(context.ExpressionOwner.GetType(), parameters[0].ParameterType, null) == false)
{
return(false);
}
}
else
{
return(false);
}
// Match if every given argument is implicitly convertible to the method's corresponding parameter
for (int i = 0; i < argTypes.Length; i++)
{
if (ImplicitConverter.EmitImplicitConvert(argTypes[i], parameters[i + 1].ParameterType, null) == false)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Writes the code element body text.
/// </summary>
/// <param name="element">The element.</param>
private void WriteBody(TextCodeElement element)
{
MemberElement memberElement = element as MemberElement;
TypeElement parentTypeElement = GetTypeParent(element);
bool isAbstract = memberElement != null &&
(memberElement.MemberModifiers & MemberModifiers.Abstract) == MemberModifiers.Abstract;
bool inInterface = memberElement != null &&
parentTypeElement != null && parentTypeElement.Type == TypeElementType.Interface;
if (!(isAbstract || inInterface))
{
WriteBeginBlock();
Writer.WriteLine();
if (element.BodyText != null && element.BodyText.Trim().Length > 0)
{
WriteTextBlock(element.BodyText);
Writer.WriteLine();
WriteEndBlock(element);
WriteClosingComment(element, VBSymbol.BeginComment.ToString());
}
else
{
WriteEndBlock(element);
}
}
}
public InvocationListElement(IList elements, ExpressionContext context)
{
HandleFirstElement(elements, context);
LinkElements(elements);
Resolve(elements, context);
//Todo: What is the _tail reference?
_tail = (MemberElement)elements[elements.Count - 1];
}
/// <summary>
/// Is the given MethodInfo usable as an overload?
/// </summary>
/// <param name="argTypes"></param>
/// <returns></returns>
public bool IsMatch(Type[] argTypes, MemberElement previous, ExpressionContext context)
{
ParameterInfo[] parameters = _myTarget.GetParameters();
// If there are no parameters and no arguments were passed, then we are a match.
if (parameters.Length == 0 & argTypes.Length == 0)
{
return(true);
}
// If there are no parameters but there are arguments, we cannot be a match
if (parameters.Length == 0 & argTypes.Length > 0)
{
return(false);
}
// Is the last parameter a paramArray?
ParameterInfo lastParam = parameters[parameters.Length - 1];
if (lastParam.IsDefined(typeof(ParamArrayAttribute), false) == false)
{
//Extension method support
if (parameters.Length == argTypes.Length + 1)
{
IsExtensionMethod = true;
return(AreValidExtensionMethodArgumentsForParameters(argTypes, parameters, previous, context));
}
if ((parameters.Length != argTypes.Length))
{
// Not a paramArray and parameter and argument counts don't match
return(false);
}
else
{
// Regular method call, do the test
return(AreValidArgumentsForParameters(argTypes, parameters));
}
}
// At this point, we are dealing with a paramArray call
// If the parameter and argument counts are equal and there is an implicit conversion from one to the other, we are a match.
if (parameters.Length == argTypes.Length && AreValidArgumentsForParameters(argTypes, parameters) == true)
{
return(true);
}
else if (this.IsParamArrayMatch(argTypes, parameters, lastParam) == true)
{
IsParamArray = true;
return(true);
}
else
{
return(false);
}
}
private void ThrowNoAccessibleMethodsException(MemberElement previous)
{
if (previous == null)
{
base.ThrowCompileException(CompileErrorResourceKeys.NoAccessibleMatches, CompileExceptionReason.AccessDenied, MyName, _myArguments);
}
else
{
base.ThrowCompileException(CompileErrorResourceKeys.NoAccessibleMatchesOnType, CompileExceptionReason.AccessDenied, MyName, _myArguments, previous.TargetType.Name);
}
}
private void ThrowFunctionNotFoundException(MemberElement previous)
{
if (previous == null)
{
throw CreateCompileException(CompileErrors.UndefinedFunction, CompileExceptionReason.UndefinedName, MemberName, arguments);
}
else
{
throw CreateCompileException(CompileErrors.UndefinedFunctionOnType, CompileExceptionReason.UndefinedName, MemberName, arguments, previous.TargetType.Name);
}
}
private void ThrowFunctionNotFoundException(MemberElement previous)
{
if (previous == null)
{
base.ThrowCompileException(CompileErrorResourceKeys.UndefinedFunction, CompileExceptionReason.UndefinedName, MyName, _myArguments);
}
else
{
base.ThrowCompileException(CompileErrorResourceKeys.UndefinedFunctionOnType, CompileExceptionReason.UndefinedName, MyName, _myArguments, previous.TargetType.Name);
}
}
private void ThrowNoAccessibleMethodsException(MemberElement previous)
{
if (previous == null)
{
throw CreateCompileException(CompileErrors.NoAccessibleMatches, CompileExceptionReason.AccessDenied, MemberName, arguments);
}
else
{
throw CreateCompileException(CompileErrors.NoAccessibleMatchesOnType, CompileExceptionReason.AccessDenied, MemberName, arguments, previous.TargetType.Name);
}
}
public virtual TrimMember GetMemberElementFromMember(ITypeMemberReference member)
{
if (member == null || member.GetType().ToString().Contains("Dummy"))
{
throw new ArgumentNullException("member");
}
MemberElement memberElement = null;
_typeMembers.TryGetValue(Util.MemberKeyFromMember(member), out memberElement);
return(memberElement as TrimMember);
}
public static RootElement New(string mapName)
{
var obj = new RootElement(mapName);
var controller = new MemberElement("controller");
controller.Int.Add(new IntElement("ownership", 1));
obj.Member.Add(controller);
return(obj);
}
/// <summary>
/// Creates a clone of this instance.
/// </summary>
/// <returns>Cloned attribute element state.</returns>
protected override sealed AttributedElement DoAttributedClone()
{
MemberElement clone = DoMemberClone();
//
// Copy state
//
clone._memberModifiers = _memberModifiers;
clone._type = _type;
return(clone);
}
public void MemberElementTests()
{
// Type Element : Class
MemberElement typeElement = new MemberElement(XMLClassElement);
Assert.AreEqual($"## Class {XMLClassElement.Attribute("name").Value.Split('.').Last()}", typeElement.MarkdownValue);
// Property Element : Property
MemberElement propElement = new MemberElement(XMLPropertyElement);
Assert.AreEqual($"#### Property {XMLPropertyElement.Attribute("name").Value.Split('.').Last()}", propElement.MarkdownValue);
}
private ParamDeclaration DeclareParam(MemberElement param)
{
return(new ParamDeclaration
{
VkName = param.VkName,
Type = new TypeReference
{
VkName = param.Type,
PointerType = param.PointerType
},
Name = this.nameFormatter.FormatName(param, true)
});
}
/// <summary>
/// Arrange elements as a linked list
/// </summary>
/// <param name="elements"></param>
private static void LinkElements(IList elements)
{
for (int i = 0; i <= elements.Count - 1; i++)
{
MemberElement current = (MemberElement)elements[i];
MemberElement nextElement = null;
if (i + 1 < elements.Count)
{
nextElement = (MemberElement)elements[i + 1];
}
current.Link(nextElement);
}
}
private void AddReferencedVariable(MemberElement previous)
{
if ((previous != null))
{
return;
}
if ((_myVariableType != null) || MyOptions.IsOwnerType(this.MemberOwnerType) == true)
{
ExpressionInfo info = (ExpressionInfo)MyServices.GetService(typeof(ExpressionInfo));
info.AddReferencedVariable(MyName);
}
}
private bool ResolveVirtualProperty(MemberElement previous)
{
if (previous == null)
{
// We can't use virtual properties if we are the first element
return(false);
}
PropertyDescriptorCollection coll = TypeDescriptor.GetProperties(previous.ResultType);
_myPropertyDescriptor = coll.Find(MyName, true);
return(_myPropertyDescriptor != null);
}
private bool ResolveVirtualProperty(MemberElement previous)
{
if (previous == null)
{
// We can't use virtual properties if we are the first element
return(false);
}
var properties = TypeDescriptor.GetProperties(previous.ResultType);
propertyDescriptor = properties.Find(MemberName, true);
return(propertyDescriptor != null);
}
private void ReadMemberContent_correctly_parses_seealso_elements(string xml, SeeAlsoElement expected)
{
// ARRANGE
xml = $@"<container>{xml}</container>";
var sut = new XmlDocsReader(NullLogger.Instance, new XDocument(), Array.Empty <TypeId>());
var memberElement = new MemberElement(MemberId.Parse("T:DemoProject.DemoClass", Array.Empty <TypeId>()));
// ACT
sut.ReadMemberContent(XElement.Parse(xml), memberElement);
// ASSERT
var actual = Assert.Single(memberElement.SeeAlso);
Assert.Equal(expected, actual);
}
public void EmitFunctionCall(bool nextRequiresAddress, FleeILGenerator ilg, IServiceProvider services)
{
ParameterInfo[] parameters = this.Method.GetParameters();
ExpressionElement[] elements = _myArguments.ToArray();
// Emit either a regular or paramArray call
if (_myTargetMethodInfo.IsParamArray == false)
{
this.EmitRegularFunctionInternal(parameters, elements, ilg, services);
}
else
{
this.EmitParamArrayArguments(parameters, elements, ilg, services);
}
MemberElement.EmitMethodCall(this.ResultType, nextRequiresAddress, this.Method, ilg);
}
/// <summary>
/// Writes the end block for an element.
/// </summary>
/// <param name="codeElement">The code element.</param>
private void WriteEndBlock(CodeElement codeElement)
{
TabCount--;
MemberElement memberElement = codeElement as MemberElement;
string blockName = string.Empty;
if (memberElement != null)
{
if (memberElement.ElementType == ElementType.Method ||
memberElement.ElementType == ElementType.Constructor)
{
MethodElement methodElement = memberElement as MethodElement;
if (methodElement != null && methodElement.IsOperator)
{
blockName = VBKeyword.Operator;
}
else if (memberElement.Type != null)
{
blockName = VBKeyword.Function;
}
else
{
blockName = VBKeyword.Sub;
}
}
}
if (string.IsNullOrEmpty(blockName))
{
TypeElement typeElement = codeElement as TypeElement;
if (typeElement != null)
{
blockName = EnumUtilities.ToString(typeElement.Type);
}
if (string.IsNullOrEmpty(blockName))
{
blockName = EnumUtilities.ToString(codeElement.ElementType);
}
}
WriteIndented(VBKeyword.End + ' ' + blockName);
}
private bool ResolveFieldProperty(MemberElement previous)
{
MemberInfo[] members = this.GetMembers(MemberTypes.Field | MemberTypes.Property);
// Keep only the ones which are accessible
members = this.GetAccessibleMembers(members);
if (members.Length == 0)
{
// No accessible members; try to resolve a virtual property
return(this.ResolveVirtualProperty(previous));
}
else if (members.Length > 1)
{
// More than one accessible member
if (previous == null)
{
base.ThrowCompileException(CompileErrorResourceKeys.IdentifierIsAmbiguous, CompileExceptionReason.AmbiguousMatch, MyName);
}
else
{
base.ThrowCompileException(CompileErrorResourceKeys.IdentifierIsAmbiguousOnType, CompileExceptionReason.AmbiguousMatch, MyName, previous.TargetType.Name);
}
}
else
{
// Only one member; bind to it
_myField = members[0] as FieldInfo;
if ((_myField != null))
{
return(true);
}
// Assume it must be a property
_myProperty = (PropertyInfo)members[0];
return(true);
}
return(false);
}
