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; }