internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host) {
   Contract.Requires(containingType != null);
   Contract.Requires(host != null);
   this.containingType = containingType;
   this.host = host;
   this.platformType = containingType.PlatformType;
 }

 public FieldAssignmentReplacementBuilder(FieldReference field, IMetadataHost host, ExpressionStatement assignment, ReplacementRegistry registry)
 {
     this.field = field;
     this.host = host;
     this.assignment = assignment;
     this.registry = registry;
 }

 /// <summary>
 /// For an iterator method, find the closure class' MoveNext method and return its body.
 /// </summary>
 /// <param name="host"></param>
 /// <param name="possibleIterator">The (potential) iterator method.</param>
 /// <returns>Dummy.MethodBody if <paramref name="possibleIterator"/> does not fit into the code pattern of an iterator method, 
 /// or the body of the MoveNext method of the corresponding closure class if it does.
 /// </returns>
 public static IMethodBody/*?*/ FindClosureMoveNext(IMetadataHost host, ISourceMethodBody/*!*/ possibleIterator) {
   if (possibleIterator is Dummy) return null;
   var nameTable = host.NameTable;
   var possibleIteratorBody = possibleIterator.Block;
   foreach (var statement in possibleIteratorBody.Statements) {
     var expressionStatement = statement as IExpressionStatement;
     if (expressionStatement != null)
       return FirstStatementIsIteratorCreation(host, possibleIterator, nameTable, statement);
     break;
   }
   foreach (var statement in possibleIteratorBody.Statements){
     //var lds = statement as ILocalDeclarationStatement;
     //if (lds != null) {
     //  if (lds.InitialValue != null)
     //    return null;
     //  else
     //    continue;
     //}
     var returnStatement = statement as IReturnStatement;
     if (returnStatement == null) return null;
     var blockExpression = returnStatement.Expression as IBlockExpression;
     if (blockExpression == null) return null;
     foreach (var s in blockExpression.BlockStatement.Statements) {
       return FirstStatementIsIteratorCreation(host, possibleIterator, nameTable, s);
     }
   }
   return null;
 }

 internal AnonymousDelegateCachingRemover(IMetadataHost host, Hashtable<IAnonymousDelegate>/*?*/ delegatesCachedInFields,
   Hashtable<LocalDefinition, AnonymousDelegate>/*?*/ delegatesCachedInLocals)
   : base(host) {
   Contract.Requires(host != null);
   this.delegatesCachedInFields = delegatesCachedInFields;
   this.delegatesCachedInLocals = delegatesCachedInLocals;
 }

 private static IMethodBody/*?*/ FirstStatementIsIteratorCreation(IMetadataHost host, ISourceMethodBody possibleIterator, INameTable nameTable, IStatement statement) {
   ICreateObjectInstance createObjectInstance = GetICreateObjectInstance(statement);
   if (createObjectInstance == null) {
     // If the first statement in the method body is not the creation of iterator closure, return a dummy.
     // Possible corner case not handled: a local is used to hold the constant value for the initial state of the closure.
     return null;
   }
   ITypeReference closureType/*?*/ = createObjectInstance.MethodToCall.ContainingType;
   ITypeReference unspecializedClosureType = ContractHelper.Unspecialized(closureType);
   if (!AttributeHelper.Contains(unspecializedClosureType.Attributes, host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
     return null;
   INestedTypeReference closureTypeAsNestedTypeReference = unspecializedClosureType as INestedTypeReference;
   if (closureTypeAsNestedTypeReference == null) return null;
   ITypeReference unspecializedClosureContainingType = ContractHelper.Unspecialized(closureTypeAsNestedTypeReference.ContainingType);
   if (closureType != null && TypeHelper.TypesAreEquivalent(possibleIterator.MethodDefinition.ContainingTypeDefinition, unspecializedClosureContainingType)) {
     IName MoveNextName = nameTable.GetNameFor("MoveNext");
     foreach (ITypeDefinitionMember member in closureType.ResolvedType.GetMembersNamed(MoveNextName, false)) {
       IMethodDefinition moveNext = member as IMethodDefinition;
       if (moveNext != null) {
         ISpecializedMethodDefinition moveNextGeneric = moveNext as ISpecializedMethodDefinition;
         if (moveNextGeneric != null)
           moveNext = moveNextGeneric.UnspecializedVersion.ResolvedMethod;
         return moveNext.Body;
       }
     }
   }
   return null;
 }

 private static int CalculateCyclomaticComplexity(this IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     var methodBody = method.Decompile(pdb, host);
     var cyclomaticComplexityCalculator = new CyclomaticComplexityCalculator();
     cyclomaticComplexityCalculator.Traverse(methodBody.Statements());
     return cyclomaticComplexityCalculator.Result;
 }

 private static void AnalyzeFileInHost(string toAnalyse, IMetadataHost host)
 {
     AnalyzeFileWithPdb(toAnalyse, host, (pdb) =>
     {
         AnalyzeAssembly(host.LoadUnitFrom(toAnalyse) as IAssembly, pdb);
     });
 }

 private void AnalyzeAssemblyInHost(IMetadataHost host, IAssembly assembly, string pdbPath)
 {
     if (pdbPath != null)
         AnalyzeAssemblyInHostWithProgramDatabase(assembly, host, pdbPath);
     else
         AnalyzeTypes(assembly, null, host, Report);
 }

 public SpecifiedMethodCallRegistrar(IMetadataHost host, ILogger log, ReplacementRegistry registry)
 {
     this.host = host;
     this.log = log;
     this.registry = registry;
     reflector = new UnitReflector(host);
 }

 private TypeMetricsWithMethodMetrics TypeAndMethods(PdbReader pdb, IMetadataHost host, INamedTypeDefinition type)
 {
     var typeAndMethods = new TypeMetricsWithMethodMetrics();
     typeAndMethods.AddMethodReports(AnalyzeMethods(type, pdb, host));
     typeAndMethods.Type = AnalyzeType(type, pdb, typeAndMethods.Methods);
     return typeAndMethods;
 }

 public static SourceMethodBody Decompile(this IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     return new SourceMethodBody(method.Body, host, pdb, pdb,
                DecompilerOptions.Loops |
                DecompilerOptions.AnonymousDelegates |
                DecompilerOptions.Iterators);
 }

    internal static void Reachable(
      IMetadataHost host,
      ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
      HashSet<object> thingsToKeep,
      HashSet<uint> methodsWhoseBodiesShouldBeKept,
      out Dictionary<IMethodDefinition, uint> contractOffsets
      ) {

      Contract.Requires(host != null);
      Contract.Requires(slice != null);
      Contract.Requires(thingsToKeep != null);
      Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

      var traverser = new MetadataTraverser();
      var me = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);
      traverser.TraverseIntoMethodBodies = true;
      traverser.PreorderVisitor = me;

      var methodsToTraverse = slice.Methods;
      foreach (var m in methodsToTraverse) {
        var methodDefinition = m.reference.ResolvedMethod;
        traverser.Traverse(methodDefinition);
      }

      foreach (var c in slice.Chains) {
        VisitChain(c, traverser);
      }
      contractOffsets = me.contractOffsets;
      return;
    }

        public static IModule RewriteModule(IMetadataHost host, ILocalScopeProvider localScopeProvider, ISourceLocationProvider sourceLocationProvider, IModule module)
        {
            var m = new PropertyChangedWeaver(host);
            m._rewriter = new ReferenceReplacementRewriter(host, localScopeProvider, sourceLocationProvider);

            return m.Rewrite(module);
        }

 public static int Of(IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     if (method.HasOperations())
         return method.CalculateStatements(pdb, host);
     else
         return 0;
 }

        public SharpMockTypes(IMetadataHost host)
        {
            var funcs = new Dictionary<int, INamedTypeReference>();
            var acts = new Dictionary<int, INamedTypeReference>();

            var sharpMockTypes =
                host.LoadUnitFrom(
                    System.Reflection.Assembly.GetExecutingAssembly().Location);
            var sharpMockDelegateTypes = sharpMockTypes as IAssembly;
            Unit = sharpMockTypes;

            foreach (var type in sharpMockDelegateTypes.GetAllTypes())
            {
                if (type.Name.Value == "VoidAction")
                {
                    acts.Add(type.GenericParameterCount, type);
                }

                if (type.Name.Value == "Function")
                {
                    funcs.Add(type.GenericParameterCount - 1, type);
                }
            }

            functions = new GenericMethodTypeDictionary(funcs, "Unable to find type Function<> with {0} input parameter arguments.");
            actions = new GenericMethodTypeDictionary(acts, "Unable to find type VoidAction<> with {0} parameter arguments.");
        }

 /// <summary>
 /// Allocates a reference to a .NET assembly.
 /// </summary>
 /// <param name="host">Provides a standard abstraction over the applications that host components that provide or consume objects from the metadata model.</param>
 /// <param name="assemblyIdentity">The identity of the referenced assembly.</param>
 /// <param name="isRetargetable">True if the implementation of the referenced assembly used at runtime is not expected to match the version seen at compile time.</param>
 /// <param name="containsForeignTypes">
 /// True if the referenced assembly contains types that describe objects that are neither COM objects nor objects that are managed by the CLR.
 /// Instances of such types are created and managed by another runtime and are accessed by CLR objects via some form of interoperation mechanism.
 /// </param>
 public AssemblyReference(IMetadataHost host, AssemblyIdentity assemblyIdentity, bool isRetargetable = false, bool containsForeignTypes = false)
 {
     this.host = host;
       this.assemblyIdentity = assemblyIdentity;
       this.isRetargetable = isRetargetable;
       this.containsForeignTypes = containsForeignTypes;
 }

 public static int Of(IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     if (method.HasOperations())
         return method.CalculateCyclomaticComplexity(pdb, host);
     else
         return 0;
 }

    public DotNetDesktopStubMethodBodyEmitter(IMetadataHost host)
      : base(host) {

      this.consoleWriteLine = new Microsoft.Cci.MethodReference(host,
        GarbageCollectHelper.CreateTypeReference(host, coreAssemblyReference, "System.Console"),
        CallingConvention.Default,
        host.PlatformType.SystemVoid,
        host.NameTable.GetNameFor("WriteLine"),
        0,
        host.PlatformType.SystemString);

      this.environmentGetStackTrace = new Microsoft.Cci.MethodReference(host,
        GarbageCollectHelper.CreateTypeReference(host, coreAssemblyReference, "System.Environment"),
        CallingConvention.Default,
        host.PlatformType.SystemString,
        host.NameTable.GetNameFor("get_StackTrace"),
        0);

      this.environmentExit = new Microsoft.Cci.MethodReference(host,
        GarbageCollectHelper.CreateTypeReference(host, coreAssemblyReference, "System.Environment"),
        CallingConvention.Default,
        host.PlatformType.SystemVoid,
        host.NameTable.GetNameFor("Exit"),
        0,
        host.PlatformType.SystemInt32);
    }

        /// <summary>
        /// A rewriter for CodeModel method bodies, which changes any foreach loops found in the body into lower level structures.
        /// </summary>
        /// <param name="host">An object representing the application that is hosting the converter. It is used to obtain access to some global
        /// objects and services such as the shared name table and the table for interning references.</param>
        /// <param name="sourceLocationProvider">An object that can map the ILocation objects found in a block of statements to IPrimarySourceLocation objects. May be null.</param>
        public ForEachRemover(IMetadataHost host, ISourceLocationProvider/*?*/ sourceLocationProvider)
            : base(host)
        {
            this.sourceLocationProvider = sourceLocationProvider;


            this.moveNext = new MethodReference()
            {
                CallingConvention = CallingConvention.HasThis,
                ContainingType = host.PlatformType.SystemCollectionsIEnumerator,
                InternFactory = host.InternFactory,
                Name = host.NameTable.GetNameFor("MoveNext"),
                Parameters = new List<IParameterTypeInformation>(),
                Type = host.PlatformType.SystemBoolean,
            };

            var assemblyReference = new Immutable.AssemblyReference(this.host, this.host.CoreAssemblySymbolicIdentity);
            IUnitNamespaceReference ns = new Immutable.RootUnitNamespaceReference(assemblyReference);
            ns = new Immutable.NestedUnitNamespaceReference(ns, this.host.NameTable.GetNameFor("System"));
            var iDisposable = new Immutable.NamespaceTypeReference(this.host, ns, this.host.NameTable.GetNameFor("IDisposable"), 0, false, false, true, PrimitiveTypeCode.Reference);
            this.disposeMethod = new MethodReference()
            {
                CallingConvention = CallingConvention.HasThis,
                ContainingType = iDisposable,
                InternFactory = host.InternFactory,
                Name = this.host.NameTable.GetNameFor("Dispose"),
                Parameters = new List<IParameterTypeInformation>(),
                Type = this.host.PlatformType.SystemVoid,
            };
        }

 private static int CalculateStatements(this IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     var methodBody = method.Decompile(pdb, host);
     var statementCollector = new StatementCollector(pdb);
     statementCollector.Traverse(methodBody.Statements());
     return statementCollector.ResultCount;
 }