public void ScanAssembly(IAssembly assembly) { foreach (var type in assembly.GetAllTypes()) { ScanType(type); } }
public override void TraverseChildren(IAssembly assembly) { foreach (var t in assembly.GetAllTypes()) { this.Traverse(t); } }
public override void Visit(IAssembly assembly) { AppendElementType(assembly); output.Append(assembly.Name.Value); Visit(assembly.GetAllTypes()); System.Console.WriteLine(output); }
static internal AssemblyReport CreateAssemblyReportFromRTA(IAssembly assembly, RapidTypeAnalysis rta) { AssemblyReport report = new AssemblyReport(assembly); int totalTypes = 0; int totalFields = 0; int totalMethods = 0; foreach (var t in assembly.GetAllTypes()) { totalTypes++; if (rta.ReachableTypes().Contains(t) == false) { report.UnreachableTypes.Add(t); //Console.WriteLine("Unused type {0}", t); } else { report.ReachableTypes.Add(t); } if (t.IsClass || t.IsStruct) { foreach (var f in t.Fields) { totalFields++; if (rta.ReachableFields().Contains(f) == false) { report.UnreachableFields.Add(f); //Console.WriteLine("Unused field {0}", f); } else { report.ReachableFields.Add(f); } } foreach (var m in t.Methods) { if (!m.IsAbstract) { totalMethods++; if (rta.MethodIsReachable(m) == false) { report.UnreachableMethods.Add(m); //Console.WriteLine("Unreachable method {0}", m); } else { report.ReachableMethods.Add(m); } } } } } return(report); }
public static bool IsFacade(this IAssembly assembly) { if (assembly.GetAllTypes().Any(t => t.Name.Value != "<Module>")) { return(false); } return(true); }
public static INamedTypeDefinition GetTypeDefinition(this IAssembly assembly, Type type) { return(( from t in assembly.GetAllTypes() let name = TypeHelper.GetTypeName(t, NameFormattingOptions.UseGenericTypeNameSuffix) where name == type.FullName select t ).First()); }
public static bool IsFacade(this IAssembly assembly) { if (assembly.GetAllTypes().Any(t => t.Name.Value != "<Module>")) { return(false); } Contract.Assert(assembly.ExportedTypes.Any()); return(true); }
private IEnumerable <IMethodDefinition> GetAllMethodsInAssembly(IAssembly assembly) { foreach (ITypeDefinition typeDefinition in assembly.GetAllTypes()) { foreach (IMethodDefinition method in typeDefinition.Methods) { yield return(method); } } }
private IEnumerable <IFieldDefinition> GetAllFieldsInAssembly(IAssembly assembly) { foreach (ITypeDefinition typeDefinition in assembly.GetAllTypes()) { foreach (IFieldDefinition field in typeDefinition.Fields) { yield return(field); } } }
private static IEnumerable <string> GetPublicVisibleTypes(IAssembly contractAssembly) { var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType) .OfType <INamespaceTypeReference>(); var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t)) .OfType <INamespaceTypeDefinition>(); return(typeForwardsToForward.Concat(typesToForward) .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.UseGenericTypeNameSuffix)).ToList()); }
/// <summary> /// This is "ugly" but I don't know how to query a type by name /// Inspired in Zvonimir code /// </summary> /// <param name="host"></param> public static void InitializeScopeTypes(IMetadataHost host, IAssembly scopeRuntime) { foreach (var type in scopeRuntime.GetAllTypes()) { if (type.GetFullName() == "ScopeRuntime.Reducer") { Reducer = type; } else if (type.GetFullName() == "ScopeRuntime.Processor") { Processor = type; } else if (type.GetFullName() == "ScopeRuntime.Producer") { Producer = type; } else if (type.GetFullName() == "ScopeRuntime.Row") { Row = type; } else if (type.GetFullName() == "ScopeRuntime.RowSet") { RowSet = type; } else if (type.GetFullName() == "ScopeRuntime.RowList") { RowList = type; } else if (type.GetFullName() == "ScopeRuntime.ColumnData") { ColumnData = type; } else if (type.GetFullName() == "ScopeRuntime.ColumnData<T>") { ColumnData_Generic = type; } else if (type.GetFullName() == "ScopeRuntime.Schema") { Schema = type; } else if (type.GetFullName() == "ScopeRuntime.Combiner") { Combiner = type; } else if (type.GetFullName() == "ScopeRuntime.ScopeMap<K, V>") { ScopeMap = type; } if (type.ContainingNamespace() == "ScopeRuntime") { scopeTypes.Add(type); } } }
public static bool IsFacade(this IAssembly assembly) { if (assembly.GetAllTypes().Any(t => t.Name.Value != "<Module>")) { return(false); } // Don't assert here -- turns out empty assemblies are a thing. // Contract.Assert(assembly.ExportedTypes.Any()); return(assembly.ExportedTypes.Any()); }
public TypeVerifier Type(string typeName, int genericParamsCount, Action <ITypeDefinition> typeVerifier) { var types = assembly.GetAllTypes().Where(t => t.Name.Value == typeName); var targetType = types.FirstOrDefault(t => t.GenericParameterCount == genericParamsCount); if (targetType == null) { throw new ArgumentException(string.Format("Type {0} not found", typeName)); } typeVerifier(targetType); return(new TypeVerifier(this, targetType, env)); }
public AssemblyBuilder Load(IAssembly assembly) { //first create (but do not initialize) all typeBuilder builders, since they are needed to create member builders. this.typeBuilderAllocator.Traverse(assembly); //next create (but do not initialize) builder for all other kinds of typeBuilder members, since there may be forward references during initialization this.memberBuilderAllocator.Traverse(assembly); //now initialize all the builders this.initializingTraverser.TraverseChildren(assembly); //create all of the types this.typeCreator.Traverse(assembly.GetAllTypes()); //set entry point on assembly if defined if (!(assembly.EntryPoint is Dummy)) this.AssemblyBuilder.SetEntryPoint((MethodInfo)this.mapper.GetMethod(assembly.EntryPoint)); //now the assembly is ready for action return this.AssemblyBuilder; }
void CheckSurface(IAssembly contractAssembly, IAssembly originalAssembly) { Contract.Requires(contractAssembly != null); // Check each type in contract Assembly foreach (var type in contractAssembly.GetAllTypes()) { if (type is INestedTypeDefinition) { continue; // visited during parent type } CheckSurface(type, originalAssembly); } }
public ISet <IDefinition> FindDefinitionsMatchingRegularExpressionInAssembly(Regex regex, IAssembly assembly) { // Maybe figure out how to factor out commons parts of this with FindDefinitionWithIdentifierInAssembly? ISet <IDefinition> results = new HashSet <IDefinition>(new DefinitionEqualityComparer()); string regexPattern = regex.ToString(); // We could be more efficient here, but for now we go with simplicity if (regexPattern.StartsWith("M:")) { foreach (IMethodDefinition method in GetAllMethodsInAssembly(assembly)) { if (regex.IsMatch(GarbageCollectHelper.GetIDStringForReference(method))) { results.Add(method); } } } else if (regexPattern.StartsWith("T:")) { foreach (ITypeDefinition type in assembly.GetAllTypes()) { if (regex.IsMatch(GarbageCollectHelper.GetIDStringForReference(type))) { results.Add(type); } } } else if (regexPattern.StartsWith("F:")) { foreach (IFieldDefinition field in GetAllFieldsInAssembly(assembly)) { if (regex.IsMatch(GarbageCollectHelper.GetIDStringForReference(field))) { results.Add(field); } } } else { throw new Exception("Un recognized doc comment definition identifier prefix in: " + regexPattern + " (expected T:, M:, or F:)"); } return(results); }
private ICustomAttribute CreateAttribute(string typeName, IAssembly seedCoreAssembly, string argument = null) { var type = seedCoreAssembly.GetAllTypes().FirstOrDefault(t => t.FullName() == typeName); if (type == null) { throw new FacadeGenerationException(String.Format("Cannot find {0} type in seed core assembly.", typeName)); } IEnumerable <IMethodDefinition> constructors = type.GetMembersNamed(_seedHost.NameTable.Ctor, false).OfType <IMethodDefinition>(); IMethodDefinition constructor = null; if (argument != null) { constructor = constructors.SingleOrDefault(m => m.ParameterCount == 1 && m.Parameters.First().Type.AreEquivalent("System.String")); } else { constructor = constructors.SingleOrDefault(m => m.ParameterCount == 0); } if (constructor == null) { throw new FacadeGenerationException(String.Format("Cannot find {0} constructor taking single string argument in seed core assembly.", typeName)); } var attribute = new CustomAttribute(); attribute.Constructor = constructor; if (argument != null) { var argumentExpression = new MetadataConstant(); argumentExpression.Type = _seedHost.PlatformType.SystemString; argumentExpression.Value = argument; attribute.Arguments = new List <IMetadataExpression>(1); attribute.Arguments.Add(argumentExpression); } return(attribute); }
private static IEnumerable <string> EnumerateDocIdsToForward(IAssembly contractAssembly) { // Use INamedTypeReference instead of INamespaceTypeReference in order to also include nested // class type-forwards. var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType) .OfType <INamedTypeReference>(); var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t)) .OfType <INamespaceTypeDefinition>(); List <string> result = typeForwardsToForward.Concat(typesToForward) .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList(); foreach (var type in typesToForward) { AddNestedTypeDocIds(result, type); } return(result); }
private static IEnumerable <string> EnumerateDocIdsToForward(IAssembly contractAssembly) { // Make note that all type forwards (including nested) implement INamespaceAliasForType, so do // not be tempted to filter using it, instead, we look at the aliased type to them. var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType) .OfType <INamespaceTypeReference>(); var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t)) .OfType <INamespaceTypeDefinition>(); List <string> result = typeForwardsToForward.Concat(typesToForward) .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList(); foreach (var type in typesToForward) { AddNestedTypeDocIds(result, type); } return(result); }
public IDefinition FindDefinitionWithIdentifierInAssembly(string docCommentIdentifier, IAssembly assembly) { // We could be more efficient here, but for now we go with simplicity if (docCommentIdentifier.StartsWith("M:")) { foreach (IMethodDefinition method in GetAllMethodsInAssembly(assembly)) { if (GarbageCollectHelper.GetIDStringForReference(method) == docCommentIdentifier) { return(method); } } } else if (docCommentIdentifier.StartsWith("T:")) { foreach (ITypeDefinition type in assembly.GetAllTypes()) { if (GarbageCollectHelper.GetIDStringForReference(type) == docCommentIdentifier) { return(type); } } } else if (docCommentIdentifier.StartsWith("F:")) { foreach (IFieldDefinition field in GetAllFieldsInAssembly(assembly)) { if (GarbageCollectHelper.GetIDStringForReference(field) == docCommentIdentifier) { return(field); } } } else { throw new Exception("Un recognized doc comment definition identifier prefix in: " + docCommentIdentifier + " (expected T:, M:, or F:)"); } return(null); }
public void DoStuff() { var host = new PeReader.DefaultHost(); foreach (string file in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.exe")) { Console.WriteLine(file); IAssembly assembly = host.LoadUnitFrom(file) as IAssembly; if (assembly != null) { foreach (INamedTypeDefinition type in assembly.GetAllTypes()) { foreach (IMethodDefinition method in type.Methods) { Console.WriteLine(String.Format("{0}::{1}", type.Name, method.Name)); } } } } }
public override void TraverseChildren(IAssembly assembly) { foreach (var t in assembly.GetAllTypes()) this.Traverse(t); }
private static IEnumerable<INamedTypeDefinition> getTypesNotGenerated(IAssembly assembly) { return from t in assembly.GetAllTypes() where !HasAnyGeneratedCodeAttributes(t) select t; }
void CheckSurface(IAssembly contractAssembly, IAssembly originalAssembly) { Contract.Requires(contractAssembly != null); // Check each type in contract Assembly foreach (var type in contractAssembly.GetAllTypes()) { if (type is INestedTypeDefinition) continue; // visited during parent type CheckSurface(type, originalAssembly); } }
private ICustomAttribute CreateAttribute(string typeName, IAssembly seedCoreAssembly, string argument = null) { var type = seedCoreAssembly.GetAllTypes().FirstOrDefault(t => t.FullName() == typeName); if (type == null) { throw new FacadeGenerationException(String.Format("Cannot find {0} type in seed core assembly.", typeName)); } IEnumerable<IMethodDefinition> constructors = type.GetMembersNamed(_seedHost.NameTable.Ctor, false).OfType<IMethodDefinition>(); IMethodDefinition constructor = null; if (argument != null) { constructor = constructors.SingleOrDefault(m => m.ParameterCount == 1 && m.Parameters.First().Type.AreEquivalent("System.String")); } else { constructor = constructors.SingleOrDefault(m => m.ParameterCount == 0); } if (constructor == null) { throw new FacadeGenerationException(String.Format("Cannot find {0} constructor taking single string argument in seed core assembly.", typeName)); } var attribute = new CustomAttribute(); attribute.Constructor = constructor; if (argument != null) { var argumentExpression = new MetadataConstant(); argumentExpression.Type = _seedHost.PlatformType.SystemString; argumentExpression.Value = argument; attribute.Arguments = new List<IMetadataExpression>(1); attribute.Arguments.Add(argumentExpression); } return attribute; }
private static IEnumerable<string> EnumerateDocIdsToForward(IAssembly contractAssembly) { // Make note that all type forwards (including nested) implement INamespaceAliasForType, so do // not be tempted to filter using it, instead, we look at the aliased type to them. var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType) .OfType<INamespaceTypeReference>(); var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t)) .OfType<INamespaceTypeDefinition>(); List<string> result = typeForwardsToForward.Concat(typesToForward) .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList(); foreach(var type in typesToForward) { AddNestedTypeDocIds(result, type); } return result; }
private static IEnumerable<string> EnumerateDocIdsToForward(IAssembly contractAssembly) { // Use INamedTypeReference instead of INamespaceTypeReference in order to also include nested // class type-forwards. var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType) .OfType<INamedTypeReference>(); var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t)) .OfType<INamespaceTypeDefinition>(); List<string> result = typeForwardsToForward.Concat(typesToForward) .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList(); foreach(var type in typesToForward) { AddNestedTypeDocIds(result, type); } return result; }
private IEnumerable <TypeMetricsWithMethodMetrics> AnalyzeTypes(IAssembly assembly, PdbReader pdb, IMetadataHost host) { return(from type in assembly.GetAllTypes() where type.Name.ToString() != "<Module>" select TypeAndMethods(pdb, host, type)); }
private IEnumerable<TypeMetricsWithMethodMetrics> AnalyzeTypes(IAssembly assembly, PdbReader pdb, IMetadataHost host) { return from type in assembly.GetAllTypes() where type.Name.ToString() != "<Module>" select TypeAndMethods(pdb, host, type); }