public IMember FindBaseMembers()
{
var result = InheritanceHelper.GetBaseMembers(this, false);
//var result = bm
// .Where(m => m.DeclaringTypeDefinition != null && m.DeclaringTypeDefinition.Kind == TypeKind.Class)
// .ToArray();
////IEnumerable<IMember> otherMembers = DeclaringTypeDefinition.Members;
////if (SymbolKind == SymbolKind.Accessor)
//// otherMembers = DeclaringTypeDefinition.GetAccessors(options: GetMemberOptions.IgnoreInheritedMembers);
////result = result.Where(item => !otherMembers.Any(m => m.IsExplicitInterfaceImplementation && m.ImplementedInterfaceMembers.Contains(item))).ToArray();
return(result.FirstOrDefault());
}
static IMember FindDerivedMember(IMember importedMember, ITypeDefinition derivedType)
{
IMember derivedMember;
if (importedMember.DeclaringTypeDefinition.Kind == TypeKind.Interface)
{
derivedMember = derivedType.GetMembers(null, GetMemberOptions.IgnoreInheritedMembers)
.FirstOrDefault(m => m.ImplementedInterfaceMembers.Any(im => im.Region == importedMember.Region));
}
else
{
derivedMember = InheritanceHelper.GetDerivedMember(importedMember, derivedType);
}
return(derivedMember);
}
bool IsInactiveConditionalMethod(IParameterizedMember member)
{
if (member.SymbolKind != SymbolKind.Method || member.ReturnType.Kind != TypeKind.Void)
{
return(false);
}
foreach (var baseMember in InheritanceHelper.GetBaseMembers(member, false))
{
if (IsInactiveConditional(baseMember.Attributes))
{
return(true);
}
}
return(IsInactiveConditional(member.Attributes));
}
Accessibility ComputeAccessibility()
{
var baseAcc = base.Accessibility;
if (IsOverride && !(CanGet && CanSet))
{
foreach (var baseMember in InheritanceHelper.GetBaseMembers(this, false))
{
if (!baseMember.IsOverride)
{
return(baseMember.Accessibility);
}
}
}
return(baseAcc);
}
bool IsInactiveConditionalMethod(IParameterizedMember member)
{
if (member.EntityType != EntityType.Method || member.ReturnType.Kind != TypeKind.Void)
{
return(false);
}
while (member.IsOverride)
{
member = (IParameterizedMember)InheritanceHelper.GetBaseMember(member);
if (member == null)
{
return(false);
}
}
return(IsInactiveConditional(member.Attributes));
}
protected virtual int GetIndex(IMember member)
{
var originalMember = member;
while (member != null && member.IsOverride && !this.IsTemplateOverride(member))
{
member = InheritanceHelper.GetBaseMember(member);
}
if (member == null)
{
member = originalMember;
}
return(this.Members.IndexOf(member.MemberDefinition));
}
Accessibility ComputeAccessibility()
{
if (IsOverride && (getter == null || setter == null))
{
foreach (var baseMember in InheritanceHelper.GetBaseMembers(this, includeImplementedInterfaces: false))
{
if (!baseMember.IsOverride)
{
return(baseMember.Accessibility);
}
}
}
return(AccessibilityExtensions.Union(
this.Getter?.Accessibility ?? Accessibility.None,
this.Setter?.Accessibility ?? Accessibility.None));
}
public override void VisitInvocationExpression(InvocationExpression invocationExpression)
{
base.VisitInvocationExpression(invocationExpression);
var mr = invocationExpression.Target as MemberReferenceExpression;
if (mr == null || !(mr.Target is BaseReferenceExpression))
{
return;
}
var invocationRR = ctx.Resolve(invocationExpression) as InvocationResolveResult;
if (invocationRR == null)
{
return;
}
var parentEntity = invocationExpression.GetParent <EntityDeclaration>();
if (parentEntity == null)
{
return;
}
var rr = ctx.Resolve(parentEntity) as MemberResolveResult;
if (rr == null)
{
return;
}
if (invocationExpression.Arguments.Count >= invocationRR.Member.Parameters.Count ||
invocationRR.Member.Parameters.Count == 0 ||
!invocationRR.Member.Parameters.Last().IsOptional)
{
return;
}
if (!InheritanceHelper.GetBaseMembers(rr.Member, false).Any(m => m == invocationRR.Member))
{
return;
}
AddIssue(new CodeIssue(
invocationExpression.RParToken,
ctx.TranslateString("Call to base member with implicit default parameters")
));
}
void Check(EntityDeclaration entity)
{
if (!entity.HasModifier(Modifiers.Override))
{
return;
}
var rr = ctx.Resolve(entity) as MemberResolveResult;
if (rr == null || rr.IsError)
{
return;
}
var method = rr.Member as IParameterizedMember;
if (method == null)
{
return;
}
var baseMethod = InheritanceHelper.GetBaseMember(method) as IParameterizedMember;
if (baseMethod == null)
{
return;
}
for (int i = 0; i < Math.Min(method.Parameters.Count, baseMethod.Parameters.Count); i++)
{
var arg = method.Parameters[i];
var baseArg = baseMethod.Parameters[i];
if (arg.Name != baseArg.Name)
{
int _i = i;
var parameters = entity.GetChildrenByRole(Roles.Parameter);
AddIssue(new CodeIssue(
parameters.ElementAt(_i).NameToken,
ctx.TranslateString("Parameter name differs in base method declaration"),
string.Format(ctx.TranslateString("Rename to '{0}'"), baseArg.Name),
s => {
s.Rename(arg, baseArg.Name);
}
));
}
}
}
public void Setup()
{
String uri = "tcp://localhost:4003";
MainInheritanceListener implFactory = new MainInheritanceListener();
listener = InheritanceHelper.NewListener(uri, null, implFactory);
listener.TransportControl(TransportConsts.START_AND_WAIT_UP, 4000);
MainInheritanceClient client = new MainInheritanceClient();
server = InheritanceHelper.NewServer(uri, null, client);
// server._TransportControl(Etch.Transport.TransportConsts.START_AND_WAIT_UP, 4000);
server._StartAndWaitUp(4000);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
var lastParam = methodDeclaration.Parameters.LastOrDefault();
if (lastParam == null || lastParam.ParameterModifier != ParameterModifier.Params)
{
return;
}
var type = lastParam.Type as ComposedType;
if (type == null || !type.ArraySpecifiers.Any())
{
return;
}
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr == null)
{
return;
}
var baseMember = InheritanceHelper.GetBaseMember(rr.Member) as IMethod;
if (baseMember == null || baseMember.Parameters.Count == 0 || baseMember.Parameters.Last().IsParams)
{
return;
}
AddIssue(new CodeIssue(
lastParam.GetChildByRole(ParameterDeclaration.ParamsModifierRole),
ctx.TranslateString("'params' is always ignored in overrides"),
ctx.TranslateString("Remove 'params' modifier"),
script => {
var p = (ParameterDeclaration)lastParam.Clone();
p.ParameterModifier = ParameterModifier.None;
script.Replace(lastParam, p);
}
)
{
IssueMarker = IssueMarker.GrayOut
});
}
///
/// <summary>Main for InheritanceClient</summary>
/// <param name="args"></param>
///
public static void Main(String[] args)
{
string uri = "tcp://localhost:4001";
if (args.Length > 0)
{
uri = args[0];
}
MainInheritanceClient implFactory = new MainInheritanceClient();
RemoteInheritanceServer server = InheritanceHelper.NewServer(uri, null, implFactory);
server._TransportControl(TransportConsts.START_AND_WAIT_UP, 4000);
// Insert Your Code Here
//---------------------------------------------------------------------
server._TransportControl(TransportConsts.STOP_AND_WAIT_DOWN, 4000);
}
public IEnumerable <IMember> GetOverridableMembers()
{
// Disallow trying to override in e.g. interfaces or enums
if (this.CurrentType.Kind != TypeKind.Class &&
this.CurrentType.Kind != TypeKind.Struct)
{
return(new IMember[0]);
}
var candidates = this.CurrentType
.GetMembers(m => (m.IsVirtual || m.IsAbstract) && m.IsOverridable).ToArray();
var overridden = this.CurrentType
.GetMembers(m => m.IsOverride &&
m.DeclaringTypeDefinition == currentTypeDefinition)
.SelectMany(m => InheritanceHelper.GetBaseMembers(m, true));
return(candidates.Except(overridden));
}
private static CompilerRule[] GetVirtualMemberRules(IEmitter emitter, IEntity entity)
{
if (entity is IMember member)
{
if (member.IsOverride)
{
var baseMember = InheritanceHelper.GetBaseMember(member);
return(new[] { Rules.Get(emitter, baseMember) });
}
if (member.ImplementedInterfaceMembers.Count > 0)
{
var interfaceMember = member.ImplementedInterfaceMembers.First();
return(Rules.GetClassRules(emitter, interfaceMember.DeclaringTypeDefinition));
}
}
return(null);
}
void VisitParameterizedEntityDeclaration(string memberType, EntityDeclaration entityDeclaration, AstNodeCollection <ParameterDeclaration> parameters)
{
// Ignore explicit interface implementations (those should have no optional parameters as there can't be any direct calls)
if (!entityDeclaration.GetChildByRole(EntityDeclaration.PrivateImplementationTypeRole).IsNull)
{
return;
}
//Override is not strictly necessary because methodDeclaration
//might still implement an interface member
var memberResolveResult = ctx.Resolve(entityDeclaration) as MemberResolveResult;
if (memberResolveResult == null)
{
return;
}
var member = (IParameterizedMember)memberResolveResult.Member;
var baseMembers = InheritanceHelper.GetBaseMembers(member, true).ToList();
foreach (IParameterizedMember baseMember in baseMembers)
{
if (baseMember.IsOverride || baseMember.DeclaringType.Kind == TypeKind.Interface)
{
continue;
}
CompareMethods(memberType, parameters, member, baseMember);
return;
}
// only check 1 interface method -> multiple interface implementations could lead to deault value conflicts
// possible other solutions: Skip the interface check entirely
var interfaceBaseMethods = baseMembers.Where(b => b.DeclaringType.Kind == TypeKind.Interface).ToList();
if (interfaceBaseMethods.Count == 1)
{
foreach (IParameterizedMember baseMember in interfaceBaseMethods)
{
if (baseMember.DeclaringType.Kind == TypeKind.Interface)
{
CompareMethods(memberType, parameters, member, baseMember);
}
}
}
}
IEnumerable <IEntity> AnalyzeType(IEvent analyzedEntity, ITypeDefinition type)
{
var token = analyzedEntity.DeclaringTypeDefinition.MetadataToken;
var module = analyzedEntity.DeclaringTypeDefinition.ParentModule.PEFile;
if (!type.GetAllBaseTypeDefinitions()
.Any(t => t.MetadataToken == token && t.ParentModule.PEFile == module))
{
yield break;
}
foreach (var @event in type.GetEvents(options: GetMemberOptions.ReturnMemberDefinitions))
{
if (InheritanceHelper.GetBaseMembers(@event, true)
.Any(m => m.DeclaringTypeDefinition.MetadataToken == token && m.ParentModule.PEFile == module))
{
yield return(@event);
}
}
}
IEnumerable <IEntity> AnalyzeType(IMethod analyzedEntity, ITypeDefinition type)
{
var token = analyzedEntity.MetadataToken;
var declaringTypeToken = analyzedEntity.DeclaringTypeDefinition.MetadataToken;
var module = analyzedEntity.DeclaringTypeDefinition.ParentModule.PEFile;
var allTypes = type.GetAllBaseTypeDefinitions();
if (!allTypes.Any(t => t.MetadataToken == declaringTypeToken && t.ParentModule.PEFile == module))
{
yield break;
}
foreach (var method in type.Methods)
{
var baseMembers = InheritanceHelper.GetBaseMembers(method, true);
if (baseMembers.Any(m => m.MetadataToken == token && m.ParentModule.PEFile == module))
{
yield return(method);
}
}
}
void CheckTypeCast(Expression typeCastNode, Expression expr, TextLocation castStart, TextLocation castEnd)
{
var outerTypeCastNode = typeCastNode;
while (outerTypeCastNode.Parent != null && outerTypeCastNode.Parent is ParenthesizedExpression)
{
outerTypeCastNode = (Expression)outerTypeCastNode.Parent;
}
IMember accessingMember;
var expectedType = GetExpectedType(outerTypeCastNode, out accessingMember);
var exprType = ctx.Resolve(expr).Type;
if (expectedType.Kind == TypeKind.Interface && IsExplicitImplementation(exprType, expectedType, outerTypeCastNode))
{
return;
}
var baseTypes = exprType.GetAllBaseTypes().ToList();
if (!baseTypes.Any(t => t.Equals(expectedType)))
{
return;
}
// check if the called member doesn't change it's virtual slot when changing types
if (accessingMember != null)
{
var baseMember = InheritanceHelper.GetBaseMember(accessingMember);
foreach (var bt in baseTypes)
{
foreach (var member in bt.GetMembers(m => m.Name == accessingMember.Name))
{
if (InheritanceHelper.GetBaseMember(member) != baseMember)
{
return;
}
}
}
}
AddIssue(outerTypeCastNode, typeCastNode, expr, castStart, castEnd);
}
private QuickFixResponse GetMemberResponse(ITypeResolveContext rctx, MemberResolveResult resolveResult)
{
var quickFixes = new List <QuickFix>();
//TODO: we don't need to scan all types in all projects
foreach (ITypeDefinition type in GetAllTypes(rctx))
{
if (type != null)
{
IMember member =
InheritanceHelper.GetDerivedMember(resolveResult.Member, type);
if (member != null)
{
var quickFix = QuickFix.ForFirstLineInRegion
(member.MemberDefinition.Region
, _solution.GetFile(type.Region.FileName));
quickFixes.Add(quickFix);
}
}
}
return(new QuickFixResponse(quickFixes));
}
public static IAttribute GetInheritedAttribute(IMember member, string attrName)
{
foreach (var attr in member.Attributes)
{
if (attr.AttributeType.FullName == attrName)
{
return(attr);
}
}
if (member.IsOverride)
{
member = InheritanceHelper.GetBaseMember(member);
if (member != null)
{
return(Helpers.GetInheritedAttribute(member, attrName));
}
}
return(null);
}
public static string GetMethodName(IMethod method)
{
if (!method.IsPublic)
{
return(null);
}
string name = null;
MethodDefinition methodDefinition = GetMethodDefinition(method);
if (methodDefinition != null)
{
var info = methods_.GetOrDefault(methodDefinition);
if (info != null)
{
name = info.Name;
}
}
if (name == null)
{
if (method.IsOverride)
{
IMethod baseMethod = (IMethod)InheritanceHelper.GetBaseMember(method);
name = GetMethodName(baseMethod);
}
else if (method.ImplementedInterfaceMembers.Count > 0)
{
foreach (IMethod baseMethod in method.ImplementedInterfaceMembers)
{
name = GetMethodName(baseMethod);
if (name != null)
{
break;
}
}
}
}
return(name);
}
protected override CodeAction GetAction(RefactoringContext context, MethodDeclaration node)
{
if (node == null || !node.HasModifier(Modifiers.Override))
{
return(null);
}
if (!node.NameToken.Contains(context.Location))
{
return(null);
}
IMethod resolvedMember = (IMethod)(context.Resolve(node) as MemberResolveResult).Member;
if (resolvedMember == null)
{
return(null);
}
IMethod originalMember = (IMethod)InheritanceHelper.GetBaseMember(resolvedMember);
if (originalMember == null || originalMember.Documentation == null)
{
return(null);
}
string comments = originalMember.Documentation.ToString();
if (string.IsNullOrEmpty(comments))
{
return(null);
}
string[] lines = comments.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
return(new CodeAction(context.TranslateString("Copy comments from base"), script => {
foreach (string co in lines)
{
script.InsertBefore(node, new Comment(co, CommentType.Documentation));
}
}, node.NameToken));
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
var lastParam = methodDeclaration.Parameters.LastOrDefault();
if (lastParam == null || lastParam.ParameterModifier == ParameterModifier.Params)
{
return;
}
var type = lastParam.Type as ComposedType;
if (type == null || !type.ArraySpecifiers.Any())
{
return;
}
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr == null)
{
return;
}
var baseMember = InheritanceHelper.GetBaseMember(rr.Member) as IMethod;
if (baseMember == null || baseMember.Parameters.Count == 0 || !baseMember.Parameters.Last().IsParams)
{
return;
}
AddIssue(
lastParam.NameToken,
string.Format(ctx.TranslateString("Base method '{0}' has a 'params' modifier"), baseMember.FullName),
ctx.TranslateString("Add 'params' modifier"),
script => {
script.ChangeModifier(lastParam, ParameterModifier.Params);
}
);
}
IEnumerable <IEntity> AnalyzeType(IEvent analyzedEntity, ITypeDefinition type)
{
if (!analyzedEntity.DeclaringType.GetAllBaseTypeDefinitions()
.Any(t => t.MetadataToken == analyzedEntity.DeclaringTypeDefinition.MetadataToken && t.ParentModule.PEFile == type.ParentModule.PEFile))
{
yield break;
}
foreach (var @event in type.Events)
{
if ([email protected])
{
continue;
}
if (InheritanceHelper.GetBaseMembers(@event, false)
.Any(p => p.MetadataToken == analyzedEntity.MetadataToken &&
p.ParentModule.PEFile == analyzedEntity.ParentModule.PEFile))
{
yield return(@event);
}
}
}
void CheckAutomaticToStringCallers(InvocationExpression invocationExpression, IMember member)
{
if (member.IsOverride)
{
member = InheritanceHelper.GetBaseMember(member);
if (member == null)
{
return;
}
}
var key = new Tuple <string, int>(member.ReflectionName, invocationExpression.Arguments.Count);
Tuple <int, int> checkInfo;
if (membersCallingToString.TryGetValue(key, out checkInfo))
{
var arguments = invocationExpression.Arguments.ToList();
for (int i = checkInfo.Item1; i < Math.Min(invocationExpression.Arguments.Count, checkInfo.Item2 + 1); ++i)
{
CheckExpressionInAutoCallContext(arguments[i]);
}
}
}
/// <summary>
/// Gets the attributes on the entity.
/// </summary>
/// <param name="entity">The entity on which the attributes are declared.</param>
/// <param name="inherit">
/// Specifies whether attributes inherited from base classes and base members
/// (if the given <paramref name="entity"/> in an <c>override</c>)
/// should be returned.
/// </param>
/// <returns>
/// Returns the list of attributes that were found.
/// If inherit is true, attributes from the entity itself are returned first;
/// followed by attributes inherited from the base entity.
/// </returns>
public static IEnumerable <IAttribute> GetAttributes(this IEntity entity, bool inherit)
{
if (inherit)
{
if (entity is ITypeDefinition td)
{
return(InheritanceHelper.GetAttributes(td));
}
else if (entity is IMember m)
{
return(InheritanceHelper.GetAttributes(m));
}
else
{
throw new NotSupportedException("Unknown entity type");
}
}
else
{
return(entity.GetAttributes());
}
}
public virtual bool IsTemplateOverride(IMember member)
{
if (member.IsOverride)
{
member = InheritanceHelper.GetBaseMember(member);
if (member != null)
{
var inline = this.Emitter.GetInline(member);
bool isInline = !string.IsNullOrWhiteSpace(inline);
if (isInline)
{
if (member.IsOverride)
{
return(this.IsTemplateOverride(member));
}
return(true);
}
}
}
return(false);
}
bool IsAppropriateCallTarget(IMember expectedTarget, IMember actualTarget, bool isVirtCall)
{
if (expectedTarget.Equals(actualTarget))
{
return(true);
}
if (isVirtCall && actualTarget.IsOverride)
{
foreach (var possibleTarget in InheritanceHelper.GetBaseMembers(actualTarget, false))
{
if (expectedTarget.Equals(possibleTarget))
{
return(true);
}
if (!possibleTarget.IsOverride)
{
break;
}
}
}
return(false);
}
/// <summary>
/// Gets the XML documentation element for the specified entity.
/// Returns null if no documentation is found.
/// </summary>
public static XmlDocumentationElement Get(IEntity entity, bool inheritDocIfMissing = true)
{
var documentationComment = entity.Documentation;
if (documentationComment != null)
{
return(Create(documentationComment, entity));
}
IMember member = entity as IMember;
if (inheritDocIfMissing && member != null)
{
foreach (IMember baseMember in InheritanceHelper.GetBaseMembers(member, includeImplementedInterfaces: true))
{
documentationComment = baseMember.Documentation;
if (documentationComment != null)
{
return(Create(documentationComment, baseMember));
}
}
}
return(null);
}
IList <IMember> FindImplementedInterfaceMembers()
{
if (unresolved.IsExplicitInterfaceImplementation)
{
List <IMember> result = new List <IMember>();
foreach (var memberReference in unresolved.ExplicitInterfaceImplementations)
{
IMember member = memberReference.Resolve(context);
if (member != null)
{
result.Add(member);
}
}
return(result.ToArray());
}
else if (unresolved.IsStatic || !unresolved.IsPublic || DeclaringTypeDefinition == null || DeclaringTypeDefinition.Kind == TypeKind.Interface)
{
return(EmptyList <IMember> .Instance);
}
else
{
// TODO: implement interface member mappings correctly
var result = InheritanceHelper.GetBaseMembers(this, true)
.Where(m => m.DeclaringTypeDefinition != null && m.DeclaringTypeDefinition.Kind == TypeKind.Interface)
.ToArray();
IEnumerable <IMember> otherMembers = DeclaringTypeDefinition.Members;
if (SymbolKind == SymbolKind.Accessor)
{
otherMembers = DeclaringTypeDefinition.GetAccessors(options: GetMemberOptions.IgnoreInheritedMembers);
}
result = result.Where(item => !otherMembers.Any(m => m.IsExplicitInterfaceImplementation && m.ImplementedInterfaceMembers.Contains(item))).ToArray();
return(result);
}
}
