protected override void ReadSymbol(IMethodSymbol methodSymbol)
{
// we don't need to know about static members
// because they won't be delegated from child to mixin
if (methodSymbol.IsStatic)
return;
// skip methods that are not visible to the outside world
if (methodSymbol.DeclaredAccessibility == Accessibility.Private ||
methodSymbol.DeclaredAccessibility == Accessibility.Protected)
return;
// skip all property accessors and ctors
if (methodSymbol.MethodKind == MethodKind.Ordinary)
{
var isOverrideFromObject =
methodSymbol.IsOverride &&
methodSymbol.OverriddenMethod
?.ContainingType.SpecialType == SpecialType.System_Object;
var method = new Method(
methodSymbol.Name,
methodSymbol.ReturnType,
isOverrideFromObject)
{
IsAbstract = methodSymbol.IsAbstract,
IsOverride = methodSymbol.IsOverride,
IsInternal = methodSymbol.DeclaredAccessibility.HasFlag(Accessibility.Internal),
Documentation = new DocumentationComment(methodSymbol.GetDocumentationCommentXml())
};
var parameterReader = new ParameterSymbolReader(method);
parameterReader.VisitSymbol(methodSymbol);
_methods.AddMethod(method);
}
}
protected override Member CreateCopy()
{
var copy = new Method(Name, ReturnType, IsOverrideFromObject);
foreach (var parameter in Parameters)
copy.Add(new Parameter(parameter.Name, parameter.Type));
return copy;
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
var method = new Method(
node.Identifier.ToString(),
(ITypeSymbol)_semantic.GetSymbolInfo(node.ReturnType).Symbol);
// set correct modifiers
method.IsOverride = node.Modifiers.Any(x => x.IsKind(SyntaxKind.OverrideKeyword));
method.IsAbstract = node.Modifiers.Any(x => x.IsKind(SyntaxKind.AbstractKeyword));
// read parameters
var parameterSyntaxReader = new ParameterSyntaxReader(method, _semantic);
parameterSyntaxReader.Visit(node);
_methods.AddMethod(method);
// we don't care if the method here is abstract or not
// since methods that are defined directly in the child
// will never be overridden by mixin methods
}
/// <summary>
/// checks if one method has the same signature as
/// the other method. This is the case if the name and
/// the order and signature of the parameters is the same.
/// The return type does not play a rule since
/// two methods with the same name and parameters cannot
/// have the same return type.
/// </summary>
/// <param name = "first"></param>
/// <param name = "second"></param>
/// <returns></returns>
protected virtual bool IsEqual(Method first, Method second)
{
if (first.Name == second.Name)
{
if (first.ParameterCount == second.ParameterCount)
{
for (var i = 0; i < first.ParameterCount; i++)
{
if (!first.GetParameter(i).IsEqual(second.GetParameter(i)))
return false;
}
return true; // all parameters are same => methods are equal
}
return false;
}
return false;
}
public void AddMethod(Method newMethod)
{
_methods.AddMethod(newMethod);
newMethod.Class = this;
}
