private RawUsingItem CreateUsingItem([NotNull] ItemType itemType, [NotNull] TypeReference typeReference, [NotNull] string memberName, [CanBeNull, ItemNotNull] string[] markers, [CanBeNull] ItemTail customSections, WorkingGraph readingGraph) { string namespaceName, className, assemblyName, assemblyVersion, assemblyCulture; GetTypeInfo(typeReference, out namespaceName, out className, out assemblyName, out assemblyVersion, out assemblyCulture); return(RawUsingItem.New(_rawUsingItemsCache, itemType, namespaceName, className, assemblyName, assemblyVersion, assemblyCulture, memberName, markers, customSections, readingGraph)); }
protected override IEnumerable <RawUsingItem> ReadUsingItems(int depth, WorkingGraph readingGraph) { Log.WriteInfo("Reading " + FullFileName); AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly(FullFileName); try { assembly.MainModule.ReadSymbols(); } catch (Exception ex) { Log.WriteWarning( $"Loading symbols for assembly {FullFileName} failed - maybe .PDB file is missing. ({ex.Message})", FullFileName, 0); } ItemTail customSections = GetCustomSections(readingGraph, assembly.CustomAttributes, null); foreach (TypeDefinition type in assembly.MainModule.Types) { if (type.Name == "<Module>") { continue; } foreach (var usingItem in AnalyzeType(type, customSections, readingGraph)) { yield return(usingItem); } } AssemblyNameDefinition currentAssembly = assembly.Name; yield return(RawUsingItem.New(_rawUsingItemsCache, DOTNETASSEMBLY, namespaceName: "", className: "", assemblyName: currentAssembly.Name, assemblyVersion: currentAssembly.Version.ToString(), assemblyCulture: currentAssembly.Culture, memberName: "", markers: null, tail: null, readingGraph: readingGraph)); }
private IEnumerable <RawDependency> CreateTypeAndMethodDependencies(RawUsingItem usingItem, TypeReference usedType, DotNetUsage dotNetUsage, WorkingGraph readingGraph) { return(CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(Resolve(usedType), _typeDefinitionMarkers), usedType, usage: dotNetUsage, sequencePoint: null, memberName: "", readingGraph: readingGraph)); }
private RawUsingItem GetClassItem(TypeReference typeReference, ItemTail customSections, WorkingGraph readingGraph) { string namespaceName, className, assemblyName, assemblyVersion, assemblyCulture; GetTypeInfo(typeReference, out namespaceName, out className, out assemblyName, out assemblyVersion, out assemblyCulture); return(RawUsingItem.New(_rawUsingItemsCache, DotNetAssemblyDependencyReaderFactory.DOTNETTYPE, namespaceName, className, assemblyName, assemblyVersion, assemblyCulture, memberName: "", markers: null, tail: customSections, readingGraph: readingGraph)); }
private IEnumerable <RawDependency> AnalyzeGetterSetter([NotNull] TypeDefinition owner, [NotNull] PropertyDefinition property, [NotNull] string[] markers, [CanBeNull] ItemTail propertyCustomSections, [CanBeNull] MethodDefinition getterSetter, WorkingGraph readingGraph) { if (getterSetter != null) { RawUsingItem usingItem = CreateUsingItem(DOTNETPROPERTY, property.DeclaringType, property.Name, markers, propertyCustomSections, readingGraph); // readingGraph: WHY???yield return new RawDependency(DOTNETITEM, usingItem, null, null); foreach (var dependency in AnalyzeMethod(owner, usingItem, getterSetter, readingGraph)) { yield return(dependency); } } }
public RawDependency([NotNull] RawUsingItem usingItem, [NotNull] RawUsedItem usedItem, DotNetUsage usage, [CanBeNull] SequencePoint sequencePoint, AbstractDotNetAssemblyDependencyReader readerForUsedItem) { if (usingItem == null) { throw new ArgumentNullException(nameof(usingItem)); } if (usedItem == null) { throw new ArgumentNullException(nameof(usedItem)); } UsingItem = usingItem; UsedItem = usedItem; Usage = usage; _readerForUsedItem = readerForUsedItem; _sequencePoint = sequencePoint; }
private IEnumerable <RawDependency> AnalyzeCustomAttributes([NotNull] RawUsingItem usingItem, [NotNull] IEnumerable <CustomAttribute> customAttributes, WorkingGraph readingGraph) { foreach (CustomAttribute customAttribute in customAttributes) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETITEM, null, customAttribute.Constructor.DeclaringType, usage: DotNetUsage._usesmember, sequencePoint: null, memberName: customAttribute.Constructor.Name, readingGraph: readingGraph)) { yield return(dependency_); } // See comment at Usage._usesmemberoftype on why this is commented out //foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, null, customAttribute.Constructor.DeclaringType, // usage: Usage._usesmemberoftype, sequencePoint: null, memberName: "")) { // yield return dependency_; //} } }
private IEnumerable <RawDependency> AnalyzeGenericParameter(RawUsingItem usingItem, GenericParameter genericParameter, WorkingGraph readingGraph) { foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, genericParameter, DotNetUsage._usesasgenericargument, readingGraph)) { yield return(dependency); } foreach (var constraint in genericParameter.Constraints) { foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, constraint, DotNetUsage._isconstrainedby, readingGraph)) { yield return(dependency); } } }
/// <summary> /// Create a single dependency to the calledType or (if passed) calledType+method. /// Create additional dependencies for each generic parameter type of calledType. /// </summary> private IEnumerable <RawDependency> CreateTypeAndMethodDependencies([NotNull] RawUsingItem usingItem, [NotNull] ItemType usedItemType, [CanBeNull, ItemNotNull] string[] usedMarkers, [NotNull] TypeReference usedType, DotNetUsage usage, [CanBeNull] SequencePoint sequencePoint, [NotNull] string memberName, WorkingGraph readingGraph) { if (usedType is TypeSpecification) { // E.g. the reference type System.int&, which is used for out parameters. // or an arraytype?!? usedType = ((TypeSpecification)usedType).ElementType; } if (!(usedType is GenericInstanceType) && !(usedType is GenericParameter)) { // Here, we do not look at generic type parameters; we would have to // untangle the usage of an actual (non-type-parameter) type's member // to get a useful Dependency for the user. // Generic parameters and their constraints are handled above. RawUsedItem usedItem = CreateUsedItem(usedItemType, usedType, memberName, usedMarkers, readingGraph); yield return(new RawDependency(usingItem, usedItem, usage, sequencePoint, _readingContext.ReaderGang.OfType <AbstractDotNetAssemblyDependencyReader>().FirstOrDefault(r => r.AssemblyName == usedItem.AssemblyName))); } var genericInstanceType = usedType as GenericInstanceType; if (genericInstanceType != null) { foreach (TypeReference genericArgument in genericInstanceType.GenericArguments) { foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(Resolve(genericArgument), _typeDefinitionMarkers), genericArgument, usage: DotNetUsage._usesasgenericargument, sequencePoint: sequencePoint, memberName: genericArgument.Name, readingGraph: readingGraph)) { yield return(dependency); } } } }
private IEnumerable <RawDependency> AnalyzeInstruction([NotNull] TypeDefinition owner, [NotNull] RawUsingItem usingItem, [NotNull] Instruction instruction, [CanBeNull] SequencePoint sequencePoint, [NotNull] WorkingGraph readingGraph) { { var methodReference = instruction.Operand as MethodReference; // Durch die !IsLinked-Bedingung wird der Test MainTests.Exit0Aspects mit den Calls // zwischen Nested-Klassen in NDepCheck.TestAssembly.cs - Klasse Class14.Class13EInner2, Methode SpecialMethodOfInnerClass // rot: Weil die Calls zwischen der Class14 und der Nested Class wegen IsLinked==true hier einfach ausgefiltert // werden ... // WIESO SOLL DAS SO SEIN? - bitte um Erklärung! ==> SIehe nun temporäre Änderung an IsLinked - IST DAS OK? if (methodReference != null && !IsLinked(methodReference.DeclaringType, owner)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETMETHOD, GetMemberMarkers(Resolve(methodReference.DeclaringType), _typeDefinitionMarkers), methodReference.DeclaringType, usage: DotNetUsage._usesmember, sequencePoint: sequencePoint, memberName: methodReference.Name, readingGraph: readingGraph)) { yield return(dependency_); } // See comment at Usage._usesmemberoftype on why this is commented out //foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, // GetMemberMarkers(Resolve(methodReference.ReturnType), _typeDefinitionMarkers), // methodReference.ReturnType, usage: Usage._usesmemberoftype, sequencePoint: sequencePoint, memberName: "")) { // yield return dependency_; //} } } { var field = instruction.Operand as FieldDefinition; if (field != null && !IsLinked(field.DeclaringType, owner)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETFIELD, GetMemberMarkers(field, _fieldDefinitionMarkers), field.FieldType, usage: DotNetUsage._usesmember, sequencePoint: sequencePoint, memberName: field.Name, readingGraph: readingGraph)) { yield return(dependency_); } // See comment at Usage._usesmemberoftype on why this is commented out //foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, GetMemberMarkers(field, _fieldDefinitionMarkers), // field.DeclaringType, usage: Usage._usesmemberoftype, sequencePoint: sequencePoint, memberName: "")) { // yield return dependency_; //} } } { var property = instruction.Operand as PropertyDefinition; if (property != null && !IsLinked(property.DeclaringType, owner)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETPROPERTY, GetMemberMarkers(property, _propertyDefinitionMarkers), property.PropertyType, usage: DotNetUsage._usesmember, sequencePoint: sequencePoint, memberName: property.Name, readingGraph: readingGraph)) { yield return(dependency_); } // See comment at Usage._usesmemberoftype on why this is commented out //foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, GetMemberMarkers(property, _propertyDefinitionMarkers), // property.DeclaringType, usage: Usage._usesmemberoftype, sequencePoint: sequencePoint, memberName: "")) { // yield return dependency_; //} } } { var typeref = instruction.Operand as TypeReference; if (typeref != null && !IsLinked(typeref, owner)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(Resolve(typeref), _typeDefinitionMarkers), typeref, usage: DotNetUsage._usestype, sequencePoint: sequencePoint, memberName: "", readingGraph: readingGraph)) { yield return(dependency_); } } } }
private IEnumerable <RawDependency> AnalyzeMethod([NotNull] TypeDefinition owner, [NotNull] RawUsingItem usingItem, [NotNull] MethodDefinition method, WorkingGraph readingGraph) { foreach (var dependency_ in AnalyzeCustomAttributes(usingItem, method.CustomAttributes, readingGraph)) { yield return(dependency_); } foreach (ParameterDefinition parameter in method.Parameters) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETPARAMETER, GetParameterMarkers(parameter, _parameterDefinitionMarkers), parameter.ParameterType, usage: DotNetUsage._declaresparameter, sequencePoint: null, memberName: parameter.Name, readingGraph: readingGraph)) { yield return(dependency_); } } if (method.ReturnType != null && !IsLinked(method.ReturnType, method.DeclaringType.DeclaringType)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(Resolve(method.ReturnType), _typeDefinitionMarkers), method.ReturnType, usage: DotNetUsage._declaresreturntype, sequencePoint: null, memberName: "", readingGraph: readingGraph)) { yield return(dependency_); } } if (method.HasBody) { foreach (var variable in method.Body.Variables) { if (!IsLinked(variable.VariableType, method.DeclaringType.DeclaringType)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETVARIABLE, GetVariableMarkers(variable, _variableDefinitionMarkers), variable.VariableType, usage: DotNetUsage._declaresvariable, sequencePoint: null, memberName: variable.Name, readingGraph: readingGraph)) { yield return(dependency_); } } } SequencePoint mostRecentSeqPoint = null; foreach (Instruction instruction in method.Body.Instructions) { if (instruction.SequencePoint != null) { mostRecentSeqPoint = instruction.SequencePoint; } foreach (var dependency_ in AnalyzeInstruction(owner, usingItem, instruction, mostRecentSeqPoint, readingGraph)) { yield return(dependency_); } } } }
private IEnumerable <RawDependency> AnalyzeProperty([NotNull] TypeDefinition owner, [NotNull] RawUsingItem usingItem, [NotNull] PropertyDefinition property, [CanBeNull] ItemTail typeCustomSections, WorkingGraph readingGraph) { ItemTail propertyCustomSections = GetCustomSections(readingGraph, property.CustomAttributes, typeCustomSections); foreach (var dependency_ in AnalyzeCustomAttributes(usingItem, property.CustomAttributes, readingGraph)) { yield return(dependency_); } foreach (ParameterDefinition parameter in property.Parameters) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETPARAMETER, GetParameterMarkers(parameter, _parameterDefinitionMarkers), parameter.ParameterType, usage: DotNetUsage._declaresparameter, sequencePoint: null, memberName: parameter.Name, readingGraph: readingGraph)) { yield return(dependency_); } } if (property.PropertyType != null) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(property, _propertyDefinitionMarkers), property.PropertyType, usage: DotNetUsage._declaresreturntype, sequencePoint: null, memberName: property.Name, readingGraph: readingGraph)) { yield return(dependency_); } } foreach (var dependency in AnalyzeGetterSetter(owner, property, GET_MARKER, propertyCustomSections, property.GetMethod, readingGraph)) { yield return(dependency); } foreach (var dependency in AnalyzeGetterSetter(owner, property, SET_MARKER, propertyCustomSections, property.SetMethod, readingGraph)) { yield return(dependency); } }
private IEnumerable <RawDependency> AnalyzeType([NotNull] TypeDefinition type, [CanBeNull] ItemTail parentCustomSections, WorkingGraph readingGraph) { ItemTail typeCustomSections = GetCustomSections(readingGraph, type.CustomAttributes, parentCustomSections); { RawUsingItem usingItem = CreateUsingItem(DOTNETTYPE, type, typeCustomSections, GetMemberMarkers(type, _typeDefinitionMarkers), readingGraph); // readingGraph: WHY???yield return new RawDependency(DOTNETITEM, usingItem, null, null); foreach (var dependency_ in AnalyzeCustomAttributes(usingItem, type.CustomAttributes, readingGraph)) { yield return(dependency_); } if (type.BaseType != null && !IsLinked(type.BaseType, type.DeclaringType)) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(type, _typeDefinitionMarkers), type.BaseType, usage: DotNetUsage._directlyderivedfrom, sequencePoint: null, memberName: "", readingGraph: readingGraph)) { yield return(dependency_); } } foreach (TypeReference interfaceRef in type.Interfaces) { foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE, GetMemberMarkers(Resolve(interfaceRef), _typeDefinitionMarkers), interfaceRef, usage: DotNetUsage._directlyimplements, sequencePoint: null, memberName: "", readingGraph: readingGraph)) { yield return(dependency_); } } foreach (FieldDefinition field in type.Fields) { //if (IsLinked(field.FieldType, type.DeclaringType)) { ItemTail fieldCustomSections = GetCustomSections(readingGraph, field.CustomAttributes, typeCustomSections); // readingGraph: WHY??? yield return new RawDependency(DOTNETITEM, GetFullnameItem(type, field.Name, "", fieldCustomSections), null, null); foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETFIELD, GetMemberMarkers(field, _fieldDefinitionMarkers), field.FieldType, usage: DotNetUsage._declaresfield, sequencePoint: null, memberName: field.Name, readingGraph: readingGraph)) { yield return(dependency_); } //} } foreach (EventDefinition @event in type.Events) { ItemTail eventCustomSections = GetCustomSections(readingGraph, @event.CustomAttributes, typeCustomSections); // readingGraph: WHY??? yield return new RawDependency(DOTNETITEM, GetFullnameItem(type, @event.Name, "", eventCustomSections), null, null); foreach (var dependency_ in CreateTypeAndMethodDependencies(usingItem, DOTNETEVENT, GetMemberMarkers(@event, _eventDefinitionMarkers), @event.EventType, usage: DotNetUsage._declaresevent, sequencePoint: null, memberName: @event.Name, readingGraph: readingGraph)) { yield return(dependency_); } } foreach (var property in type.Properties) { //if (!IsLinked(property.PropertyType, type.DeclaringType)) { foreach (var dependency_ in AnalyzeProperty(type, usingItem, property, typeCustomSections, readingGraph)) { yield return(dependency_); } //} } } foreach (MethodDefinition method in type.Methods) { ItemTail methodCustomSections = GetCustomSections(readingGraph, method.CustomAttributes, typeCustomSections); RawUsingItem usingItem = CreateUsingItem(DOTNETMETHOD, type, method.Name, GetMemberMarkers(method, _methodDefinitionMarkers), methodCustomSections, readingGraph); // readingGraph: WHY???yield return new RawDependency(DOTNETITEM, usingItem, null, null); foreach (var dependency_ in AnalyzeMethod(type, usingItem, method, readingGraph)) { yield return(dependency_); } } foreach (TypeDefinition nestedType in type.NestedTypes) { foreach (var dependency_ in AnalyzeType(nestedType, typeCustomSections, readingGraph)) { yield return(dependency_); } } }
private IEnumerable <RawDependency> AnalyzeType([NotNull] TypeDefinition type, [CanBeNull] ItemTail parentCustomSections, WorkingGraph readingGraph) { ItemTail typeCustomSections = GetCustomSections(readingGraph, type.CustomAttributes, parentCustomSections); RawUsingItem usingItem = CreateUsingItem(DOTNETTYPE, type, typeCustomSections, GetMemberMarkers(type, _typeDefinitionMarkers), readingGraph); // readingGraph: WHY???yield return new RawDependency(DOTNETITEM, usingItem, null, null); foreach (var dependency in AnalyzeCustomAttributes(usingItem, type.CustomAttributes, readingGraph)) { yield return(dependency); } foreach (var genericParameter in type.GenericParameters) { RawUsedItem usedItem = CreateUsedItem(DOTNETGENERICPARAMETER, genericParameter, genericParameter.Name, NO_MARKERS, readingGraph); yield return(new RawDependency(usingItem, usedItem, DotNetUsage._usesasgenericargument, sequencePoint: null, readerForUsedItem: _readingContext.ReaderGang.OfType <AbstractDotNetAssemblyDependencyReader>() .FirstOrDefault(r => r.AssemblyName == usedItem.AssemblyName))); RawUsingItem usingParameter = CreateUsingItem(DOTNETGENERICPARAMETER, genericParameter, genericParameter.Name, NO_MARKERS, customSections: null, readingGraph: readingGraph); foreach (var rawDependency in AnalyzeGenericParameter(usingParameter, genericParameter, readingGraph)) { yield return(rawDependency); } } if (type.BaseType != null && !IsLinked(type.BaseType, type.DeclaringType)) { foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, type.BaseType, DotNetUsage._directlyderivedfrom, readingGraph)) { yield return(dependency); } } foreach (TypeReference interfaceRef in type.Interfaces) { foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, interfaceRef, DotNetUsage._directlyimplements, readingGraph)) { yield return(dependency); } } foreach (FieldDefinition field in type.Fields) { //if (IsLinked(field.FieldType, type.DeclaringType)) { ItemTail fieldCustomSections = GetCustomSections(readingGraph, field.CustomAttributes, typeCustomSections); // readingGraph: WHY??? yield return new RawDependency(DOTNETITEM, GetFullnameItem(type, field.Name, "", fieldCustomSections), null, null); foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, DOTNETFIELD, GetMemberMarkers(field, _fieldDefinitionMarkers), field.FieldType, usage: DotNetUsage._declaresfield, sequencePoint: null, memberName: field.Name, readingGraph: readingGraph)) { yield return(dependency); } //} } foreach (EventDefinition @event in type.Events) { ItemTail eventCustomSections = GetCustomSections(readingGraph, @event.CustomAttributes, typeCustomSections); // readingGraph: WHY??? yield return new RawDependency(DOTNETITEM, GetFullnameItem(type, @event.Name, "", eventCustomSections), null, null); foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, DOTNETEVENT, GetMemberMarkers(@event, _eventDefinitionMarkers), @event.EventType, usage: DotNetUsage._declaresevent, sequencePoint: null, memberName: @event.Name, readingGraph: readingGraph)) { yield return(dependency); } } foreach (var property in type.Properties) { //if (!IsLinked(property.PropertyType, type.DeclaringType)) { foreach (var dependency in AnalyzeProperty(type, usingItem, property, typeCustomSections, readingGraph)) { yield return(dependency); } //} } foreach (MethodDefinition method in type.Methods) { ItemTail methodCustomSections = GetCustomSections(readingGraph, method.CustomAttributes, typeCustomSections); RawUsedItem usedItem = CreateUsedItem(DOTNETMETHOD, type, method.Name, GetMemberMarkers(method, _methodDefinitionMarkers), readingGraph); yield return (new RawDependency(usingItem, usedItem, DotNetUsage._declaresmethod, sequencePoint: null, readerForUsedItem: _readingContext.ReaderGang.OfType <AbstractDotNetAssemblyDependencyReader>() .FirstOrDefault(r => r.AssemblyName == usedItem.AssemblyName))); RawUsingItem usingMethod = CreateUsingItem(DOTNETMETHOD, type, method.Name, GetMemberMarkers(method, _methodDefinitionMarkers), methodCustomSections, readingGraph); // readingGraph: WHY???yield return new RawDependency(DOTNETITEM, usingItem, null, null); foreach (var dependency in AnalyzeMethod(type, usingMethod, method, readingGraph)) { yield return(dependency); } } foreach (TypeDefinition nestedType in type.NestedTypes) { foreach (var dependency in AnalyzeType(nestedType, typeCustomSections, readingGraph)) { yield return(dependency); } } }