Esempio n. 1
0
        IEnumerable <EntityNode> FindTypeUsage(TypeDef type)
        {
            if (type == null)
            {
                yield break;
            }
            if (type == analyzedType)
            {
                yield break;
            }

            if (IsUsedInTypeDef(type))
            {
                yield return new TypeNode(type)
                       {
                           Context = Context
                       }
            }
            ;

            foreach (var field in type.Fields.Where(IsUsedInFieldRef))
            {
                yield return new FieldNode(field)
                       {
                           Context = Context
                       }
            }
            ;

            foreach (var method in type.Methods)
            {
                SourceRef?sourceRef = null;

                if (IsUsedInMethodDef(method, ref sourceRef))
                {
                    yield return(HandleSpecialMethodNode(method, sourceRef));
                }
            }
        }

        EntityNode HandleSpecialMethodNode(MethodDef method, SourceRef?sourceRef)
        {
            var property = method.DeclaringType.Properties.FirstOrDefault(p => p.GetMethod == method || p.SetMethod == method);

            if (property != null)
            {
                return new PropertyNode(property)
                       {
                           Context = Context, SourceRef = sourceRef
                       }
            }
            ;

            return(new MethodNode(method)
            {
                Context = Context, SourceRef = sourceRef
            });
        }

        bool IsUsedInTypeRefs(IEnumerable <ITypeDefOrRef> types) => types.Any(IsUsedInTypeRef);

        bool IsUsedInTypeRef(ITypeDefOrRef type)
        {
            if (type == null)
            {
                return(false);
            }

            return(TypeMatches(type.DeclaringType) ||
                   TypeMatches(type));
        }

        bool IsUsedInTypeDef(TypeDef type)
        {
            if (type == null)
            {
                return(false);
            }

            return(IsUsedInTypeRef(type) ||
                   TypeMatches(type.BaseType) ||
                   IsUsedInTypeRefs(type.Interfaces.Select(ii => ii.Interface)));
        }

        bool IsUsedInFieldRef(IField field)
        {
            if (field == null || !field.IsField)
            {
                return(false);
            }

            return(TypeMatches(field.DeclaringType) ||
                   TypeMatches(field.FieldSig.GetFieldType()));
        }

        bool IsUsedInMethodRef(IMethod method)
        {
            if (method == null || !method.IsMethod)
            {
                return(false);
            }

            return(TypeMatches(method.DeclaringType) ||
                   TypeMatches(method.MethodSig.GetRetType()) ||
                   IsUsedInMethodParameters(method.GetParameters()));
        }

        bool IsUsedInMethodDef(MethodDef method, ref SourceRef?sourceRef) => IsUsedInMethodRef(method) ||
        IsUsedInMethodBody(method, ref sourceRef);

        bool IsUsedInMethodBody(MethodDef method, ref SourceRef?sourceRef)
        {
            if (method == null)
            {
                return(false);
            }
            if (method.Body == null)
            {
                return(false);
            }

            foreach (var instruction in method.Body.Instructions)
            {
                ITypeDefOrRef tr = instruction.Operand as ITypeDefOrRef;
                if (IsUsedInTypeRef(tr))
                {
                    sourceRef = new SourceRef(method, instruction.Offset, instruction.Operand as IMDTokenProvider);
                    return(true);
                }
                IField fr = instruction.Operand as IField;
                if (IsUsedInFieldRef(fr))
                {
                    sourceRef = new SourceRef(method, instruction.Offset, instruction.Operand as IMDTokenProvider);
                    return(true);
                }
                IMethod mr = instruction.Operand as IMethod;
                if (IsUsedInMethodRef(mr))
                {
                    sourceRef = new SourceRef(method, instruction.Offset, instruction.Operand as IMDTokenProvider);
                    return(true);
                }
            }

            return(false);
        }

        bool IsUsedInMethodParameters(IEnumerable <Parameter> parameters) => parameters.Any(IsUsedInMethodParameter);
        bool IsUsedInMethodParameter(Parameter parameter) => !parameter.IsHiddenThisParameter && TypeMatches(parameter.Type);
        bool TypeMatches(IType tref) => tref != null && new SigComparer().Equals(analyzedType, tref);
Esempio n. 2
0
 public DefRef(T def, SourceRef sourceRef)
 {
     this.Def       = def;
     this.SourceRef = sourceRef;
 }
Esempio n. 3
0
 public DefRef(T def, SourceRef sourceRef)
 {
     Def       = def;
     SourceRef = sourceRef;
 }