/// <summary> /// Find all unique dependencies for a given CustomType, including field, method, nested, inherited, /// and generic types. Then assign this set of dependencies to the given CustomType. /// </summary> private void GatherDependencies(CustomType customType) { // First find all unique assembly Types that this CustomType depends on HashSet <Type> dependencySet = new HashSet <Type>(); dependencySet.UnionWith(GetFieldDependencies(customType.assemblyType)); dependencySet.UnionWith(GetMethodDependencies(customType.assemblyType)); dependencySet.UnionWith(GetNestedDependencies(customType.assemblyType)); dependencySet.UnionWith(GetInheritedDependencies(customType.assemblyType)); // Iterate through these Type dependencies, and find the corresponding valid CustomType from the lookup table HashSet <CustomType> customDependencySet = new HashSet <CustomType>(); foreach (Type t in dependencySet) { //Ignore dependency with self if (t != customType.assemblyType) { string simplifiedName = CustomType.SimplifyTypeFullName(t); //Dont add dependencies that aren't CustomTypes (e.g. those in System or Unity namespaces, as previously filtered) if (customTypeLookup.ContainsKey(simplifiedName)) { customDependencySet.Add(customTypeLookup[simplifiedName]); } } } // Assign this unique set of dependencies to the CustomType for easy access later customType.dependencies = customDependencySet; }
/// <summary> /// Determine if the matched type has any parents. If so, create the text that should be prepended /// onto the given type to match the format used in the customTypeLookup from DependencyAnalyzer. /// E.g. if B is not nested, return an empty string. If B is nested in A, return "A+". /// If C is nested in B which is nested in A, return "A+B+". /// </summary> private string FindParentTypesInText(CustomType previousType, int startLineNum, int endLineNum) { System.Text.StringBuilder typeString = new System.Text.StringBuilder(); // Handle nested types (e.g. private classes nested in other classes, potentially many nested levels) bool foundParent = false; do { // No outer type detected, i.e. match is not nested if (previousType == null) { foundParent = true; } //Check if match is nested in previous matched type else if (startLineNum >= previousType.startLineNum && endLineNum <= previousType.endLineNum) { Type parent = previousType.assemblyType; while (parent.IsNested) { typeString.Insert(0, parent.Name + "+"); parent = parent.DeclaringType; } typeString.Insert(0, parent.Name + "+"); foundParent = true; } //Not nested in previous matched type. Check if nested in that type's parent (if it exists) else { if (previousType.assemblyType.DeclaringType != null) { previousType = DependencyAnalyzer.GetCustomTypeFromString(CustomType.SimplifyTypeFullName(previousType.assemblyType.DeclaringType)); } else { previousType = null; } } } while (!foundParent); return(typeString.ToString()); }