public MetadataNamedArgument(ISymbol entity, Cci.ITypeReference type, Cci.IMetadataExpression value)
 {
     // entity must be one of INamedEntity or IFieldDefinition or IPropertyDefinition
     this.entity = entity;
     this.type = type;
     this.value = value;
 }

 public MethodBody(
     byte[] ilBits,
     ushort maxStack,
     Cci.IMethodDefinition parent,
     ImmutableArray<LocalDefinition> locals,
     SequencePointList sequencePoints,
     DebugDocumentProvider debugDocumentProvider,
     ImmutableArray<Cci.ExceptionHandlerRegion> exceptionHandlers,
     ImmutableArray<LocalScope> localScopes,
     Cci.CustomDebugInfoKind customDebugInfoKind,
     bool hasDynamicLocalVariables,
     ImmutableArray<NamespaceScope> namespaceScopes = default(ImmutableArray<NamespaceScope>),
     string iteratorClassName = null,
     ImmutableArray<LocalScope> iteratorScopes = default(ImmutableArray<LocalScope>),
     Cci.AsyncMethodBodyDebugInfo asyncMethodDebugInfo = null)
 {
     this.ilBits = ilBits;
     this.asyncMethodDebugInfo = asyncMethodDebugInfo;
     this.maxStack = maxStack;
     this.parent = parent;
     this.locals = locals;
     this.sequencePoints = sequencePoints;
     this.debugDocumentProvider = debugDocumentProvider;
     this.exceptionHandlers = exceptionHandlers;
     this.localScopes = localScopes;
     this.customDebugInfoKind = customDebugInfoKind;
     this.hasDynamicLocalVariables = hasDynamicLocalVariables;
     this.namespaceScopes = namespaceScopes.IsDefault ? ImmutableArray<NamespaceScope>.Empty : namespaceScopes;
     this.iteratorClassName = iteratorClassName;
     this.iteratorScopes = iteratorScopes.IsDefault ? ImmutableArray<LocalScope>.Empty : iteratorScopes;
 }

        void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
        {
            Debug.Assert(this.IsDefinitionOrDistinct());

            if (!this.IsDefinition)
            {
                if (this.IsGenericMethod)
                {
                    Debug.Assert(((Cci.IMethodReference)this).AsGenericMethodInstanceReference != null);
                    visitor.Visit((Cci.IGenericMethodInstanceReference)this);
                }
                else
                {
                    Debug.Assert(((Cci.IMethodReference)this).AsSpecializedMethodReference != null);
                    visitor.Visit((Cci.ISpecializedMethodReference)this);
                }
            }
            else
            {
                PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)visitor.Context.Module;
                if (object.ReferenceEquals(this.ContainingModule, moduleBeingBuilt.SourceModule))
                {
                    Debug.Assert(((Cci.IMethodReference)this).GetResolvedMethod(visitor.Context) != null);
                    visitor.Visit((Cci.IMethodDefinition)this);
                } 
                else
                {
                    visitor.Visit((Cci.IMethodReference)this);
                }
            }
        }

        public PermissionSetAttributeWithFileReference(Cci.ICustomAttribute sourceAttribute, string resolvedPermissionSetFilePath)
        {
            Debug.Assert(!String.IsNullOrEmpty(resolvedPermissionSetFilePath));
            Debug.Assert(PathUtilities.IsAbsolute(resolvedPermissionSetFilePath));

            this.sourceAttribute = sourceAttribute;
            this.resolvedPermissionSetFilePath = resolvedPermissionSetFilePath;
        }

        public ExpandedVarargsMethodReference(Cci.IMethodReference underlyingMethod, ImmutableArray<Cci.IParameterTypeInformation> argListParams)
        {
            Debug.Assert(underlyingMethod.AcceptsExtraArguments);
            Debug.Assert(!argListParams.IsEmpty);

            this.underlyingMethod = underlyingMethod;
            this.argListParams = argListParams;
        }

 // used by DllImportAttribute
 public void SetDllImport(int attributeIndex, string moduleName, string entryPointName, Cci.PInvokeAttributes flags, bool preserveSig)
 {
     VerifySealed(expected: false);
     Debug.Assert(attributeIndex >= 0);
     platformInvokeInfo = new DllImportData(moduleName, entryPointName, flags);
     this.dllImportIndex = attributeIndex;
     this.dllImportPreserveSig = preserveSig;
     SetDataStored();
 }

        internal LocalScope(uint begin, uint end, Cci.IMethodDefinition parent, IEnumerable<Cci.ILocalDefinition> constantSymbols, IEnumerable<Cci.ILocalDefinition> localSymbols)
        {
            //we should not create 0-length scopes as they are useless.
            //however we will allow the case of "begin == end" as that is how edge inclusive scopes of length 1 are represented.
            System.Diagnostics.Debug.Assert(begin <= end);

            this.offset = begin;
            this.length = end - begin;
            this.parent = parent;
            this.constantSymbols = constantSymbols;
            this.localSymbols = localSymbols;
        }

        public PEAssemblyBuilder(
            SourceAssemblySymbol sourceAssembly,
            Cci.ModulePropertiesForSerialization serializationProperties,
            IEnumerable<ResourceDescription> manifestResources,
            OutputKind outputKind,
            EmitOptions emitOptions)
            :base(sourceAssembly.DeclaringCompilation, (SourceModuleSymbol)sourceAssembly.Modules[0], serializationProperties, manifestResources, outputKind, emitOptions)
        {
            _sourceAssembly = sourceAssembly;
            _metadataName = (emitOptions.OutputNameOverride == null) ? sourceAssembly.MetadataName : FileNameUtilities.ChangeExtension(emitOptions.OutputNameOverride, extension: null);

            AssemblyOrModuleSymbolToModuleRefMap.Add(sourceAssembly, this);
        }

        protected PEModuleBuilder(
            PhpCompilation compilation,
            SourceModuleSymbol sourceModule,
            Cci.ModulePropertiesForSerialization serializationProperties,
            IEnumerable<ResourceDescription> manifestResources,
            OutputKind outputKind,
            EmitOptions emitOptions)
        {
            Debug.Assert(sourceModule != null);
            Debug.Assert(serializationProperties != null);

            _compilation = compilation;
            _sourceModule = sourceModule;
            _serializationProperties = serializationProperties;
            this.ManifestResources = manifestResources;
            _outputKind = outputKind;
            _emitOptions = emitOptions;
            this.CompilationState = new CommonModuleCompilationState();
            _debugDocuments = new ConcurrentDictionary<string, Cci.DebugSourceDocument>(compilation.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
            _synthesized = new SynthesizedManager(this);

            AssemblyOrModuleSymbolToModuleRefMap.Add(sourceModule, this);
        }

 void Cci.IMetadataExpression.Dispatch(Cci.MetadataVisitor visitor)
 {
     visitor.Visit(this);
 }

 public HexPropertyMetadataNamedArgument(Cci.ITypeReference type, Cci.IMetadataExpression value)
 {
     this.type = type;
     this.value = value;
 }

 void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
 {
     visitor.Visit(this);
 }

 void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
 {
     if (((Cci.IMethodReference)this).AsGenericMethodInstanceReference != null)
     {
         visitor.Visit((Cci.IGenericMethodInstanceReference)this);
     }
     else if (((Cci.IMethodReference)this).AsSpecializedMethodReference != null)
     {
         visitor.Visit((Cci.ISpecializedMethodReference)this);
     }
     else
     {
         visitor.Visit((Cci.IMethodReference)this);
     }
 }

 /// <summary>
 /// Acquires an element referencer method for a given array type
 /// </summary>
 public ArrayMethod GetArrayAddress(Cci.IArrayTypeReference arrayType)
 {
     return GetArrayMethod(arrayType, ArrayMethodKind.ADDRESS);
 }

 public override void Dispatch(Cci.MetadataVisitor visitor)
 {
     visitor.Visit((Cci.ISpecializedNestedTypeReference)this);
 }

 public Looker(Scope scope, Cci.ErrorHandler errorHandler, TrivialHashtable scopeFor, TrivialHashtable ambiguousTypes, TrivialHashtable referencedLabels)
   : base(scope, errorHandler, scopeFor, new TypeSystem(new ErrorHandler(errorHandler.Errors)), ambiguousTypes, referencedLabels){
   this.alreadyReported[StandardIds.Var.UniqueIdKey] = true;
 }

 public void Dispatch(Cci.MetadataVisitor visitor)
 {
     visitor.Visit((Cci.IMethodReference)this);
 }

        void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
        {
            throw ExceptionUtilities.Unreachable;
            //We've not yet discovered a scenario in which we need this.
            //If you're hitting this exception, uncomment the code below
            //and add a unit test.
#if false
            Debug.Assert(this.IsDefinition);

            SymbolKind kind = this.ContainingSymbol.Kind;

            if (((Module)visitor.Context).SourceModule == this.ContainingModule)
            {
                if (kind == SymbolKind.NamedType)
                {
                    visitor.Visit((IGenericTypeParameter)this);
                }
                else if (kind == SymbolKind.Method)
                {
                    visitor.Visit((IGenericMethodParameter)this);
                }
                else
                {
                    throw new NotSupportedException();
                }
            }
            else
            {
                if (kind == SymbolKind.NamedType)
                {
                    visitor.Visit((IGenericTypeParameterReference)this);
                }
                else if (kind == SymbolKind.Method)
                {
                    visitor.Visit((IGenericMethodParameterReference)this);
                }
                else
                {
                    throw new NotSupportedException();
                }
            }
#endif
        }

 /// <summary>
 /// Acquires an array constructor for a given array type
 /// </summary>
 public ArrayMethod GetArrayConstructor(Cci.IArrayTypeReference arrayType)
 {
     return GetArrayMethod(arrayType, ArrayMethodKind.CTOR);
 }

 internal DllImportData(string moduleName, string entryPointName, Cci.PInvokeAttributes flags)
 {
     this.moduleName = moduleName;
     this.entryPointName = entryPointName;
     this.flags = flags;
 }