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;
 }

 public HostEnvironment(INameTable table, IEnumerable<String> assemblyPaths, IEnumerable<String> referencedAssemblies)
     : base(table, new InternFactory(), 4, assemblyPaths, true)
 {
     _peReader = new PeReader(this);
     _assemblyPaths = assemblyPaths;
     _referencedAssemblies = referencedAssemblies;
 }

 /// <summary>
 /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
 /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
 /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
 /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
 /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
 /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
 /// </param>
 /// <param name="factory">The intern factory to use when generating keys. When comparing two or more assemblies using
 /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.</param>
 protected MetadataHostEnvironment(INameTable nameTable, IInternFactory factory, byte pointerSize)
   //^ requires pointerSize == 0 || pointerSize == 4 || pointerSize == 8;
 {
   this.nameTable = nameTable;
   this.internFactory = factory;
   this.pointerSize = pointerSize;
 }

 /// <summary>
 /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="factory">
 /// The intern factory to use when generating keys. When comparing two or more assemblies using
 /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.
 /// </param>
 /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
 /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
 /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
 /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
 /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
 /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
 /// </param>
 /// <param name="searchPaths">
 /// A collection of strings that are interpreted as valid paths which are used to search for units.
 /// </param>
 /// <param name="searchInGAC">
 /// Whether the GAC (Global Assembly Cache) should be searched when resolving references.
 /// </param>
 protected MetadataHostEnvironment(INameTable nameTable, IInternFactory factory, byte pointerSize, IEnumerable<string> searchPaths, bool searchInGAC)
   //^ requires pointerSize == 0 || pointerSize == 4 || pointerSize == 8;
 {
   this.nameTable = nameTable;
   this.internFactory = factory;
   this.pointerSize = pointerSize;
   this.libPaths = searchPaths == null ? new List<string>(0) : new List<string>(searchPaths);
   this.SearchInGAC = searchInGAC;
 }

    /// <summary>
    /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
    /// </summary>
    /// <param name="nameTable">
    /// A collection of IName instances that represent names that are commonly used during compilation.
    /// This is a provided as a parameter to the host environment in order to allow more than one host
    /// environment to co-exist while agreeing on how to map strings to IName instances.
    /// </param>
    /// <param name="factory">
    /// The intern factory to use when generating keys. When comparing two or more assemblies using
    /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.
    /// </param>
    /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
    /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
    /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
    /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
    /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
    /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
    /// </param>
    /// <param name="searchPaths">
    /// A collection of strings that are interpreted as valid paths which are used to search for units. May be null.
    /// </param>
    /// <param name="searchInGAC">
    /// Whether the GAC (Global Assembly Cache) should be searched when resolving references.
    /// </param>
    protected MetadataHostEnvironment(INameTable nameTable, IInternFactory factory, byte pointerSize, IEnumerable<string>/*?*/ searchPaths, bool searchInGAC) {
      Contract.Requires(nameTable != null);
      Contract.Requires(factory != null);
      Contract.Requires(pointerSize == 0 || pointerSize == 4 || pointerSize == 8);

      this.nameTable = nameTable;
      this.internFactory = factory;
      this.pointerSize = pointerSize;
      this.libPaths = searchPaths == null ? new List<string>(0) : new List<string>(searchPaths);
      this.SearchInGAC = searchInGAC;
    }

        public static AssemblyIdentity Parse(INameTable nameTable, string formattedName)
        {
            var name = new System.Reflection.AssemblyName(formattedName);
            return new AssemblyIdentity(nameTable.GetNameFor(name.Name),
                                        name.CultureName,
                                        name.Version,
                                        name.GetPublicKeyToken(),
#if COREFX
                                        "");
#else
                                        name.CodeBase);
#endif
        }

 /// <summary>
 /// Specifies whether this attribute applies to derived types and/or overridden methods.
 /// This information is obtained from an attribute on the attribute type definition.
 /// </summary>
 public static bool Inherited(ITypeDefinition attributeType, INameTable nameTable) {
   foreach (ICustomAttribute ca in attributeType.Attributes) {
     if (!TypeHelper.TypesAreEquivalent(ca.Type, attributeType.PlatformType.SystemAttributeUsageAttribute))
       continue;
     foreach (IMetadataNamedArgument namedArgument in ca.NamedArguments) {
       if (namedArgument.ArgumentName.UniqueKey == nameTable.AllowMultiple.UniqueKey) {
         IMetadataConstant/*?*/ compileTimeConst = namedArgument.ArgumentValue as IMetadataConstant;
         if (compileTimeConst == null || compileTimeConst.Value == null || !(compileTimeConst.Value is bool))
           continue;
         //^ assume false; //Unboxing cast might fail
         return (bool)compileTimeConst.Value;
       }
     }
   }
   return false;
 }

 internal NamespaceTypeName(INameTable nameTable, NamespaceName/*?*/ namespaceName, IName name) {
   this.NamespaceName = namespaceName;
   this.Name = name;
   string nameStr = null;
   TypeCache.SplitMangledTypeName(name.Value, out nameStr, out this.genericParameterCount);
   if (this.genericParameterCount > 0)
     this.unmanagledTypeName = nameTable.GetNameFor(nameStr);
   else
     this.unmanagledTypeName = name;
 }

 internal NamespaceName(INameTable nameTable, NamespaceName/*?*/ parentNamespaceName, IName name) {
   this.ParentNamespaceName = parentNamespaceName;
   this.Name = name;
   if (parentNamespaceName == null)
     this.FullyQualifiedName = name;
   else
     this.FullyQualifiedName = nameTable.GetNameFor(parentNamespaceName.FullyQualifiedName.Value + "." + name);
 }

 /// <summary>
 /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="factory">The intern factory to use when generating keys. When comparing two or more assemblies using
 /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.</param>
 /// /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
 /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
 /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
 /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
 /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
 /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
 /// </param>
 protected MetadataReaderHost(INameTable nameTable, IInternFactory factory, byte pointerSize)
   : base(nameTable, factory, pointerSize)
   //^ requires pointerSize == 0 || pointerSize == 4 || pointerSize == 8;
 {
 }

 internal NestedTypeName(INameTable nameTable, NominalTypeName containingTypeName, IName mangledName) {
   this.ContainingTypeName = containingTypeName;
   this.Name = mangledName;
   string nameStr = null;
   TypeCache.SplitMangledTypeName(mangledName.Value, out nameStr, out this.genericParameterCount);
   this.unmangledTypeName = nameTable.GetNameFor(nameStr);
 }

 /// <summary>
 /// Allocates a simple host environment using default settings inherited from MetadataReaderHost and that
 /// uses PeReader as its metadata reader.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 public DefaultHost(INameTable nameTable)
   : base(nameTable) {
   this.peReader = new PeReader(this);
 }

 /// <summary>
 /// Allocates a visitor that traverses a code model and generates explicit assert and assume statements based on implicit checks and assumptions
 /// that are present in the object model. For example, any array index expression implicitly asserts that the array index is within bounds.
 /// The purpose of this visitor is to produce an object model that can be checked by a static checker, without requiring the static checker to
 /// have special cases for all of the implicit assertions and assumes in the code.
 /// </summary>
 /// <param name="nameTable">A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.</param>
 /// <param name="insertAssumeFalseAtLine"></param>
 public AssertAssumeAdderVisitor(INameTable nameTable, uint? insertAssumeFalseAtLine)
     : base()
 {
     this.nameTable = nameTable;
       this.insertAssumeFalseAtLine = insertAssumeFalseAtLine;
 }

 /// <summary>
 /// Allocates a simple host environment using default settings inherited from MetadataReaderHost and that
 /// uses PeReader as its metadata reader.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 public DefaultHost(INameTable nameTable)
     : base(nameTable, new InternFactory(), 0, null, false)
 {
     this.peReader = new PeReader(this);
 }

 internal ILGeneratorScope(uint offset, INameTable nameTable, IMethodDefinition containingMethod)
 {
     this.offset = offset;
       this.nameTable = nameTable;
       this.methodDefinition = containingMethod;
 }

 private NamespaceName/*?*/ GetNamespaceName(INameTable nameTable, INestedUnitNamespaceReference/*?*/ nestedUnitNamespaceReference) {
   if (nestedUnitNamespaceReference == null) return null;
   var parentNamespaceName = this.GetNamespaceName(nameTable, nestedUnitNamespaceReference.ContainingUnitNamespace as INestedUnitNamespaceReference);
   return new NamespaceName(nameTable, parentNamespaceName, nestedUnitNamespaceReference.Name);
 }

 internal TypeNameParser(
   INameTable nameTable,
   string typeName
 ) {
   this.NameTable = nameTable;
   this.TypeName = typeName;
   this.Length = typeName.Length;
   this.Version = nameTable.GetNameFor("Version");
   this.Retargetable = nameTable.GetNameFor("Retargetable");
   this.PublicKeyToken = nameTable.GetNameFor("PublicKeyToken");
   this.Culture = nameTable.GetNameFor("Culture");
   this.neutral = nameTable.GetNameFor("neutral");
   this.CurrentIdentifierInfo = nameTable.EmptyName;
   this.NextToken(false);
 }

 /// <summary>
 /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
 /// Remember to call the Dispose method when the resulting object is no longer needed.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="factory">
 /// The intern factory to use when generating keys. When comparing two or more assemblies using
 /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.
 /// </param>
 /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
 /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
 /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
 /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
 /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
 /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
 /// </param>
 /// <param name="searchPaths">
 /// A collection of strings that are interpreted as valid paths which are used to search for units.
 /// </param>
 /// <param name="searchInGAC">
 /// Whether the GAC (Global Assembly Cache) should be searched when resolving references.
 /// </param>
 protected MetadataReaderHost(INameTable nameTable, IInternFactory factory, byte pointerSize, IEnumerable<string> searchPaths, bool searchInGAC)
   : base(nameTable, factory, pointerSize, searchPaths, searchInGAC) {
   Contract.Requires(pointerSize == 0 || pointerSize == 4 || pointerSize == 8);
 }

 /// <summary>
 /// Allocates a simple host environment using default settings inherited from MetadataReaderHost and that
 /// uses PeReader as its metadata reader.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="projectToCLRTypes">True if the host should project references to certain Windows Runtime types and methods
 /// to corresponding CLR types and methods, in order to emulate the runtime behavior of the CLR.</param>
 public DefaultWindowsRuntimeHost(INameTable nameTable, bool projectToCLRTypes = true)
   : base(nameTable, new InternFactory(), 0, null, false, projectToCLRTypes) {
   this.peReader = new PeReader(this);
 }

 /// <summary>
 /// Allocates an object that provides an abstraction over the application hosting compilers based on this framework.
 /// </summary>
 /// <param name="nameTable">
 /// A collection of IName instances that represent names that are commonly used during compilation.
 /// This is a provided as a parameter to the host environment in order to allow more than one host
 /// environment to co-exist while agreeing on how to map strings to IName instances.
 /// </param>
 /// <param name="factory">
 /// The intern factory to use when generating keys. When comparing two or more assemblies using
 /// TypeHelper, MemberHelper, etc. it is necessary to make the hosts use the same intern factory.
 /// </param>
 /// <param name="pointerSize">The size of a pointer on the runtime that is the target of the metadata units to be loaded
 /// into this metadta host. This parameter only matters if the host application wants to work out what the exact layout
 /// of a struct will be on the target runtime. The framework uses this value in methods such as TypeHelper.SizeOfType and
 /// TypeHelper.TypeAlignment. If the host application does not care about the pointer size it can provide 0 as the value
 /// of this parameter. In that case, the first reference to IMetadataHost.PointerSize will probe the list of loaded assemblies
 /// to find an assembly that either requires 32 bit pointers or 64 bit pointers. If no such assembly is found, the default is 32 bit pointers.
 /// </param>
 /// <param name="searchPaths">
 /// A collection of strings that are interpreted as valid paths which are used to search for units.
 /// </param>
 /// <param name="searchInGAC">
 /// Whether the GAC (Global Assembly Cache) should be searched when resolving references.
 /// </param>
 protected SourceEditHostEnvironment(INameTable nameTable, IInternFactory factory, byte pointerSize, IEnumerable<string> searchPaths, bool searchInGAC)
   : base(nameTable, factory, pointerSize, searchPaths, searchInGAC)
   //^ requires pointerSize == 0 || pointerSize == 4 || pointerSize == 8;
 {
 }