protected AttributeDecoder(
   PEFileToObjectModel peFileToObjectModel,
   MemoryReader signatureMemoryReader
 )
     {
         this.PEFileToObjectModel = peFileToObjectModel;
           this.SignatureMemoryReader = signatureMemoryReader;
           this.morePermutationsArePossible = true;
     }

     internal override IModuleTypeReference GetAsTypeReference(
   PEFileToObjectModel peFileToObjectModel, IModuleModuleReference module
 )
     {
         return this.GetAsNomimalType(peFileToObjectModel, module);
     }

 internal StandAloneMethodSignatureConverter(PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethodDef, MemoryReader signatureMemoryReader)
   : base(peFileToObjectModel, signatureMemoryReader, moduleMethodDef) {
   this.RequiredParameters = Enumerable<IParameterTypeInformation>.Empty;
   this.VarArgParameters = Enumerable<IParameterTypeInformation>.Empty;
   //  TODO: Check minimum required size of the signature...
   this.FirstByte = this.SignatureMemoryReader.ReadByte();
   int paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
   bool dummyPinned;
   this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
   byte retByte = this.SignatureMemoryReader.PeekByte(0);
   if (retByte == ElementType.Void) {
     this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemVoid;
     this.SignatureMemoryReader.SkipBytes(1);
   } else if (retByte == ElementType.TypedReference) {
     this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemTypedReference;
     this.SignatureMemoryReader.SkipBytes(1);
   } else {
     if (retByte == ElementType.ByReference) {
       this.IsReturnByReference = true;
       this.SignatureMemoryReader.SkipBytes(1);
     }
     this.ReturnTypeReference = this.GetTypeReference();
   }
   if (paramCount > 0) {
     IParameterTypeInformation[] reqModuleParamArr = this.GetModuleParameterTypeInformations(Dummy.Signature, paramCount);
     if (reqModuleParamArr.Length > 0) this.RequiredParameters = IteratorHelper.GetReadonly(reqModuleParamArr);
     IParameterTypeInformation[] varArgModuleParamArr = this.GetModuleParameterTypeInformations(Dummy.Signature, paramCount - reqModuleParamArr.Length);
     if (varArgModuleParamArr.Length > 0) this.VarArgParameters = IteratorHelper.GetReadonly(varArgModuleParamArr);
   }
 }

 internal override ITypeReference/*?*/ GetAsTypeReference(PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module) {
   foreach (var aref in peFileToObjectModel.GetAssemblyReferences()) {
     var assemRef = aref as AssemblyReference;
     if (assemRef == null) continue;
     if (assemRef.AssemblyIdentity.Equals(this.AssemblyIdentity))
       return this.TypeName.GetAsTypeReference(peFileToObjectModel, assemRef);
   }
   if (module.ContainingAssembly.AssemblyIdentity.Equals(this.AssemblyIdentity))
     return this.TypeName.GetAsTypeReference(peFileToObjectModel, module);
   AssemblyFlags flags = this.Retargetable ? AssemblyFlags.Retargetable : (AssemblyFlags)0;
   return this.TypeName.GetAsTypeReference(peFileToObjectModel, new AssemblyReference(peFileToObjectModel, 0, this.AssemblyIdentity, flags));
 }

 internal override IMetadataReaderNamedTypeReference/*?*/ GetAsNomimalType(
   PEFileToObjectModel peFileToObjectModel,
   IMetadataReaderModuleReference module
 ) {
   var typeRef = new NamespaceTypeNameTypeReference(module, this, peFileToObjectModel);
   var redirectedTypeRef = peFileToObjectModel.ModuleReader.metadataReaderHost.Redirect(peFileToObjectModel.Module, typeRef) as INamespaceTypeReference;
   if (redirectedTypeRef != typeRef && redirectedTypeRef != null) {
     var namespaceName = this.GetNamespaceName(peFileToObjectModel.NameTable, redirectedTypeRef.ContainingUnitNamespace as INestedUnitNamespaceReference);
     var mangledName = redirectedTypeRef.Name;
     if (redirectedTypeRef.GenericParameterCount > 0)
       mangledName = peFileToObjectModel.NameTable.GetNameFor(redirectedTypeRef.Name.Value+"`"+redirectedTypeRef.GenericParameterCount);
     var redirectedNamespaceTypeName = new NamespaceTypeName(peFileToObjectModel.NameTable, namespaceName, mangledName, redirectedTypeRef.Name);
     return new NamespaceTypeNameTypeReference(module, redirectedNamespaceTypeName, peFileToObjectModel);
   }
   return typeRef;
 }

     //^ [NotDelayed]
     internal SecurityAttributeDecoder20(
   PEFileToObjectModel peFileToObjectModel,
   MemoryReader signatureMemoryReader,
   SecurityAttribute securityAttribute
 )
         : base(peFileToObjectModel, signatureMemoryReader)
     {
         //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
           this.SecurityAttributes = TypeCache.EmptySecurityAttributes;
           //^ base;
           byte prolog = this.SignatureMemoryReader.ReadByte();
           if (prolog != SerializationType.SecurityAttribute20Start) {
         return;
           }
           int numberOfAttributes = this.SignatureMemoryReader.ReadCompressedUInt32();
           SecurityCustomAttribute[] securityCustomAttributes = new SecurityCustomAttribute[numberOfAttributes];
           for (int i = 0; i < numberOfAttributes; ++i) {
         SecurityCustomAttribute/*?*/ secAttr = this.ReadSecurityAttribute(securityAttribute);
         if (secAttr == null) {
           //  MDError...
           return;
         }
         securityCustomAttributes[i] = secAttr;
           }
           //^ NonNullType.AssertInitialized(securityCustomAttributes);
           this.SecurityAttributes = new EnumerableArrayWrapper<SecurityCustomAttribute, ICustomAttribute>(securityCustomAttributes, Dummy.CustomAttribute);
     }

     //^ [NotDelayed]
     internal CustomAttributeDecoder(
   PEFileToObjectModel peFileToObjectModel,
   MemoryReader signatureMemoryReader,
   uint customAttributeRowId,
   IModuleMethodReference attributeConstructor
 )
         : base(peFileToObjectModel, signatureMemoryReader)
     {
         //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
           this.CustomAttribute = Dummy.CustomAttribute;
           //^ base;
           ushort prolog = this.SignatureMemoryReader.ReadUInt16();
           if (prolog != SerializationType.CustomAttributeStart) {
         return;
           }
           List<ExpressionBase> exprList = new List<ExpressionBase>();
           IModuleParameterTypeInformation[] modParams = attributeConstructor.RequiredModuleParameterInfos.RawArray;
           int len = modParams.Length;
           for (int i = 0; i < len; ++i) {
         IModuleTypeReference/*?*/ moduleTypeRef = modParams[i].ModuleTypeReference;
         if (moduleTypeRef == null) {
           //  Error...
           return;
         }
         ExpressionBase/*?*/ argument = this.ReadSerializedValue(moduleTypeRef);
         if (argument == null) {
           //  Error...
           this.decodeFailed = true;
           return;
         }
         exprList.Add(argument);
           }
           ushort numOfNamedArgs = this.SignatureMemoryReader.ReadUInt16();
           FieldOrPropertyNamedArgumentExpression[]/*?*/ namedArgumentArray = null;
           if (numOfNamedArgs > 0) {
         namedArgumentArray = new FieldOrPropertyNamedArgumentExpression[numOfNamedArgs];
         for (ushort i = 0; i < numOfNamedArgs; ++i) {
           bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
           IModuleTypeReference/*?*/ memberType = this.GetFieldOrPropType();
           if (memberType == null) {
         //  Error...
         return;
           }
           string/*?*/ memberStr = this.GetSerializedString();
           if (memberStr == null)
         return;
           IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
           ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
           if (value == null) {
         //  Error...
         return;
           }
           IModuleTypeReference/*?*/ moduleTypeRef = attributeConstructor.OwningTypeReference;
           if (moduleTypeRef == null) {
         //  Error...
         return;
           }
           FieldOrPropertyNamedArgumentExpression namedArg = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeRef, isField, memberType, value);
           namedArgumentArray[i] = namedArg;
         }
           }
           EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> arguments = TypeCache.EmptyExpressionList;
           if (exprList.Count > 0)
         arguments = new EnumerableArrayWrapper<ExpressionBase, IMetadataExpression>(exprList.ToArray(), Dummy.Expression);
           EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument> namedArguments = TypeCache.EmptyNamedArgumentList;
           if (namedArgumentArray != null)
         namedArguments = new EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument>(namedArgumentArray, Dummy.NamedArgument);
           this.CustomAttribute = new CustomAttribute(this.PEFileToObjectModel, customAttributeRowId, attributeConstructor, arguments, namedArguments);
     }

     /*?*/
     internal abstract TypeBase ResolveNominalTypeName(
   PEFileToObjectModel peFileToObjectModel
 );

 internal SecurityAttribute(
   PEFileToObjectModel peFileToObjectModel,
   uint declSecurityRowId,
   SecurityAction action
 )
   : base(peFileToObjectModel) {
   this.DeclSecurityRowId = declSecurityRowId;
   this.Action = action;
 }

     internal CustomAttribute(
   PEFileToObjectModel peFileToObjectModel,
   uint attributeRowId,
   IModuleMethodReference constructor,
   EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> arguments,
   EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument> namedArguments
 )
         : base(peFileToObjectModel)
     {
         this.AttributeRowId = attributeRowId;
           this.Constructor = constructor;
           this.Arguments = arguments;
           this.NamedArguments = namedArguments;
     }

 internal IMetadataReaderNamedTypeReference GetAsNamedTypeReference(
   PEFileToObjectModel peFileToObjectModel, IMetadataReaderModuleReference module
 ) {
   return this.GetAsNomimalType(peFileToObjectModel, module);
 }

 internal abstract INamedTypeDefinition/*?*/ ResolveNominalTypeName(
   PEFileToObjectModel peFileToObjectModel
 );

 private ITypeReference GetSpecializedTypeReference(PEFileToObjectModel peFileToObjectModel, INamedTypeReference nominalType, out int argumentUsed, bool mostNested) {
   argumentUsed = 0;
   int len = this.GenericArguments.Count;
   var nestedType = nominalType as INestedTypeReference;
   if (nestedType != null) {
     var parentTemplate = this.GetSpecializedTypeReference(peFileToObjectModel, (INamedTypeReference)nestedType.ContainingType, out argumentUsed, mostNested: false);
     if (parentTemplate != nestedType.ContainingType)
       nominalType = new SpecializedNestedTypeReference(nestedType, parentTemplate, peFileToObjectModel.InternFactory);
   }
   var argsToUse = mostNested ? len-argumentUsed : nominalType.GenericParameterCount;
   if (argsToUse == 0) return nominalType;
   var genericArgumentsReferences = new ITypeReference[argsToUse];
   for (int i = 0; i < argsToUse; ++i)
     genericArgumentsReferences[i] = this.GenericArguments[i+argumentUsed].GetAsTypeReference(peFileToObjectModel, peFileToObjectModel.Module)??Dummy.TypeReference;
   argumentUsed += argsToUse;
   return new GenericTypeInstanceReference(nominalType, IteratorHelper.GetReadonly(genericArgumentsReferences), peFileToObjectModel.InternFactory);
 }

 internal TypeOfExpression(
   PEFileToObjectModel peFileToObjectModel,
   ITypeReference/*?*/ typeExpression
 ) {
   this.PEFileToObjectModel = peFileToObjectModel;
   this.TypeExpression = typeExpression;
 }

 internal LocalVariableSignatureConverter(
   PEFileToObjectModel peFileToObjectModel,
   MethodBody owningMethodBody,
   MemoryReader signatureMemoryReader
 )
   : base(peFileToObjectModel, signatureMemoryReader, owningMethodBody.MethodDefinition) {
   this.OwningMethodBody = owningMethodBody;
   byte firstByte = this.SignatureMemoryReader.ReadByte();
   if (!SignatureHeader.IsLocalVarSignature(firstByte)) {
     //  MDError
   }
   int locVarCount = this.SignatureMemoryReader.ReadCompressedUInt32();
   LocalVariableDefinition[] locVarArr = new LocalVariableDefinition[locVarCount];
   for (int i = 0; i < locVarCount; ++i) {
     locVarArr[i] = this.GetLocalVariable((uint)i);
   }
   this.LocalVariables = locVarArr;
 }

 internal CustomAttribute(PEFileToObjectModel peFileToObjectModel, uint attributeRowId, IMethodReference constructor,
   IMetadataExpression[]/*?*/ arguments, IMetadataNamedArgument[]/*?*/ namedArguments)
   : base(peFileToObjectModel) {
   this.AttributeRowId = attributeRowId;
   this.Constructor = constructor;
   this.Arguments = arguments;
   this.NamedArguments = namedArguments;
 }

 internal ILReader(
   MethodDefinition methodDefinition,
   MethodIL methodIL
 ) {
   this.MethodDefinition = methodDefinition;
   this.PEFileToObjectModel = methodDefinition.PEFileToObjectModel;
   this.MethodIL = methodIL;
   this.MethodBody = new MethodBody(methodDefinition, methodIL.LocalVariablesInited, methodIL.MaxStack);
   this.EndOfMethodOffset = (uint)methodIL.EncodedILMemoryBlock.Length;
 }

     /*?*/
     internal abstract IModuleNominalType GetAsNomimalType(
   PEFileToObjectModel peFileToObjectModel,
   IModuleModuleReference module
 );