//-----------------------------------------------------------------------------

//

// Copyright (C) Microsoft Corporation.  All Rights Reserved.

//

//-----------------------------------------------------------------------------

using System;

using System.Collections;

using System.Collections.Generic;

using System.Globalization;

using System.Collections.Specialized;

#if FxCop

using AssemblyReferenceList = Microsoft.Cci.AssemblyReferenceCollection;

using AttributeList = Microsoft.Cci.AttributeNodeCollection;

using BlockList = Microsoft.Cci.BlockCollection;

using ExpressionList = Microsoft.Cci.ExpressionCollection;

using InstructionList = Microsoft.Cci.InstructionCollection;

using Int32List = System.Collections.Generic.List<int>;

using InterfaceList = Microsoft.Cci.InterfaceCollection;

using MemberList = Microsoft.Cci.MemberCollection;

using MethodList = Microsoft.Cci.MethodCollection;

using ModuleReferenceList = Microsoft.Cci.ModuleReferenceCollection;

using NamespaceList = Microsoft.Cci.NamespaceCollection;

using ParameterList = Microsoft.Cci.ParameterCollection;

using ResourceList = Microsoft.Cci.ResourceCollection;

using SecurityAttributeList = Microsoft.Cci.SecurityAttributeCollection;

using StatementList = Microsoft.Cci.StatementCollection;

using TypeNodeList = Microsoft.Cci.TypeNodeCollection;

using Win32ResourceList = Microsoft.Cci.Win32ResourceCollection;

using Module = Microsoft.Cci.ModuleNode;

using Class = Microsoft.Cci.ClassNode;

using Interface = Microsoft.Cci.InterfaceNode;

using Property = Microsoft.Cci.PropertyNode;

using Event = Microsoft.Cci.EventNode;

using Return = Microsoft.Cci.ReturnNode;

using Throw = Microsoft.Cci.ThrowNode;

#endif

#if UseSingularityPDB

using Microsoft.Singularity.PdbInfo;

#endif

#if CCINamespace

using Cci = Microsoft.Cci;

using Microsoft.Cci.Metadata;

using Metadata = Microsoft.Cci.Metadata;

#else

using Cci = System.Compiler;

using System.Compiler.Metadata;

using Metadata = System.Compiler.Metadata;

#endif

using System.Diagnostics;

using System.IO;

using System.Text;

#if !NoXml

using System.Xml;

#endif



using BindingFlags = System.Reflection.BindingFlags;



#if CCINamespace

namespace Microsoft.Cci{

#else

namespace System.Compiler{

#endif

#if !FxCop

  /// <summary>

  /// This interface can be used to link an arbitrary source text provider into an IR tree via a DocumentText instance.

  /// </summary>

  public interface ISourceText{

    /// <summary>

    /// The number of characters in the source text. 

    /// A "character" corresponds to a System.Char which is actually a Unicode UTF16 code point to be precise.

    /// </summary>

    int Length{get;}

    /// <summary>

    /// Retrieves a substring from this instance. The substring starts with the character at the specified index and has a specified length.

    /// </summary>

    string Substring(int startIndex, int length);

    /// <summary>

    /// Retrieves the character at the given position. The first character is at position zero.

    /// </summary>

    char this[int position]{get;}

    /// <summary>

    /// Indicates that the text has been fully scanned and futher references to the text are expected to be infrequent.

    /// The underlying object can now choose to clear cached information if it comes under resource pressure.

    /// </summary>

    void MakeCollectible();

  }

  public unsafe interface ISourceTextBuffer : ISourceText{

    /// <summary>

    /// Returns null unless the implementer is based on an ASCII buffer that stays alive as long at the implementer itself.

    /// An implementer that returns a non-null value is merely a wrapper to keep the buffer alive. No further methods will

    /// be called on the interface in this case.

    /// </summary>

    byte* Buffer{get;}

  }

#endif

#if !MinimalReader

  /// <summary>

  /// Use this after a source text has already been scanned and parsed. This allows the source text to get released

  /// if there is memory pressure, while still allowing portions of it to be retrieved on demand. This is useful when

  /// a large number of source files are read in, but only infrequent references are made to them.

  /// </summary>

  public sealed class CollectibleSourceText : ISourceText{

    private string/*!*/ filePath;

    private WeakReference/*!*/ fileContent;

    private int length;



    public CollectibleSourceText(string/*!*/ filePath, int length) {

      this.filePath = filePath;

      this.fileContent = new WeakReference(null);

      this.length = length;

      //^ base();

    }

    public CollectibleSourceText(string/*!*/ filePath, string fileContent) {

      this.filePath = filePath;

      this.fileContent = new WeakReference(fileContent);

      this.length = fileContent == null ? 0 : fileContent.Length;

      //^ base();

    }

    private string/*!*/ ReadFile() {

      string content = string.Empty;

      try {

        StreamReader sr = new StreamReader(filePath);

        content = sr.ReadToEnd();

        this.length = content.Length;

        sr.Close();

      }catch{}

      return content;

    }

    public string/*!*/ GetSourceText() {

      string source = (string)this.fileContent.Target;

      if (source != null) return source;

      source = this.ReadFile();

      this.fileContent.Target = source;

      return source;

    }



    int ISourceText.Length{get{return this.length;}}

    string ISourceText.Substring(int startIndex, int length){

      return this.GetSourceText().Substring(startIndex, length);

    }

    char ISourceText.this[int index]{

      get{

        return this.GetSourceText()[index];

      }

    }

    void ISourceText.MakeCollectible(){

      this.fileContent.Target = null;

    }

  }

  /// <summary>

  /// This class is used to wrap the string contents of a source file with an ISourceText interface. It is used while compiling

  /// a project the first time in order to obtain a symbol table. After that the StringSourceText instance is typically replaced with

  /// a CollectibleSourceText instance, so that the actual source text string can be collected. When a file is edited, 

  /// and the editor does not provide its own ISourceText wrapper for its edit buffer, this class can be used to wrap a copy of the edit buffer.

  /// </summary>

  public sealed class StringSourceText : ISourceText{

    /// <summary>

    /// The wrapped string used to implement ISourceText. Use this value when unwrapping.

    /// </summary>

    public readonly string/*!*/ SourceText;

    /// <summary>

    /// True when the wrapped string is the contents of a file. Typically used to check if it safe to replace this

    /// StringSourceText instance with a CollectibleSourceText instance.

    /// </summary>

    public bool IsSameAsFileContents;



    public StringSourceText(string/*!*/ sourceText, bool isSameAsFileContents) {

      this.SourceText = sourceText;

      this.IsSameAsFileContents = isSameAsFileContents;

      //^ base();

    }

    int ISourceText.Length{get{return this.SourceText.Length;}}

    string ISourceText.Substring(int startIndex, int length){

      return this.SourceText.Substring(startIndex, length);

    }

    char ISourceText.this[int index]{

      get{

        return this.SourceText[index];

      }

    }

    void ISourceText.MakeCollectible(){

    }

  }

#endif

#if !FxCop

  /// <summary>

  /// This class provides a uniform interface to program sources provided in the form of Unicode strings,

  /// unsafe pointers to ascii buffers (as obtained from a memory mapped file, for instance) as well as

  /// arbitrary source text providers that implement the ISourceText interface.

  /// </summary>

  public sealed unsafe class DocumentText{

    /// <summary>

    /// If this is not null it is used to obtain 8-bit ASCII characters.

    /// </summary>

    public byte* AsciiStringPtr;

    /// <summary>

    /// If this is not null it represents a Unicode string encoded as UTF16.

    /// </summary>

    public string Source;

    /// <summary>

    /// If this is not null the object implement ISourceText provides some way to get at individual characters and substrings.

    /// </summary>

    public ISourceText TextProvider;

    /// <summary>

    /// The number of characters in the source document. 

    /// A "character" corresponds to a System.Char which is actually a Unicode UTF16 code point to be precise.

    /// </summary>

    public int Length;

    public DocumentText(string source){

      if (source == null){Debug.Assert(false); return;}

      this.Source = source;

      this.Length = source.Length;

    }

    public DocumentText(ISourceText textProvider){

      if (textProvider == null){Debug.Assert(false); return;}

      this.TextProvider = textProvider;

      this.Length = textProvider.Length;

    }

    public unsafe DocumentText(ISourceTextBuffer textProvider){

      if (textProvider == null){Debug.Assert(false); return;}

      this.TextProvider = textProvider;

      this.AsciiStringPtr = textProvider.Buffer;

      this.Length = textProvider.Length;

    }

    /// <summary>

    /// Compare this.Substring(offset, length) for equality with str.

    /// Call this only if str.Length is known to be equal to length.

    /// </summary>

    public bool Equals(string str, int position, int length){ //TODO: (int position, int length, string str)

      if (str == null){Debug.Assert(false); return false;}

      if (str.Length != length){Debug.Assert(false); return false;}

      if (position < 0 || position+length > this.Length){Debug.Assert(false); return false;}

      unsafe{

        byte* p = this.AsciiStringPtr;

        if (p != null){

          for (int i = position, j = 0; j < length; i++, j++)

            if (((char)*(p+i)) != str[j]) return false;

          return true;

        }

      }

      string source = this.Source;

      if (source != null){

        for (int i = position, j = 0; j < length; i++, j++)

          if (source[i] != str[j]) return false;

        return true;

      }

      ISourceText myProvider = this.TextProvider;

      if (myProvider == null){Debug.Assert(false); return false;}

      for (int i = position, j = 0; j < length; i++, j++)

        if (myProvider[i] != str[j]) return false;

      return true;

    }

    /// <summary>

    /// Compares the substring of the specificied length starting at offset, with the substring in DocumentText starting at textOffset.

    /// </summary>

    /// <param name="offset">The index of the first character of the substring of this DocumentText.</param>

    /// <param name="text">The Document text with the substring being compared to.</param>

    /// <param name="textOffset">The index of the first character of the substring of the DocumentText being compared to.</param>

    /// <param name="length">The number of characters in the substring being compared.</param>

    /// <returns></returns>

    public bool Equals(int offset, DocumentText text, int textOffset, int length){ //TODO: (int position, int length, DocumentText text, int textPosition)

      if (offset < 0 || length < 0 || offset+length > this.Length){ Debug.Assert(false); return false;}

      if (textOffset < 0 || text == null || textOffset+length > text.Length){Debug.Assert(false); return false;}

      unsafe{

        byte* p = this.AsciiStringPtr;

        if (p != null){

          unsafe{

            byte* q = text.AsciiStringPtr;

            if (q != null){

              for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

                if (*(p+i) != *(q+j)) return false;

              return true;

            }

          }

          string textSource = text.Source;

          if (textSource != null){

            for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

              if (((char)*(p+i)) != textSource[j]) return false;

            return true;

          }

          ISourceText textProvider = text.TextProvider;

          if (textProvider == null){Debug.Assert(false); return false;}

          for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

            if (((char)*(p+i)) != textProvider[j]) return false;

          return true;

        }

      }

      string source = this.Source;

      if (source != null){

        unsafe{

          byte* q = text.AsciiStringPtr;

          if (q != null){

            for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

              if (source[i] != (char)*(q+j)) return false;

            return true;

          }

        }

        string textSource = text.Source;

        if (textSource != null){

          for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

            if (source[i] != textSource[j]) return false;

          return true;

        }

        ISourceText textProvider = text.TextProvider;

        if (textProvider == null){Debug.Assert(false); return false;}

        for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

          if (source[i] != textProvider[j]) return false;

        return true;

      } 

      { 

        ISourceText myProvider = this.TextProvider;

        if (myProvider == null){Debug.Assert(false); return false;}

        unsafe{

          byte* q = text.AsciiStringPtr;

          if (q != null){

            for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

              if (myProvider[i] != (char)*(q+j)) return false;

            return true;

          }

        }

        string textSource = text.Source;

        if (textSource != null){

          for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

            if (myProvider[i] != textSource[j]) return false;

          return true;

        }

        ISourceText textProvider = text.TextProvider;

        if (textProvider == null){Debug.Assert(false); return false;}

        for (int i = offset, j = textOffset, n = offset+length; i < n; i++, j++)

          if (myProvider[i] != textProvider[j]) return false;

        return true;

      }

    }

    /// <summary>

    /// Retrieves a substring from this instance. The substring starts at a specified character position and has a specified length.

    /// </summary>

    public string/*!*/ Substring(int position, int length){

      if (position < 0 || length < 0 || position+length > this.Length+1){Debug.Assert(false); return "";}

      if (position+length > this.Length) length = this.Length-position; //Allow virtual EOF character to be included in length

      if (this.AsciiStringPtr != null){

        unsafe{

          return new String((sbyte*)this.AsciiStringPtr, position, length, System.Text.Encoding.ASCII);

        }

      }else if (this.Source != null)

        return this.Source.Substring(position, length);

      else if (this.TextProvider != null)

        return this.TextProvider.Substring(position, length);

      else{

        Debug.Assert(false);

        return "";

      }

    }

    /// <summary>

    /// Retrieves the character at the given position. The first character is at position zero.

    /// </summary>

    public char this[int position]{

      get{

        if (position < 0 || position >= this.Length){Debug.Assert(false); return (char)0;}

        if (this.AsciiStringPtr != null){

          unsafe{

            unchecked{ 

              return (char) *(this.AsciiStringPtr+position);

            }

          }

        }else if (this.Source != null)

          return this.Source[position];

        else if (this.TextProvider != null)

          return this.TextProvider[position];

        else{

          Debug.Assert(false);

          return (char)0;

        }

      }

    }

  }

  /// <summary>

  /// A source document from which an Abstract Syntax Tree has been derived.

  /// </summary>

  public class Document{

    /// <summary>

    /// A Guid that identifies the kind of document to applications such as a debugger. Typically System.Diagnostics.SymbolStore.SymDocumentType.Text.

    /// </summary>

    public System.Guid DocumentType;

    /// <summary>

    /// A Guid that identifies the programming language used in the source document. Typically used by a debugger to locate language specific logic.

    /// </summary>

    public System.Guid Language;

    /// <summary>

    /// A Guid that identifies the compiler vendor programming language used in the source document. Typically used by a debugger to locate vendor specific logic.

    /// </summary>

    public System.Guid LanguageVendor;

    /// <summary>

    /// The line number corresponding to the first character in Text. Typically 1 but can be changed by C# preprocessor directives. 

    /// </summary>

    public int LineNumber;

    /// <summary>

    /// Indicates that the document contains machine generated source code that should not show up in tools such as debuggers.

    /// Can be set by C# preprocessor directives.

    /// </summary>

    public bool Hidden;

    /// <summary>

    /// The name of the document. Typically a file name. Can be a full or relative file path, or a URI or some other kind of identifier.

    /// </summary>

    public string/*!*/ Name;

    /// <summary>

    /// Contains the source text.

    /// </summary>

    public DocumentText Text;

    public Document(){

      this.Name = "";

      //^ base();

    }

    public Document(string/*!*/ name, int lineNumber, string text, System.Guid documentType, System.Guid language, System.Guid languageVendor)

      :this(name, lineNumber, new DocumentText(text), documentType, language, languageVendor){

    }

    public Document(string/*!*/ name, int lineNumber, DocumentText text, System.Guid documentType, System.Guid language, System.Guid languageVendor) {

      this.DocumentType = documentType;

      this.Language = language;

      this.LanguageVendor = languageVendor;

      this.LineNumber = lineNumber;

      this.Name = name;

      this.Text = text;

      //^ base();

    }



    /// <summary>

    /// Maps the given zero based character position to the number of the source line containing the same character. 

    /// Line number counting starts from the value of LineNumber.

    /// </summary>

    public virtual int GetLine(int position){

      int line = 0; int column = 0;

      this.GetPosition(position, out line, out column);

      return line+this.LineNumber;

    }

    /// <summary>

    /// Maps the given zero based character position in the entire text to the position of the same character in a source line.

    /// Counting within the source line starts at 1.

    /// </summary>

    public virtual int GetColumn(int position){

      int line = 0; int column = 0;

      this.GetPosition(position, out line, out column);

      return column+1;

    }



    /// <summary>

    /// Given a startLine, startColum, endLine and endColumn, this returns the corresponding startPos and endPos. In other words it

    /// converts a range expression in line and columns to a range expressed as a start and end character position.

    /// </summary>

    /// <param name="startLine">The number of the line containing the first character. The number of the first line equals this.LineNumber.</param>

    /// <param name="startColumn">The position of the first character relative to the start of the line. Counting from 1.</param>

    /// <param name="endLine">The number of the line contain the character that immediate follows the last character of the range.</param>

    /// <param name="endColumn">The position, in the last line, of the character that immediately follows the last character of the range.</param>

    /// <param name="startPos">The position in the entire text of the first character of the range, counting from 0.</param>

    /// <param name="endPos">The position in the entire text of the character following the last character of the range.</param>

    public virtual void GetOffsets(int startLine, int startColumn, int endLine, int endColumn, out int startPos, out int endPos){

      lock(this){

        if (this.lineOffsets == null) this.ComputeLineOffsets();

        //^ assert this.lineOffsets != null;

        startPos = this.lineOffsets[startLine-this.LineNumber]+startColumn-1;

        endPos = this.lineOffsets[endLine-this.LineNumber]+endColumn-1;

      }

    }



    /// <summary>

    /// Retrieves a substring from the text of this Document. The substring starts at a specified character position and has a specified length.

    /// </summary>

    public virtual string Substring(int position, int length){

      if (this.Text == null) return null;

      return this.Text.Substring(position, length);

    }



    /// <summary>

    /// Counts the number of end of line marker sequences in the given text.

    /// </summary>

    protected int GetLineCount(string/*!*/ text) {

      int n = text == null ? 0 : text.Length;

      int count = 0;

      for (int i = 0; i < n; i++){

        switch(text[i]){

          case '\r':

            if (i+1 < n && text[i+1] == '\n')

              i++;

            count++;

            break;

          case '\n':

          case (char)0x2028:

          case (char)0x2029:

            count++;

            break;

        }

      }

      return count;

    }

    /// <summary>An array of offsets, with offset at index i corresponding to the position of the first character of line i, (counting lines from 0).</summary>

    private int[] lineOffsets;

    /// <summary>The number of lines in Text.</summary>

    private int lines;



    /// <summary>

    ///  Returns the index in this.lineOffsets array such that this.lineOffsets[index] is less than or equal to offset

    ///  and offset is less than lineOffsets[index+1]

    /// </summary>

    private int Search(int offset){

    tryAgain:

      int[] lineOffsets = this.lineOffsets;

      int lines = this.lines;

      if (lineOffsets == null){Debug.Assert(false); return -1;}

      if (offset < 0){Debug.Assert(false); return -1;}

      int mid = 0;

      int low = 0;

      int high = lines-1;

      while (low < high){

        mid = (low+high)/2;

        if (lineOffsets[mid] <= offset){

          if (offset < lineOffsets[mid+1])

            return mid;

          else

            low = mid + 1;

        }else

          high = mid;

      }

      Debug.Assert(lines == this.lines);

      Debug.Assert(lineOffsets[low] <= offset);

      Debug.Assert(offset < lineOffsets[low+1]);

      if (lineOffsets != this.lineOffsets) goto tryAgain;

      return low;

    }



    /// <summary>

    /// Maps the given zero based character position in the entire text to a (line, column) pair corresponding to the same position.

    /// Counting within the source line starts at 0. Counting source lines start at 0.

    /// </summary>

    private void GetPosition(int offset, out int line, out int column){

      line = 0; column = 0; 

      if (offset < 0 || this.Text == null || offset > this.Text.Length){Debug.Assert(false); return;}

      lock(this){

        if (this.lineOffsets == null) this.ComputeLineOffsets();

        if (this.lineOffsets == null){Debug.Assert(false); return;}

        int[] lineOffsets = this.lineOffsets;

        int index = this.Search(offset);

        Debug.Assert(lineOffsets == this.lineOffsets);

        if (index < 0 || index >= this.lineOffsets.Length){Debug.Assert(false); return;}

        Debug.Assert(this.lineOffsets[index] <= offset && offset < this.lineOffsets[index+1]);

        line = index;

        column = offset-this.lineOffsets[index];

      }

    }

    /// <summary>

    /// Adds the given offset to the this.lineOffsets table as the offset corresponding to the start of line this.lines+1.

    /// </summary>

    private void AddOffset(int offset){

      if (this.lineOffsets == null || this.lines < 0){Debug.Assert(false); return;}

      if (this.lines >= this.lineOffsets.Length){

        int n = this.lineOffsets.Length;

        if (n <= 0) n = 16;

        int[] newLineOffsets = new int[n*2];

        Array.Copy(this.lineOffsets, newLineOffsets, this.lineOffsets.Length);

        this.lineOffsets = newLineOffsets;

      }

      this.lineOffsets[this.lines++] = offset;

    }

    public virtual void InsertOrDeleteLines(int offset, int lineCount){

      if (lineCount == 0) return;

      if (offset < 0 || this.Text == null || offset > this.Text.Length){Debug.Assert(false); return;}

      lock(this){

        if (this.lineOffsets == null)

          if (this.lineOffsets == null) this.ComputeLineOffsets();

        if (lineCount < 0)

          this.DeleteLines(offset, -lineCount);

        else

          this.InsertLines(offset, lineCount);

      }

    }

    private void DeleteLines(int offset, int lineCount)

      //^ requires offset >= 0 && this.Text != null && offset < this.Text.Length && lineCount > 0 && this.lineOffsets != null;

    {

      Debug.Assert(offset >= 0 && this.Text != null && offset < this.Text.Length && lineCount > 0 && this.lineOffsets != null);

      int index = this.Search(offset);

      if (index < 0 || index >= this.lines){Debug.Assert(false); return;}

      for (int i = index+1; i+lineCount < this.lines; i++){

        this.lineOffsets[i] = this.lineOffsets[i+lineCount];

      }

      this.lines -= lineCount;

      if (this.lines <= index){Debug.Assert(false); this.lines = index+1;}

    }

    private void InsertLines(int offset, int lineCount)

      //^ requires offset >= 0 && this.Text != null && offset < this.Text.Length && lineCount > 0 && this.lineOffsets != null;

    {

      Debug.Assert(offset >= 0 && this.Text != null && offset < this.Text.Length && lineCount > 0 && this.lineOffsets != null);

      int index = this.Search(offset);

      if (index < 0 || index >= this.lines){Debug.Assert(false); return;}

      int n = this.lineOffsets[this.lines-1];

      for (int i = 0; i < lineCount; i++) this.AddOffset(++n);

      for (int i = lineCount; i > 0; i--){

        this.lineOffsets[index+i+1] = this.lineOffsets[index+1];

      }

    }

    /// <summary>

    /// Populates this.lineOffsets with an array of offsets, with offset at index i corresponding to the position of the first

    /// character of line i, (counting lines from 0).

    /// </summary>

    private void ComputeLineOffsets()

      //ensures this.lineOffsets != null;

    {

      if (this.Text == null){Debug.Assert(false); return;}

      int n = this.Text.Length;

      this.lineOffsets = new int[n/10+1];

      this.lines = 0;

      this.AddOffset(0);

      for (int i = 0; i < n; i++){

        switch(this.Text[i]){

          case '\r':

            if (i+1 < n && this.Text[i+1] == '\n')

              i++;

            this.AddOffset(i+1);

            break;

          case '\n':

          case (char)0x2028:

          case (char)0x2029:

            this.AddOffset(i+1);

            break;

        }

      }

      this.AddOffset(n+1);

      this.AddOffset(n+2);

    }



    /// <summary> Add one to this every time a Document instance gets a unique key.</summary>

    private static int uniqueKeyCounter;

    private int uniqueKey;

    /// <summary>

    /// An integer that uniquely distinguishes this document instance from every other document instance. 

    /// This provides an efficient equality test to facilitate hashing.

    /// </summary>

    public int UniqueKey{

      get{

        if (this.uniqueKey == 0){

        TryAgain:

          int c = Document.uniqueKeyCounter;

          int cp1 = c == int.MaxValue ? 1 : c+1;

          if (System.Threading.Interlocked.CompareExchange(ref Document.uniqueKeyCounter, cp1, c) != c) goto TryAgain;

          this.uniqueKey = cp1;

        }

        return this.uniqueKey;

      }

    }

  }

#endif

#if !MinimalReader

  /// <summary>

  /// For creating source contexts that have just a filename, start line and column and end line and column.

  /// If a SourceContext has a DocumentWithPrecomputedLineNumbers as its Document, then it should have 0 as its StartPos

  /// and 1 as its EndPos because those are used here to decide what to return.

  /// </summary>

  public class DocumentWithPrecomputedLineNumbers : Document {

    private int startLine, startCol, endLine, endCol;

    public DocumentWithPrecomputedLineNumbers(string/*!*/ filename, int startLine, int startCol, int endLine, int endCol) {

      this.Name = filename;

      this.startLine = startLine;

      this.startCol = startCol;

      this.endLine = endLine;

      this.endCol = endCol;

    }

    public override int GetColumn (int offset) { return offset == 0 ? this.startCol : this.endCol; }

    public override int GetLine (int offset) { return offset == 0 ? this.startLine : this.endLine; }

  }

#endif

#if UseSingularityPDB

  internal class PdbDocument : Document {

    internal PdbDocument(PdbLines lines) {

      this.Name = lines.file.name;

      this.lines = lines;

    }

    PdbLines lines;

    public override int GetColumn(int position) {

      PdbLine line = this.lines.lines[position/2];

      if (position%2 == 0)

        return line.colBegin;

      else

        return line.colEnd;

    }

    public override int GetLine(int position) {

      PdbLine line = this.lines.lines[position/2];

      return (int)line.line;

    }

  }

#elif !ROTOR

  internal class UnmanagedDocument: Document{

    internal UnmanagedDocument(IntPtr ptrToISymUnmanagedDocument){

      //^ base();

      ISymUnmanagedDocument idoc = 

        (ISymUnmanagedDocument)System.Runtime.InteropServices.Marshal.GetTypedObjectForIUnknown(ptrToISymUnmanagedDocument, typeof(ISymUnmanagedDocument));

      if (idoc != null){

        try{

#if !FxCop

          idoc.GetDocumentType(out this.DocumentType);

          idoc.GetLanguage(out this.Language);

          idoc.GetLanguageVendor(out this.LanguageVendor);

#endif

          uint capacity = 1024;

          uint len = 0;

          char[] buffer = new char[capacity];

          while (capacity >= 1024){

            idoc.GetURL(capacity, out len, buffer);

            if (len < capacity) break;

            capacity += 1024;

            buffer = new char[capacity];

          }

          if (len > 0)

            this.Name = new String(buffer, 0, (int)len-1);

        }finally{

          System.Runtime.InteropServices.Marshal.ReleaseComObject(idoc);

        }

      }

#if !FxCop

      this.LineNumber = -1;

      this.Text = null;

#endif

    }



    private Int32List/*!*/ lineList = new Int32List();

    private Int32List/*!*/ columnList = new Int32List();

#if !FxCop

    public override int GetLine(int offset){

      return this.lineList[offset];

    }

    public override int GetColumn(int offset){

      return this.columnList[offset];

    }

    public override void GetOffsets(int startLine, int startColumn, int endLine, int endColumn, out int startCol, out int endCol){

      int i = UnmanagedDocument.BinarySearch(this.lineList, startLine);

      Int32List columnList = this.columnList;

      startCol = 0;

      for (int j = i, n = columnList.Count; j < n; j++){

        if (columnList[j] >= startColumn){ startCol = j; break;}

      }

      endCol = 0;

      i = UnmanagedDocument.BinarySearch(this.lineList, endLine);

      for (int j = i, n = columnList.Count; j < n; j++){

        if (columnList[j] >= endColumn){ endCol = j; break;}

      }

    }

    private static int BinarySearch(Int32List/*!*/ list, int value){

      int mid = 0;

      int low = 0; 

      int high = list.Count-1;

      while (low < high){

        mid = low + (high-low)/2;

        if (list[mid] <= value){

          if (list[mid+1] > value)

            return mid;

          else

            low = mid + 1;

        }else

          high = mid;

      }

      return low;

    }

    public override void InsertOrDeleteLines(int offset, int lineCount){

      Debug.Assert(false); //Caller should not be modifying an umanaged document

    }

#endif

    internal int GetOffset(uint line, uint column){

      this.lineList.Add((int)line);

      this.columnList.Add((int)column);

      return this.lineList.Count-1;

    }

  }

#endif // !ROTOR

#if FxCop

  class Document{

    internal string Name;

  }

  public struct SourceContext{ 

    private string name;

    private int startLine;

    private int endLine;

    private int startColumn;

    private int endColumn;

    internal SourceContext(string name, uint startLine, uint endLine, uint startColumn, uint endColumn){  

      this.name = name;

      checked {

        this.startLine = (int)startLine;

        this.endLine = (int)endLine;

        this.startColumn = (int)startColumn;

        this.endColumn = (int)endColumn;

      }    

    }

    public string FileName{

      get{return this.name;}

    }

    public int StartLine{

      get{return this.startLine;}

    }

    public int EndLine{

      get{return this.endLine;}

    }

    public int StartColumn{

      get{return this.startColumn;}

    }

    public int EndColumn{

      get{return this.endColumn;}

    }

  }

#else

  /// <summary>

  /// Records a location within a source document that corresponds to an Abstract Syntax Tree node.

  /// </summary>

  public struct SourceContext{

    /// <summary>The source document within which the AST node is located. Null if the node is not derived from a source document.</summary>

    public Document Document;

    /// <summary>

    /// The zero based index of the first character beyond  the last character in the source document that corresponds to the AST node.

    /// </summary>

    public int EndPos;

    /// <summary>

    /// The zero based index of the first character in the source document that corresponds to the AST node.

    /// </summary>

    public int StartPos;

    public SourceContext(Document document)

      : this(document, 0, document == null ? 0 : (document.Text == null ? 0 : document.Text.Length)){

    }

    public SourceContext(Document document, int startPos, int endPos){

      this.Document = document;

      this.StartPos = startPos;

      this.EndPos = endPos;

    }

    public SourceContext(Document/*!*/ document, 

      int startLine, int startColumn, int endLine, int endColumn){

      this.Document = document;

      this.Document.GetOffsets(startLine, startColumn, endLine, endColumn, out this.StartPos, out this.EndPos);

    }

    /// <summary>

    /// The number (counting from Document.LineNumber) of the line containing the first character in the source document that corresponds to the AST node.

    /// </summary>

    public int StartLine{

      get{ 

        if (this.Document == null) return 0;

        return this.Document.GetLine(this.StartPos); 

      }

    }

    /// <summary>

    /// The number (counting from one) of the line column containing the first character in the source document that corresponds to the AST node.

    /// </summary>

    public int StartColumn{

      get{ 

        if (this.Document == null) return 0;

        return this.Document.GetColumn(this.StartPos); 

      }

    }

    /// <summary>

    /// The number (counting from Document.LineNumber) of the line containing the first character beyond the last character in the source document that corresponds to the AST node.

    /// </summary>

    public int EndLine{

      get{ 

#if UseSingularityPDB

        if (this.Document == null || (this.Document.Text == null && !(this.Document is PdbDocument))) return 0;

#elif !ROTOR

        if (this.Document == null || (this.Document.Text == null && !(this.Document is UnmanagedDocument))) return 0;

#else

        if (this.Document == null || this.Document.Text == null) return 0;

#endif

        if (this.Document.Text != null && this.EndPos >= this.Document.Text.Length) this.EndPos = this.Document.Text.Length;

        return this.Document.GetLine(this.EndPos); 

      }

    }

    /// <summary>

    /// The number (counting from one) of the line column containing first character beyond the last character in the source document that corresponds to the AST node.

    /// </summary>

    public int EndColumn{

      get{ 

#if UseSingularityPDB

        if (this.Document == null || (this.Document.Text == null && !(this.Document is PdbDocument))) return 0;

#elif !ROTOR

        if (this.Document == null || (this.Document.Text == null && !(this.Document is UnmanagedDocument))) return 0;

#else

        if (this.Document == null || this.Document.Text == null) return 0;

#endif

        if (this.Document.Text != null && this.EndPos >= this.Document.Text.Length) this.EndPos = this.Document.Text.Length;

        return this.Document.GetColumn(this.EndPos); 

      }

    }

    /// <summary>

    /// Returns true if the line and column is greater than or equal the position of the first character 

    /// and less than or equal to the position of the last character

    /// of the source document that corresponds to the AST node.

    /// </summary>

    /// <param name="line">A line number(counting from Document.LineNumber)</param>

    /// <param name="column">A column number (counting from one)</param>

    /// <returns></returns>

    public bool Encloses(int line, int column){

      if (line < this.StartLine || line > this.EndLine) return false;

      if (line == this.StartLine) return column >= this.StartColumn && (column <= this.EndColumn || line < this.EndLine);

      if (line == this.EndLine) return column <= this.EndColumn;

      return true;

    }

    public bool Encloses(SourceContext sourceContext){

      return this.StartPos <= sourceContext.StartPos && this.EndPos >= sourceContext.EndPos && this.EndPos > sourceContext.StartPos;

    }

    /// <summary>

    /// The substring of the source document that corresponds to the AST node.

    /// </summary>

    public string SourceText{

      get{

        if (this.Document == null) return null;

        return this.Document.Substring(this.StartPos, this.EndPos-this.StartPos);

      }

    }

  }

#endif

#if !MinimalReader

  public struct SourceChange{

    public SourceContext SourceContext;

    public string ChangedText;

  }

  /// <summary>

  /// Allows a compilation to output progress messages and to query if cancellation was requested.

  /// </summary>

  public class CompilerSite{

    public virtual void OutputMessage(string message){

    }

    public virtual bool ShouldCancel{

      get{

        return false;

      }

    }

  }

#endif

#if !NoWriter

  public enum PlatformType{notSpecified, v1, v11, v2, cli1}

  public class CompilerOptions: System.CodeDom.Compiler.CompilerParameters{

    public StringCollection AliasesForReferencedAssemblies;

    public ModuleKindFlags ModuleKind = ModuleKindFlags.ConsoleApplication;

    public bool EmitManifest = true;

    public StringList DefinedPreProcessorSymbols;

    public string XMLDocFileName;

    public string RecursiveWildcard;

    public StringList ReferencedModules;

    public string Win32Icon;

#if !WHIDBEY

    private StringCollection embeddedResources = new StringCollection();

    public StringCollection EmbeddedResources{

      get{return this.embeddedResources;}

    }

    private StringCollection linkedResources = new StringCollection();

    public StringCollection LinkedResources{

      get{return this.linkedResources;}

    }

#endif

#if VS7

    private System.Security.Policy.Evidence evidence;

    public System.Security.Policy.Evidence Evidence{

      get{return this.evidence;}

      set{this.evidence = value;}

    }

#endif

    public bool PDBOnly;

    public bool Optimize;

    public bool IncrementalCompile;

    public Int32List SuppressedWarnings;

    public bool CheckedArithmetic;

    public bool AllowUnsafeCode;

    public bool DisplayCommandLineHelp;

    public bool SuppressLogo;

    public long BaseAddress; //TODO: default value

    public string BugReportFileName;

    public object CodePage; //must be an int if not null

    public bool EncodeOutputInUTF8;

    public bool FullyQualifyPaths;

    public int FileAlignment;

    public bool NoStandardLibrary;

    public StringList AdditionalSearchPaths;

    public bool HeuristicReferenceResolution;

    public string RootNamespace;

    public bool CompileAndExecute;

    public object UserLocaleId; //must be an int if not null

    public string StandardLibraryLocation;

    public PlatformType TargetPlatform; //TODO: rename this to TargetRuntime

#if !MinimalReader

    public ProcessorType TargetProcessor;

#endif

    public string TargetPlatformLocation;

    public string AssemblyKeyFile;

    public string AssemblyKeyName;

    public bool DelaySign;

    public TargetInformation TargetInformation;

    public Int32List SpecificWarningsToTreatAsErrors;

    public Int32List SpecificWarningsNotToTreatAsErrors;

    public string OutputPath;

    public string ExplicitOutputExtension;

    public AppDomain TargetAppDomain;

    public bool MayLockFiles;

    public string ShadowedAssembly;

    public bool UseStandardConfigFile;

#if !MinimalReader

    public CompilerSite Site;

#endif

#if ExtendedRuntime

    /// <summary>

    /// True if the source code for the assembly specify only contracts.

    /// </summary>

    public bool IsContractAssembly;

    /// <summary>

    /// Do not emit run-time checks for requires clauses of non-externally-accessible methods, assert statements, loop invariants, and ensures clauses.

    /// </summary>

    public bool DisableInternalChecks;

    /// <summary>

    /// Do not emit run-time checks for assume statements.

    /// </summary>

    public bool DisableAssumeChecks;

    /// <summary>

    /// Do not emit run-time checks for requires clauses of externally accessible methods.

    /// Do not emit run-time checks that enforce checked exception policy.

    /// </summary>

    public bool DisableDefensiveChecks;

    /// <summary>

    /// Disable the guarded classes feature, which integrates run-time enforcement of object invariants, ownership, and safe concurrency.

    /// </summary>

    public bool DisableGuardedClassesChecks;

    public bool DisableInternalContractsMetadata;

    public bool DisablePublicContractsMetadata;

    /// <summary>

    /// Disable the runtime test against null on non-null typed parameters on public methods

    /// </summary>

    public bool DisableNullParameterValidation;

    public virtual bool LoadDebugSymbolsForReferencedAssemblies {

      get { return false; } 

    }



    /// <summary>

    /// If set, the compiler will only parse and then emit an xml file with detailed source contexts 

    /// about what is parsed.

    /// </summary>

    public bool EmitSourceContextsOnly = false;



#endif

    public CompilerOptions(){

    }

    public CompilerOptions(CompilerOptions source){

      if (source == null){Debug.Assert(false); return;}

      this.AdditionalSearchPaths = source.AdditionalSearchPaths; //REVIEW: clone the list?

      this.AliasesForReferencedAssemblies = source.AliasesForReferencedAssemblies;

      this.AllowUnsafeCode = source.AllowUnsafeCode;

      this.AssemblyKeyFile = source.AssemblyKeyFile;

      this.AssemblyKeyName = source.AssemblyKeyName;

      this.BaseAddress = source.BaseAddress;

      this.BugReportFileName = source.BugReportFileName;

      this.CheckedArithmetic = source.CheckedArithmetic;

      this.CodePage = source.CodePage;

      this.CompileAndExecute = source.CompileAndExecute;

      this.CompilerOptions = source.CompilerOptions;

      this.DefinedPreProcessorSymbols = source.DefinedPreProcessorSymbols;

      this.DelaySign = source.DelaySign;

#if ExtendedRuntime

      this.DisableAssumeChecks = source.DisableAssumeChecks;

      this.DisableDefensiveChecks = source.DisableDefensiveChecks;

      this.DisableGuardedClassesChecks = source.DisableGuardedClassesChecks;

      this.DisableInternalChecks = source.DisableInternalChecks;

      this.DisableInternalContractsMetadata = source.DisableInternalContractsMetadata;

      this.DisablePublicContractsMetadata = source.DisablePublicContractsMetadata;

#endif

      this.DisplayCommandLineHelp = source.DisplayCommandLineHelp;

      if (source.EmbeddedResources != null)

        foreach (string s in source.EmbeddedResources) this.EmbeddedResources.Add(s);

      this.EmitManifest = source.EmitManifest;

      this.EncodeOutputInUTF8 = source.EncodeOutputInUTF8;

      this.Evidence = source.Evidence;

      this.ExplicitOutputExtension = source.ExplicitOutputExtension;

      this.FileAlignment = source.FileAlignment;

      this.FullyQualifyPaths = source.FullyQualifyPaths;

      this.GenerateExecutable = source.GenerateExecutable;

      this.GenerateInMemory = source.GenerateInMemory;

      this.HeuristicReferenceResolution = source.HeuristicReferenceResolution;

      this.IncludeDebugInformation = source.IncludeDebugInformation;

      this.IncrementalCompile = source.IncrementalCompile;

#if ExtendedRuntime

      this.IsContractAssembly = source.IsContractAssembly;

#endif

      if (source.LinkedResources != null)

        foreach (string s in source.LinkedResources) this.LinkedResources.Add(s);

      this.MainClass = source.MainClass;

      this.MayLockFiles = source.MayLockFiles;

      this.ModuleKind = source.ModuleKind;

      this.NoStandardLibrary = source.NoStandardLibrary;

      this.Optimize = source.Optimize;

      this.OutputAssembly = source.OutputAssembly;

      this.OutputPath = source.OutputPath;

      this.PDBOnly = source.PDBOnly;

      this.RecursiveWildcard = source.RecursiveWildcard;

      if (source.ReferencedAssemblies != null)

        foreach (string s in source.ReferencedAssemblies) this.ReferencedAssemblies.Add(s);

      this.ReferencedModules = source.ReferencedModules;

      this.RootNamespace = source.RootNamespace;

      this.ShadowedAssembly = source.ShadowedAssembly;

      this.SpecificWarningsToTreatAsErrors = source.SpecificWarningsToTreatAsErrors;

      this.StandardLibraryLocation = source.StandardLibraryLocation;

      this.SuppressLogo = source.SuppressLogo;

      this.SuppressedWarnings = source.SuppressedWarnings;

      this.TargetAppDomain = source.TargetAppDomain;

      this.TargetInformation = source.TargetInformation;

      this.TargetPlatform = source.TargetPlatform;

      this.TargetPlatformLocation = source.TargetPlatformLocation;

      this.TreatWarningsAsErrors = source.TreatWarningsAsErrors;

      this.UserLocaleId = source.UserLocaleId;

      this.UserToken = source.UserToken;

      this.WarningLevel = source.WarningLevel;

      this.Win32Icon = source.Win32Icon;

      this.Win32Resource = source.Win32Resource;

      this.XMLDocFileName = source.XMLDocFileName;

    }

    public virtual string GetOptionHelp(){

      return null;

    }

    public virtual CompilerOptions Clone() {

      return (CompilerOptions)this.MemberwiseClone();

    }

  }

#endif

  public sealed class MarshallingInformation{

    private string @class;

    private string cookie;

    private int elementSize;

    private NativeType elementType;

    private NativeType nativeType;

    private int numberOfElements;

    private int paramIndex;

    private int size;

    public MarshallingInformation Clone(){

      return (MarshallingInformation)base.MemberwiseClone();

    }

    public string Class{

      get{return this.@class;}

      set{this.@class = value;}

    }

    public string Cookie{

      get{return this.cookie;}

      set{this.cookie = value;}

    }

    public int ElementSize{

      get{return this.elementSize;}

      set{this.elementSize = value;}

    }

    public NativeType ElementType{

      get{return this.elementType;}

      set{this.elementType = value;}

    }

    public NativeType NativeType{

      get{return this.nativeType;}

      set{this.nativeType = value;}

    }

    public int NumberOfElements{

      get{return this.numberOfElements;}

      set{this.numberOfElements = value;}

    }

    public int ParamIndex{

      get{return this.paramIndex;}

      set{this.paramIndex = value;}

    }

    public int Size{

      get{return this.size;}

      set{this.size = value;}

    }

  }

#if !NoWriter

  public struct TargetInformation{

    public string Company;

    public string Configuration;

    public string Copyright;

    public string Culture;

    public string Description;

    public string Product;

    public string ProductVersion;

    public string Title;

    public string Trademark;

    public string Version;

  }

#endif

  public enum NativeType{

    Bool       = 0x2,      // 4 byte boolean value (true != 0, false == 0)

    I1         = 0x3,      // 1 byte signed value

    U1         = 0x4,      // 1 byte unsigned value

    I2         = 0x5,      // 2 byte signed value

    U2         = 0x6,      // 2 byte unsigned value

    I4         = 0x7,      // 4 byte signed value

    U4         = 0x8,      // 4 byte unsigned value

    I8         = 0x9,      // 8 byte signed value

    U8         = 0xa,      // 8 byte unsigned value

    R4         = 0xb,      // 4 byte floating point

    R8         = 0xc,      // 8 byte floating point

    Currency   = 0xf,      // A currency

    BStr       = 0x13,    // OLE Unicode BSTR

    LPStr      = 0x14,    // Ptr to SBCS string

    LPWStr     = 0x15,    // Ptr to Unicode string

    LPTStr     = 0x16,    // Ptr to OS preferred (SBCS/Unicode) string

    ByValTStr  = 0x17,    // OS preferred (SBCS/Unicode) inline string (only valid in structs)

    IUnknown   = 0x19,    // COM IUnknown pointer. 

    IDispatch  = 0x1a,    // COM IDispatch pointer

    Struct     = 0x1b,    // Structure

    Interface  = 0x1c,    // COM interface

    SafeArray  = 0x1d,    // OLE SafeArray

    ByValArray = 0x1e,    // Array of fixed size (only valid in structs)

    SysInt     = 0x1f,    // Hardware natural sized signed integer

    SysUInt    = 0x20,     

    VBByRefStr = 0x22,     

    AnsiBStr   = 0x23,    // OLE BSTR containing SBCS characters

    TBStr      = 0x24,    // Ptr to OS preferred (SBCS/Unicode) BSTR

    VariantBool = 0x25,    // OLE defined BOOLEAN (2 bytes, true == -1, false == 0)

    FunctionPtr = 0x26,    // Function pointer

    AsAny      = 0x28,    // Paired with Object type and does runtime marshalling determination

    LPArray    = 0x2a,    // C style array

    LPStruct   = 0x2b,    // Pointer to a structure

    CustomMarshaler = 0x2c, // Native type supplied by custom code   

    Error      = 0x2d,

    NotSpecified = 0x50,

  }

  ///0-: Common

  ///1000-: HScript

  ///2000-: EcmaScript

  ///3000-: Zonnon

  ///4000-: Comega

  ///5000-: X++

  ///6000-: Spec#

  ///7000-: Sing#

  ///8000-: Xaml

  ///9000-: C/AL

  ///For your range contact hermanv@microsoft.com

  public enum NodeType {

    //Dummy

    Undefined = 0,



    //IL instruction node tags

    Add,

    Add_Ovf,

    Add_Ovf_Un,

    And,

    Arglist,

    Box,

    Branch,

    Call,

    Calli,

    Callvirt,

    Castclass,

    Ceq,

    Cgt,

    Cgt_Un,

    Ckfinite,

    Clt,

    Clt_Un,

    Conv_I,

    Conv_I1,

    Conv_I2,

    Conv_I4,

    Conv_I8,

    Conv_Ovf_I,

    Conv_Ovf_I_Un,

    Conv_Ovf_I1,

    Conv_Ovf_I1_Un,

    Conv_Ovf_I2,

    Conv_Ovf_I2_Un,

    Conv_Ovf_I4,

    Conv_Ovf_I4_Un,

    Conv_Ovf_I8,

    Conv_Ovf_I8_Un,

    Conv_Ovf_U,

    Conv_Ovf_U_Un,

    Conv_Ovf_U1,

    Conv_Ovf_U1_Un,

    Conv_Ovf_U2,

    Conv_Ovf_U2_Un,

    Conv_Ovf_U4,

    Conv_Ovf_U4_Un,

    Conv_Ovf_U8,

    Conv_Ovf_U8_Un,

    Conv_R_Un,

    Conv_R4,

    Conv_R8,

    Conv_U,

    Conv_U1,

    Conv_U2,

    Conv_U4,

    Conv_U8,

    Cpblk,

    DebugBreak,

    Div,

    Div_Un,

    Dup,

    EndFilter,

    EndFinally,

    ExceptionHandler,

    Initblk,

    Isinst,

    Jmp,

    Ldftn,

    Ldlen,

    Ldtoken,

    Ldvirtftn,

    Localloc,

    Mkrefany,

    Mul,

    Mul_Ovf,

    Mul_Ovf_Un,

    Neg,

    Nop,

    Not,

    Or,

    Pop,

    ReadOnlyAddressOf,

    Refanytype,

    Refanyval,

    Rem,

    Rem_Un,

    Rethrow,

    Shl,

    Shr,

    Shr_Un,

    Sizeof,

    SkipCheck,

    Sub,

    Sub_Ovf,

    Sub_Ovf_Un,

    SwitchInstruction,

    Throw,

    Unbox,

    UnboxAny,

    Xor,



    //AST tags that are relevant to the binary reader

    AddressDereference,

    AddressOf,

    AssignmentStatement,

    Block,

    Catch,

    Construct,

    ConstructArray,

    Eq,

    ExpressionStatement,

    FaultHandler,

    Filter,

    Finally,

    Ge,

    Gt,

    Identifier,

    Indexer,

    Instruction,

    InterfaceExpression,

    Le,

    Literal,

    LogicalNot,

    Lt,

    MemberBinding,

    NamedArgument,

    Namespace,

    Ne,

    Return,

    This,

    Try,



    //Metadata node tags

    ArrayType,

    @Assembly,

    AssemblyReference,

    Attribute,

    Class,

    ClassParameter,

    DelegateNode,

    EnumNode,

    Event,

    Field,

    FunctionPointer,

    InstanceInitializer,

    Interface,

    Local,

    Method,

    Module,

    ModuleReference,

    OptionalModifier,

    Parameter,

    Pointer,

    Property,

    Reference,

    RequiredModifier,

    SecurityAttribute,

    StaticInitializer,

    Struct,

    TypeParameter,



#if !MinimalReader

    // The following NodeType definitions are not required

    // for examining assembly metadata directly from binaries



    //Serialization tags used for values that are not leaf nodes.

    Array,

    BlockReference,

    CompilationParameters,

    Document,

    EndOfRecord,

    Expression,

    Guid,

    List,

    MarshallingInformation,

    Member,

    MemberReference,

    MissingBlockReference,

    MissingExpression,

    MissingMemberReference,

    String,

    StringDictionary,

    TypeNode,

    Uri,

    XmlNode,



    //Source-based AST node tags

    AddEventHandler,

    AliasDefinition,

    AnonymousNestedFunction,

    ApplyToAll,

    ArglistArgumentExpression,

    ArglistExpression,

    ArrayTypeExpression,

    As,

    Assertion,

    AssignmentExpression,

    Assumption,

    Base,

#endif

#if FxCop

    BlockExpression,

    StackVariable,

#endif

#if !MinimalReader

    BlockExpression,

    BoxedTypeExpression,

    ClassExpression,

    CoerceTuple,

    CollectionEnumerator,

    Comma,

    Compilation,

    CompilationUnit,

    CompilationUnitSnippet,

    Conditional,

    ConstructDelegate,

    ConstructFlexArray,

    ConstructIterator,

    ConstructTuple,

    Continue,

    CopyReference,

    CurrentClosure,

    Decrement,

    DefaultValue,

    DoWhile,

    Exit,

    ExplicitCoercion,

    ExpressionSnippet,

    FieldInitializerBlock,

    Fixed,

    FlexArrayTypeExpression,

    For,

    ForEach,

    FunctionDeclaration,

    FunctionTypeExpression,

    Goto,

    GotoCase,

    If,

    ImplicitThis,

    Increment,

    InvariantTypeExpression,

    Is,

    LabeledStatement,

    LocalDeclaration,

    LocalDeclarationsStatement,

    Lock,

    LogicalAnd,

    LogicalOr,

    LRExpression,

    MethodCall,

    NameBinding,

    NonEmptyStreamTypeExpression,

    NonNullableTypeExpression,

    NonNullTypeExpression,

    NullableTypeExpression,

    NullCoalescingExpression,

    OutAddress,

    Parentheses,

    PointerTypeExpression,

    PostfixExpression,

    PrefixExpression,

    QualifiedIdentifer,

    RefAddress,

    ReferenceTypeExpression,

    RefTypeExpression,

    RefValueExpression,

    RemoveEventHandler,

    Repeat,

    ResourceUse,

    SetterValue,

    StackAlloc,

    StatementSnippet,

    StreamTypeExpression,

    Switch,

    SwitchCase,

    SwitchCaseBottom,

    TemplateInstance,

    TupleTypeExpression,

    TypeExpression,

    TypeIntersectionExpression,

    TypeMemberSnippet,

    Typeof,

    TypeReference,

    Typeswitch,

    TypeswitchCase,

    TypeUnionExpression,

    UnaryPlus,

    UsedNamespace,

    VariableDeclaration,

    While,

    Yield,



    //Extended metadata node tags

    ConstrainedType,

    TupleType,

    TypeAlias,

    TypeIntersection,

    TypeUnion,

    

    //Query node tags

    Composition,

    QueryAggregate,

    QueryAlias,

    QueryAll,

    QueryAny,

    QueryAxis,

    QueryCommit,

    QueryContext,

    QueryDelete,

    QueryDifference,

    QueryDistinct,

    QueryExists,

    QueryFilter,

    QueryGeneratedType,

    QueryGroupBy,

    QueryInsert,

    QueryIntersection,

    QueryIterator,

    QueryJoin,

    QueryLimit,

    QueryOrderBy,

    QueryOrderItem,

    QueryPosition,

    QueryProject,

    QueryQuantifiedExpression,

    QueryRollback,

    QuerySelect,

    QuerySingleton,

    QueryTransact,

    QueryTypeFilter,

    QueryUnion,

    QueryUpdate,

    QueryYielder,



    //Contract node tags

    Acquire,

    Comprehension,

    ComprehensionBinding,

    Ensures,

    EnsuresExceptional,

    EnsuresNormal,

    Iff,

    Implies,

    Invariant,

    LogicalEqual,

    LogicalImply,

    Maplet,

    MethodContract,    

    Modelfield,

    ModelfieldContract,

    OldExpression,

    Range,

    Read,

    Requires,

    RequiresOtherwise,

    RequiresPlain,

    ReturnValue,

    TypeContract,

    Write,

  

    //Node tags for explicit modifiers in front-end

    OptionalModifierTypeExpression,

    RequiredModifierTypeExpression,



    //Temporary node tags

    Count, 

    Exists,

    ExistsUnique,

    Forall,

    Max,

    Min,

    Product,

    Sum,

    Quantifier,    

#endif  // MinimalReader

  }

  [Flags]

  public enum AssemblyFlags{

    None                       = 0x0000,

    PublicKey                  = 0x0001,

    Library                    = 0x0002,

    Platform                   = 0x0004,

    NowPlatform                = 0x0006,

    SideBySideCompatible       = 0x0000,

    NonSideBySideCompatible    = 0x0010,

    NonSideBySideProcess       = 0x0020,

    NonSideBySideMachine       = 0x0030,

    CompatibilityMask          = 0x00F0,

    Retargetable               = 0x0100,

    DisableJITcompileOptimizer = 0x4000,

    EnableJITcompileTracking   = 0x8000

  }

  public enum AssemblyHashAlgorithm{

    None = 0x0000,

    MD5  = 0x8003,

    SHA1 = 0x8004

  }

  [Flags]

  public enum CallingConventionFlags{

    Default      = 0x0,

    C            = 0x1,

    StandardCall = 0x2,

    ThisCall     = 0x3,

    FastCall     = 0x4,

    VarArg       = 0x5,

    ArgumentConvention = 0x7,

    Generic      = 0x10,

    HasThis      = 0x20,

    ExplicitThis = 0x40

  }

  [Flags]

  public enum EventFlags{

    None          = 0x0000,

    SpecialName   = 0x0200,

    ReservedMask  = 0x0400,

    RTSpecialName = 0x0400,

#if !MinimalReader

    Extend   =   MethodFlags.Extend, // used for languages with type extensions, e.g. Sing#

#endif

  }

  [Flags]

  public enum FieldFlags{

    None                = 0x0000,

    FieldAccessMask     = 0x0007,

    CompilerControlled  = 0x0000,

    Private             = 0x0001,

    FamANDAssem         = 0x0002,

    Assembly            = 0x0003,

    Family              = 0x0004,

    FamORAssem          = 0x0005,

    Public              = 0x0006,

    Static              = 0x0010,

    InitOnly            = 0x0020,

    Literal             = 0x0040,

    NotSerialized       = 0x0080,

    SpecialName         = 0x0200,

    PinvokeImpl         = 0x2000,

    ReservedMask        = 0x9500,

    RTSpecialName       = 0x0400,

    HasFieldMarshal     = 0x1000,

    HasDefault          = 0x8000,

    HasFieldRVA         = 0x0100,

  }

  [Flags]

  public enum FileFlags{

    ContainsMetaData   = 0x0000,

    ContainsNoMetaData = 0x0001

  }

  [Flags]

  public enum TypeParameterFlags{

    NonVariant = 0x0000,

    Covariant = 0x0001,

    Contravariant = 0x0002,

    VarianceMask = 0x0003,

    NoSpecialConstraint = 0x0000,

    ReferenceTypeConstraint = 0x0004,

    ValueTypeConstraint = 0x0008,

    DefaultConstructorConstraint = 0x0010,

    SpecialConstraintMask = 0x001C,

  }

  [Flags]

  public enum MethodImplFlags{

    CodeTypeMask = 0x0003,

    IL = 0x0000,

    Native = 0x0001,

    OPTIL = 0x0002,

    Runtime = 0x0003,

    ManagedMask = 0x0004,

    Unmanaged = 0x0004,

    Managed = 0x0000,

    ForwardRef = 0x0010,

    PreserveSig = 0x0080,

    InternalCall = 0x1000,

    Synchronized = 0x0020,

    NoInlining = 0x0008,

#if !MinimalReader

    MaxMethodImplVal = 0xffff

#endif

  }

  [Flags]

  public enum MethodFlags{

    MethodAccessMask = 0x0007,

    CompilerControlled = 0x0000,

    Private = 0x0001,

    FamANDAssem = 0x0002,

    Assembly = 0x0003,

    Family = 0x0004,

    FamORAssem = 0x0005,

    Public = 0x0006,

    Static = 0x0010,

    Final = 0x0020,

    Virtual = 0x0040,

    HideBySig = 0x0080,

    VtableLayoutMask = 0x0100,

    ReuseSlot = 0x0000,

    NewSlot = 0x0100,

    CheckAccessOnOverride = 0x0200,

    Abstract = 0x0400,

    SpecialName = 0x0800,

    PInvokeImpl = 0x2000,

    UnmanagedExport = 0xd000,

    ReservedMask = 0xd000,

    RTSpecialName = 0x1000,

    HasSecurity = 0x4000,

    RequireSecObject = 0x8000,

#if !MinimalReader

    Extend   =   0x01000000, // used for languages with type extensions, e.g. Sing#

#endif

  }

  public enum ModuleKindFlags{ //TODO: rename this to just ModuleKind

    ConsoleApplication,

    WindowsApplication,

    DynamicallyLinkedLibrary,

    ManifestResourceFile,

    UnmanagedDynamicallyLinkedLibrary

  }

  [Flags]

  public enum ParameterFlags{

    None = 0x0000,

    In = 0x0001,

    Out = 0x0002,

    Optional = 0x0010,

    ReservedMask = 0xf000,

    HasDefault = 0x1000,

    HasFieldMarshal = 0x2000

  }

  [Flags]

  public enum PEKindFlags{

    ILonly = 0x0001,

    Requires32bits = 0x0002,

    Requires64bits = 0x0004,

    AMD = 0x0008

  }

  [Flags]

  public enum PInvokeFlags{

    None = 0x0000,

    NoMangle = 0x0001,

    BestFitDisabled = 0x0020,

    BestFitEnabled = 0x0010,

    BestFitUseAsm = 0x0000,

    BestFitMask = 0x0030,

    CharSetMask = 0x0006,

    CharSetNotSpec = 0x0000,

    CharSetAns = 0x0002,

    CharSetUnicode = 0x0004,

    CharSetAuto = 0x0006,

    SupportsLastError = 0x0040,

    CallingConvMask = 0x0700,

    CallConvWinapi = 0x0100,

    CallConvCdecl = 0x0200,

    CallConvStdcall = 0x0300,

    CallConvThiscall = 0x0400,

    CallConvFastcall = 0x0500,

    ThrowOnUnmappableCharMask = 0x3000,

    ThrowOnUnmappableCharEnabled = 0x1000,

    ThrowOnUnmappableCharDisabled = 0x2000,

    ThrowOnUnmappableCharUseAsm = 0x0000

  }

  [Flags]

  public enum PropertyFlags{

    None          = 0x0000,

    SpecialName   = 0x0200,

    ReservedMask  = 0xf400,

    RTSpecialName = 0x0400,

#if !MinimalReader

    Extend   =   MethodFlags.Extend, // used for languages with type extensions, e.g. Sing#

#endif

  }

  public enum PESection{

    Text, 

    SData, 

    TLS

  };

#if !MinimalReader

  public enum ProcessorType{

    Any,

    x86,

    x64,

    Itanium,

  }

#endif

  [Flags]

  public enum TypeFlags{

    None              =   0x00000000,

    VisibilityMask    =   0x00000007,

    NotPublic         =   0x00000000, 

    Public            =   0x00000001,

    NestedPublic      =   0x00000002,

    NestedPrivate     =   0x00000003, 

    NestedFamily      =   0x00000004, 

    NestedAssembly    =   0x00000005,

    NestedFamANDAssem =   0x00000006,

    NestedFamORAssem  =   0x00000007,

    LayoutMask        =   0x00000018,

    AutoLayout        =   0x00000000,

    SequentialLayout  =   0x00000008,

    ExplicitLayout    =   0x00000010, 

    ClassSemanticsMask=   0x00000020,

    Class             =   0x00000000,

    Interface         =   0x00000020,

    LayoutOverridden  =   0x00000040,   // even AutoLayout can be explicit or implicit

    Abstract          =   0x00000080,

    Sealed            =   0x00000100,

    SpecialName       =   0x00000400,

    Import            =   0x00001000,

    Serializable      =   0x00002000,

    StringFormatMask  =   0x00030000,     

    AnsiClass         =   0x00000000,

    UnicodeClass      =   0x00010000,

    AutoClass         =   0x00020000, 

    BeforeFieldInit   =   0x00100000, 

    ReservedMask      =   0x00040800,

    RTSpecialName     =   0x00000800, 

    HasSecurity       =   0x00040000,

    Forwarder         =   0x00200000, //The type is a stub left behind for backwards compatibility. References to this type are forwarded to another type by the CLR.

#if !MinimalReader

    Extend            =   0x01000000,  // used for languages with type extensions, e.g. Sing#

#endif

}

  

  public sealed class TrivialHashtable{

    struct HashEntry {

      public int Key;

      public object Value;

    }



    private HashEntry[]/*!*/ entries;

    private int count;



    public TrivialHashtable(){

      this.entries = new HashEntry[16];

      //this.count = 0;

    }

    private TrivialHashtable(HashEntry[]/*!*/ entries, int count) {

      this.entries = entries;

      this.count = count;

    }

    public TrivialHashtable(int expectedEntries) {

      int initialSize = 16;

      expectedEntries <<= 1;

      while (initialSize < expectedEntries && initialSize > 0) initialSize <<= 1;

      if (initialSize < 0) initialSize = 16;

      this.entries = new HashEntry[initialSize];

      //this.count = 0;

    }

    public int Count{

      get{

        return this.count;

      }

    }

    private void Expand(){

      HashEntry[] oldEntries = this.entries;

      int n = oldEntries.Length;

      int m = n*2;

      if (m <= 0) return;

      HashEntry[] entries = new HashEntry[m];

      int count = 0;

      for (int i = 0; i < n; i++){

        int key = oldEntries[i].Key;

        if (key <= 0) continue; //No entry (0) or deleted entry (-1)

        object value = oldEntries[i].Value;

        Debug.Assert(value != null);

        int j = key & (m-1);

        int k = entries[j].Key;

        while (true){

          if (k == 0){

            entries[j].Value = value;

            entries[j].Key = key;

            count++;

            break;

          }

          j++; if (j >= m) j = 0;

          k = entries[j].Key;

        }

      }

      this.entries = entries;

      this.count = count;

    }

    public object this[int key]{

      get{

        if (key <= 0) throw new ArgumentException(ExceptionStrings.KeyNeedsToBeGreaterThanZero, "key");

        HashEntry[] entries = this.entries;

        int n = entries.Length;

        int i = key & (n-1);

        int k = entries[i].Key;

        object result = null;

        while (true){

          if (k == key){result = entries[i].Value; break;}

          if (k == 0) break;

          i++; if (i >= n) i = 0;

          k = entries[i].Key;

        }

        return result;

      }

      set{

        if (key <= 0) throw new ArgumentException(ExceptionStrings.KeyNeedsToBeGreaterThanZero, "key");

        HashEntry[] entries = this.entries;

        int n = entries.Length;

        int i = key & (n-1);

        int k = entries[i].Key;

        while(true){

          if (k == key || k == 0){

            entries[i].Value = value;

            if (k == 0){

              if (value == null){return;}

              entries[i].Key = key;

              if (++this.count > n/2) this.Expand();

              return;

            }

            if (value == null) entries[i].Key = -1;

            return;

          }

          i++; if (i >= n) i = 0;

          k = entries[i].Key;

        }

      }

    }

	public TrivialHashtable Clone(){

	  HashEntry[] clonedEntries = (HashEntry[]) this.entries.Clone();

      //^ assume clonedEntries != null;

      return new TrivialHashtable(clonedEntries, this.count);

	}

  }

#if !FxCop

  public

#endif  

  sealed class TrivialHashtableUsingWeakReferences{

    struct HashEntry {

      public int Key;

      public WeakReference Value;

    }



    private HashEntry[]/*!*/ entries;

    private int count;



    public TrivialHashtableUsingWeakReferences(){

      this.entries = new HashEntry[16];

      //this.count = 0;

    }

    private TrivialHashtableUsingWeakReferences(HashEntry[]/*!*/ entries, int count) {

      this.entries = entries;

      this.count = count;

    }

    public TrivialHashtableUsingWeakReferences(int expectedEntries) {

      int initialSize = 16;

      expectedEntries <<= 1;

      while (initialSize < expectedEntries && initialSize > 0) initialSize <<= 1;

      if (initialSize < 0) initialSize = 16;

      this.entries = new HashEntry[initialSize];

      //this.count = 0;

    }

    public int Count{

      get{

        return this.count;

      }

    }

    private void Expand(){

      HashEntry[] oldEntries = this.entries;

      int n = oldEntries.Length;

      int m = n*2;

      if (m <= 0) return;

      HashEntry[] entries = new HashEntry[m];

      int count = 0;

      for (int i = 0; i < n; i++){

        int key = oldEntries[i].Key;

        if (key <= 0) continue; //No entry (0) or deleted entry (-1)

        WeakReference value = oldEntries[i].Value;

        Debug.Assert(value != null);

        if (value == null || !value.IsAlive) continue; //Collected entry.

        int j = key & (m-1);

        int k = entries[j].Key;

        while (true){

          if (k == 0){

            entries[j].Value = value;

            entries[j].Key = key;

            count++;

            break;

          }

          j++; if (j >= m) j = 0;

          k = entries[j].Key;

        }

      }

      this.entries = entries;

      this.count = count;

    }

    private void Contract() {

      HashEntry[] oldEntries = this.entries;

      int n = oldEntries.Length;

      int m = n/2;

      if (m < 16) return;

      HashEntry[] entries = new HashEntry[m];

      int count = 0;

      for (int i = 0; i < n; i++) {

        int key = oldEntries[i].Key;

        if (key <= 0) continue; //No entry (0) or deleted entry (-1)

        WeakReference value = oldEntries[i].Value;

        Debug.Assert(value != null);

        if (value == null || !value.IsAlive) continue; //Collected entry.

        int j = key & (m-1);

        int k = entries[j].Key;

        while (true) {

          if (k == 0) {

            entries[j].Value = value;

            entries[j].Key = key;

            count++;

            break;

          }

          j++; if (j >= m) j = 0;

          k = entries[j].Key;

        }

      }

      this.entries = entries;

      this.count = count;

    }

    private void WeedOutCollectedEntries() {

      HashEntry[] oldEntries = this.entries;

      int n = oldEntries.Length;

      HashEntry[] entries = new HashEntry[n];

      int count = 0;

      for (int i = 0; i < n; i++) {

        int key = oldEntries[i].Key;

        if (key <= 0) continue; //No entry (0) or deleted entry (-1)

        WeakReference value = oldEntries[i].Value;

        Debug.Assert(value != null);

        if (value == null || !value.IsAlive) continue; //Collected entry.

        int j = key & (n-1);

        int k = entries[j].Key;

        while (true) {

          if (k == 0) {

            entries[j].Value = value;

            entries[j].Key = key;

            count++;

            break;

          }

          j++; if (j >= n) j = 0;

          k = entries[j].Key;

        }

      }

      this.entries = entries;

      this.count = count;

    }

    public object this[int key] {

      get{

        if (key <= 0) throw new ArgumentException(ExceptionStrings.KeyNeedsToBeGreaterThanZero, "key");

        HashEntry[] entries = this.entries;

        int n = entries.Length;

        int i = key & (n-1);

        int k = entries[i].Key;

        object result = null;

        while (true){

          if (k == key){

            WeakReference wref = entries[i].Value;

            if (wref == null) { Debug.Assert(false); return null; }

            result = wref.Target;

            if (result != null) return result;

            this.WeedOutCollectedEntries();

            while (this.count < n/4 && n > 16) { this.Contract(); n = this.entries.Length; }

            return null;

          }

          if (k == 0) break;

          i++; if (i >= n) i = 0;

          k = entries[i].Key;

        }

        return result;

      }

      set{

        if (key <= 0) throw new ArgumentException(ExceptionStrings.KeyNeedsToBeGreaterThanZero, "key");

        HashEntry[] entries = this.entries;

        int n = entries.Length;

        int i = key & (n-1);

        int k = entries[i].Key;

        while(true){

          if (k == key || k == 0) {

            if (value == null)

              entries[i].Value = null;

            else

              entries[i].Value = new WeakReference(value);

            if (k == 0) {

              if (value == null) return;

              entries[i].Key = key;

              if (++this.count > n/2) {

                this.Expand(); //Could decrease this.count because of collected entries being deleted

                while (this.count < n/4 && n > 16) { this.Contract(); n = this.entries.Length; }

              }

              return;

            }

            if (value == null) entries[i].Key = -1;

            return;

          } 

          i++; if (i >= n) i = 0;

          k = entries[i].Key;

        }

      }

    }

    public TrivialHashtableUsingWeakReferences Clone() {

	  HashEntry[] clonedEntries = (HashEntry[]) this.entries.Clone();

      //^ assume clonedEntries != null;

      return new TrivialHashtableUsingWeakReferences(clonedEntries, this.count);

	}

  }



  public interface IUniqueKey{

    int UniqueId{get;}

  }



  /// <summary>

  /// A node in an Abstract Syntax Tree.

  /// </summary>

  public abstract class Node : IUniqueKey{

#if !MinimalReader

    public bool IsErroneous;

#endif

    /// <summary>

    /// The region in the source code that contains the concrete syntax corresponding to this node in the Abstract Syntax Tree.

    /// </summary>

#if !FxCop

    public SourceContext SourceContext;

#else

    internal SourceContext sourceContext;

    public SourceContext SourceContext {

      get{return this.sourceContext;}

      internal set{this.sourceContext = value;}

    }

#endif

#if DEBUG && !MinimalReader

    public string DebugLabel; // useful for debugging.

#endif     

    protected Node(NodeType nodeType){

      this.NodeType = nodeType;

    }

    private NodeType nodeType;

    /// <summary>

    /// A scalar tag that identifies the concrete type of the node. This is provided to allow efficient type membership tests that 

    /// facilitate tree traversal.

    /// </summary>

    public NodeType NodeType{

      get{return this.nodeType;}

      set{this.nodeType = value;}

    }

    private static int uniqueKeyCounter;

    private int uniqueKey;

    /// <summary>

    /// An integer that uniquely identifies this node. This provides an efficient equality test to facilitate hashing.

    /// Do not override this.

    /// </summary>

    public virtual int UniqueKey{

      get{

        if (this.uniqueKey == 0){

        TryAgain:

          int c = Node.uniqueKeyCounter;

          int cp1 = c+17;

          if (cp1 <= 0) cp1 = 1000000;

          if (System.Threading.Interlocked.CompareExchange(ref Node.uniqueKeyCounter, cp1, c) != c) goto TryAgain;

          this.uniqueKey = cp1;

        }

        return this.uniqueKey;

      }

    }

    /// <summary>

    /// Makes a shallow copy of the node.

    /// </summary>

    /// <returns>A shallow copy of the node</returns>

    public virtual Node/*!*/ Clone() {

      Node result = (Node)this.MemberwiseClone();

      result.uniqueKey = 0;

      return result;

    }

#if !MinimalReader

    public virtual object GetVisitorFor(object/*!*/ callingVisitor, string/*!*/ visitorClassName) {

      if (callingVisitor == null || visitorClassName == null) { Debug.Fail(""); return null; }

      return Node.GetVisitorFor(this.GetType(), callingVisitor, visitorClassName);

    }

    private static Hashtable VisitorTypeFor; //contains weak references

    private static Object GetVisitorFor(System.Type/*!*/ nodeType, object/*!*/ callingVisitor, string/*!*/ visitorClassName) {

      if (nodeType == null || callingVisitor == null || visitorClassName == null){Debug.Fail(""); return null;}

      if (Node.VisitorTypeFor == null) Node.VisitorTypeFor = new Hashtable();

      string customVisitorClassName = visitorClassName;

      if (visitorClassName.IndexOf('.') < 0) customVisitorClassName = nodeType.Namespace + "." + visitorClassName;

      if (customVisitorClassName == callingVisitor.GetType().FullName){

        Debug.Assert(false); //This must be a bug, the calling visitor is the one that should handle the nodeType

        return null;

      }

      System.Reflection.AssemblyName visitorAssemblyName = null;

      System.Reflection.Assembly assembly = null;

      WeakReference wref = (WeakReference)Node.VisitorTypeFor[customVisitorClassName];

      Type visitorType = wref == null ? null : (System.Type)wref.Target;

      if (visitorType == typeof(object)) return null;

      string callerDirectory = null;

      if (visitorType == null){

        assembly = nodeType.Assembly;

        if (assembly == null) return null;

        visitorType = assembly.GetType(customVisitorClassName, false);

      }

      if (visitorType == null) {

        //^ assert assembly != null;

        if (assembly.Location == null) return null;

        callerDirectory = Path.GetDirectoryName(assembly.Location);

        visitorAssemblyName = new System.Reflection.AssemblyName();

        visitorAssemblyName.Name = "Visitors";

        visitorAssemblyName.CodeBase = "file:///" + Path.Combine(callerDirectory, "Visitors.dll");

        try {

          assembly = System.Reflection.Assembly.Load(visitorAssemblyName);

        } catch { }

        if (assembly != null)

          visitorType = assembly.GetType(customVisitorClassName, false);

        if (visitorType == null) {

          visitorAssemblyName.Name = customVisitorClassName;

          visitorAssemblyName.CodeBase = "file:///" + Path.Combine(callerDirectory, customVisitorClassName+".dll");

          try {

            assembly = System.Reflection.Assembly.Load(visitorAssemblyName);

          } catch { }

          if (assembly != null)

            visitorType = assembly.GetType(customVisitorClassName, false);

        }

      }

      if (visitorType == null){

        //Put fake entry into hashtable to short circuit future lookups

        visitorType = typeof(object);

        assembly = nodeType.Assembly;

      }

      if (assembly != null){ //Only happens if there was a cache miss

        lock(Node.VisitorTypeFor){

          Node.VisitorTypeFor[customVisitorClassName] = new WeakReference(visitorType);

        }

      }

      if (visitorType == typeof(object)) return null;

      try{

        return System.Activator.CreateInstance(visitorType, new object[]{callingVisitor});

      }catch{}

      return null;

    }

#endif

    int IUniqueKey.UniqueId { get { return this.UniqueKey; } }

#if MinimalReader

    // Return a constant value for IsNormalized in the binary-only

    // reader. This results in less code churn elsewhere.

    internal bool IsNormalized{get{return true;}}

#endif

  }

#if !MinimalReader

  public abstract class ErrorNode : Node{

    public int Code;

#if ExtendedRuntime

    public bool DoNotSuppress;

#endif

    public string[] MessageParameters;



    protected ErrorNode(int code, params string[] messageParameters)

      : base(NodeType.Undefined){

      this.Code = code;

      this.MessageParameters = messageParameters;

    }

    public virtual string GetErrorNumber(){

      return this.Code.ToString("0000");

    }

    public string GetMessage(){

      return this.GetMessage(null);

    }

#if ExtendedRuntime

    [return: Microsoft.Contracts.NotNull]

#endif

    public abstract string GetMessage(System.Globalization.CultureInfo culture);

    public virtual string GetMessage(string key, System.Resources.ResourceManager rm, System.Globalization.CultureInfo culture){

      if (rm == null || key == null) return null;

      string localizedString = rm.GetString(key, culture);

      if (localizedString == null) localizedString = key;

      string[] messageParameters = this.MessageParameters;

      if (messageParameters == null || messageParameters.Length == 0) return localizedString;

      return string.Format(localizedString, messageParameters);

    }

    public abstract int Severity{

      get;

    }

    public static int GetCountAtSeverity(ErrorNodeList errors, int minSeverity, int maxSeverity){

      if (errors == null) return 0;

      int n = 0;

      for (int i = 0; i < errors.Count; i++){

        ErrorNode e = errors[i];

        if (e == null)

          continue;

        int s = e.Severity;

        if (minSeverity <= s && s <= maxSeverity)

          n++;

      }

      return n;

    }

  }

  public class Expose : Statement{

    public Expression Instance;

    public Block Body;

    public bool IsLocal;

    public Expose(NodeType nodeType)

      : base(nodeType){

    }

  }

  public class Acquire : Statement{

    public bool ReadOnly;

    public Statement Target;

    public Expression Condition;

    public Expression ConditionFunction;

    public Block Body;

    public BlockScope ScopeForTemporaryVariable;

    public Acquire() : base(NodeType.Acquire) {

    }

  }

#endif

  public class Expression : Node{

    private TypeNode type;

#if FxCop

    internal int ILOffset;

#endif

#if !FxCop && ILOFFSETS

    public int ILOffset;

#endif

    public Expression(NodeType nodeType)

      : base(nodeType){

    }

    public Expression(NodeType nodeType, TypeNode type)

      : base(nodeType){

      this.type = type;

    }

    public virtual TypeNode Type{

      get{return this.type;}

      set{this.type = value;}

    }

  }

#if !MinimalReader

  public class ExpressionSnippet : Expression{

    public IParserFactory ParserFactory;



    public ExpressionSnippet()

      : base(NodeType.ExpressionSnippet){

    }

    public ExpressionSnippet(IParserFactory parserFactory, SourceContext sctx)

      : base(NodeType.ExpressionSnippet){

      this.ParserFactory = parserFactory;

      this.SourceContext = sctx;

    }

  }

#endif

  public class MemberBinding : Expression{

    private int alignment;

    private Member boundMember;

#if !MinimalReader

    public Expression BoundMemberExpression;

#endif

    private Expression targetObject;

    private bool @volatile;

    public MemberBinding()

      : base(NodeType.MemberBinding){

    }

    public MemberBinding(Expression targetObject, Member/*!*/ boundMember)

      : this(targetObject, boundMember, false, -1){

      if (boundMember is Field) this.Volatile = ((Field)boundMember).IsVolatile;

    }

#if !MinimalReader

    public MemberBinding(Expression targetObject, Member/*!*/ boundMember, Expression boundMemberExpression)

      : this(targetObject, boundMember, false, -1){

      if (boundMember is Field) this.Volatile = ((Field)boundMember).IsVolatile;

      this.BoundMemberExpression = boundMemberExpression;

    }

    public MemberBinding(Expression targetObject, Member/*!*/ boundMember, SourceContext sctx)

      : this(targetObject, boundMember, false, -1){

      if (boundMember is Field) this.Volatile = ((Field)boundMember).IsVolatile;

      this.SourceContext = sctx;

    }

    public MemberBinding(Expression targetObject, Member/*!*/ boundMember, SourceContext sctx, Expression boundMemberExpression)

      : this(targetObject, boundMember, false, -1){

      if (boundMember is Field) this.Volatile = ((Field)boundMember).IsVolatile;

      this.SourceContext = sctx;

      this.BoundMemberExpression = boundMemberExpression;

    }

#endif

    public MemberBinding(Expression targetObject, Member/*!*/ boundMember, bool @volatile, int alignment)

      : base(NodeType.MemberBinding){

      Debug.Assert(boundMember != null);

      this.alignment = alignment;

      this.boundMember = boundMember;

      this.targetObject = targetObject;

      this.@volatile = @volatile;

      switch(boundMember.NodeType){

        case NodeType.Field : this.Type = ((Field)boundMember).Type; break;

        case NodeType.Method : this.Type = ((Method)boundMember).ReturnType; break;

        case NodeType.Event : this.Type = ((Event)boundMember).HandlerType; break;

        default : this.Type = boundMember as TypeNode; break;

      }

    }

    public int Alignment{

      get{return this.alignment;}

      set{this.alignment = value;}

    }

    public Member BoundMember{

      get{return this.boundMember;}

      set{this.boundMember = value;}

    }

    public Expression TargetObject{

      get{return this.targetObject;}

      set{this.targetObject = value;}

    }

    public bool Volatile{

      get{return this.@volatile;}

      set{this.@volatile = value;}

    }

  }

  public class AddressDereference : Expression{

    private Expression address;

    private int alignment;

    private bool isVolatile; 

#if !MinimalReader

    public enum ExplicitOp { None=0, Star, Arrow }

    private ExplicitOp explicitOperation; // was explicit in source (* or ->)

#endif

    public AddressDereference()

      : base(NodeType.AddressDereference){

    }

    public AddressDereference(Expression address, TypeNode type)

      : this(address, type, false, -1){

    }

#if !MinimalReader

    public AddressDereference(Expression address, TypeNode type, SourceContext sctx)

      : this(address, type, false, -1, sctx){

    }

#endif

    public AddressDereference(Expression address, TypeNode type, bool isVolatile, int alignment)

      : base(NodeType.AddressDereference){

      this.address = address;

      this.alignment = alignment;

      this.Type = type;

      this.isVolatile = isVolatile;

    }

#if !MinimalReader

    public AddressDereference(Expression address, TypeNode type, bool Volatile, int alignment, SourceContext sctx)

      : base(NodeType.AddressDereference){

      this.address = address;

      this.alignment = alignment;

      this.Type = type;

      this.isVolatile = Volatile;

      this.SourceContext = sctx;

    }

#endif

    public Expression Address{

      get{return this.address;}

      set{this.address = value;}

    }

    public int Alignment{

      get{return this.alignment;}

      set{this.alignment = value;}

    }

    public bool Volatile{

      get{return this.isVolatile;}

      set{this.isVolatile = value;}

    }

#if !MinimalReader

    public bool Explicit{

      get{return this.explicitOperation != ExplicitOp.None;}

    }

    public ExplicitOp ExplicitOperator {

      get { return this.explicitOperation; }

      set { this.explicitOperation = value; }

    }

#endif

  }

  public class UnaryExpression : Expression{

    private Expression operand;

    public UnaryExpression()

      : base(NodeType.Nop){

    }

    public UnaryExpression(Expression operand, NodeType nodeType)

      : base(nodeType){

      this.Operand = operand;

    }

#if !MinimalReader

    public UnaryExpression(Expression operand, NodeType nodeType, SourceContext sctx)

      : base(nodeType){

      this.operand = operand;

      this.SourceContext = sctx;

    }

#endif

    public UnaryExpression(Expression operand, NodeType nodeType, TypeNode type)

      : base(nodeType){

      this.operand = operand;

      this.Type = type;

    }

#if !MinimalReader

    public UnaryExpression(Expression operand, NodeType nodeType, TypeNode type, SourceContext sctx)

      : base(nodeType){

      this.operand = operand;

      this.Type = type;

      this.SourceContext = sctx;

    }

#endif

    public Expression Operand{

      get{return this.operand;}

      set{this.operand = value;}

    }

  }

#if !MinimalReader

  public class PrefixExpression : Expression{

    public Expression Expression;

    public NodeType Operator;

    public Method OperatorOverload;

    public PrefixExpression()

      : base(NodeType.PrefixExpression){

    }

    public PrefixExpression(Expression expression, NodeType Operator, SourceContext sourceContext)

      : base(NodeType.PrefixExpression){

      this.Expression = expression;

      this.Operator = Operator;

      this.SourceContext = sourceContext;

    }

  }

  public class PostfixExpression : Expression{

    public Expression Expression;

    public NodeType Operator;

    public Method OperatorOverload;

    public PostfixExpression()

      : base(NodeType.PostfixExpression){

    }

    public PostfixExpression(Expression expression, NodeType Operator, SourceContext sourceContext)

      : base(NodeType.PostfixExpression){

      this.Expression = expression;

      this.Operator = Operator;

      this.SourceContext = sourceContext;

    }

  }

#endif

  public class BinaryExpression : Expression{

    private Expression operand1;

    private Expression operand2;

    public BinaryExpression()

      : base(NodeType.Nop){

    }

    public BinaryExpression(Expression operand1, Expression operand2, NodeType nodeType)

      : base(nodeType){

      this.operand1 = operand1;

      this.operand2 = operand2;

    }

    public BinaryExpression(Expression operand1, Expression operand2, NodeType nodeType, TypeNode resultType)

      : base(nodeType){

      this.operand1 = operand1;

      this.operand2 = operand2;

      this.Type = resultType;

    }

#if !MinimalReader

    public BinaryExpression(Expression operand1, Expression operand2, NodeType nodeType, SourceContext ctx)

      : base(nodeType){

      this.operand1 = operand1;

      this.operand2 = operand2;

      this.SourceContext = ctx;

    }

    public BinaryExpression(Expression operand1, Expression operand2, NodeType nodeType, TypeNode resultType, SourceContext ctx)

      : base(nodeType){

      this.operand1 = operand1;

      this.operand2 = operand2;

      this.Type = resultType;

      this.SourceContext = ctx;

    }

#endif

    public Expression Operand1{

      get{return this.operand1;}

      set{this.operand1 = value;}

    }

    public Expression Operand2{

      get{return this.operand2;}

      set{this.operand2 = value;}

    }

  }

  public class TernaryExpression : Expression{

    private Expression operand1;

    private Expression operand2;

    private Expression operand3;

    public TernaryExpression()

      : base(NodeType.Nop){

    }

    public TernaryExpression(Expression operand1, Expression operand2, Expression operand3, NodeType nodeType, TypeNode resultType)

      : base(nodeType){

      this.operand1 = operand1;

      this.operand2 = operand2;

      this.operand3 = operand3;

      this.Type = resultType;

    }

    public Expression Operand1{

      get{return this.operand1;}

      set{this.operand1 = value;}

    }

    public Expression Operand2{

      get{return this.operand2;}

      set{this.operand2 = value;}

    }

    public Expression Operand3{

      get{return this.operand3;}

      set{this.operand3 = value;}

    }

  }

  public abstract class NaryExpression : Expression{

#if !FxCop

    public ExpressionList Operands;

#else

    private ExpressionList operands;

    public ExpressionList Operands {

      get {return this.operands;}

      internal set{this.operands = value;}

    }

#endif

    protected NaryExpression()

      : base(NodeType.Nop){

    }

    protected NaryExpression(ExpressionList operands, NodeType nodeType)

      : base(nodeType){

      this.Operands = operands;

    }

  }

#if !MinimalReader

  public class ApplyToAll : BinaryExpression{

    public Local ElementLocal;

    public Method ResultIterator;

    public ApplyToAll()

      : base(null, null, NodeType.ApplyToAll){

    }

    public ApplyToAll(Expression operand1, Expression operand2)

      : base(operand1, operand2, NodeType.ApplyToAll){

    }

    public ApplyToAll(Expression operand1, Expression operand2, SourceContext ctx)

      : base(operand1, operand2, NodeType.ApplyToAll){

      this.SourceContext = ctx;

    }

  }

#endif

  public class NamedArgument : Expression{

    private bool isCustomAttributeProperty;

    private Identifier name;

    private Expression value;

    private bool valueIsBoxed;

    public NamedArgument()

      : base(NodeType.NamedArgument){

    }

    public NamedArgument(Identifier name, Expression value)

      : base(NodeType.NamedArgument){

      this.Name = name;

      this.Value = value;

    }

#if !MinimalReader

    public NamedArgument(Identifier name, Expression value, SourceContext ctx)

      : base(NodeType.NamedArgument){

      this.Name = name;

      this.Value = value;

      this.SourceContext = ctx;

    }

#endif

    public bool IsCustomAttributeProperty{ //TODO: rename this to IsProperty

      get{return this.isCustomAttributeProperty;}

      set{this.isCustomAttributeProperty = value;}

    }

    public Identifier Name{

      get{return this.name;}

      set{this.name = value;}

    }

    public Expression Value{

      get{return this.value;}

      set{this.value = value;}

    }

    public bool ValueIsBoxed{

      get{return this.valueIsBoxed;}

      set{this.valueIsBoxed = value;}

    }

  }

  /// <summary>

  /// This an Expression wrapper for compile time constants. It is assumed to be correct by construction.

  /// In Normalized IR, the wrapped value must be a primitive numeric type or an enum or a string or null.

  /// If used in custom attributes, types are also allowed as well as single dimensional arrays of other allowed types.

  /// If the wrapped value is null, any reference type is allowed, except in custom attributes, where it must be Type or String.

  /// </summary>

  public class Literal : Expression{

    private object value;

#if !MinimalReader

    public bool TypeWasExplicitlySpecifiedInSource;

    public Expression SourceExpression;

#endif

    public Literal()

      : base(NodeType.Literal){

    }

#if !NoReflection

    public Literal(object Value)

      : base(NodeType.Literal){

      this.value = Value;

    }

#endif

    public Literal(object value, TypeNode type)

      : base(NodeType.Literal){

      this.value = value;

      this.Type = type;

    }

    public Literal(object value, TypeNode type, SourceContext sourceContext)

      : base(NodeType.Literal){

      this.value = value;

      this.SourceContext = sourceContext;

      this.Type = type;

    }

    /// <summary>

    /// Holds the wrapped compile time constant value.

    /// </summary>

    public object Value{

      get{return this.value;}

    }

    public override string ToString(){

      if (this.Value == null) return "Literal for null";

      return this.Value.ToString();

    }

#if !NoWriter

    public static bool IsNullLiteral(Expression expr){

      Literal lit = expr as Literal;

      if (lit == null) return false;

      if (lit.Type != CoreSystemTypes.Object || lit.Value != null) return false;

      return true;      

    }

    //TODO: replace these with properties that freshly allocate them. It appears that Literals sometimes get clobbered.

    public static Literal DoubleOne;

    public static Literal False;

    public static Literal Int32MinusOne;

    public static Literal Int32Zero;

    public static Literal Int32One;

    public static Literal Int32Two;

    public static Literal Int32Sixteen;

    public static Literal Int64Zero;

    public static Literal Int64One;

    public static Literal Null;

    public static Literal SingleOne;

    public static Literal True;



    public static void Initialize(){

      Literal.DoubleOne = new Literal(1.0, CoreSystemTypes.Double);

      Literal.False = new Literal(false, CoreSystemTypes.Boolean);

      Literal.Int32MinusOne = new Literal(-1, CoreSystemTypes.Int32);

      Literal.Int32Zero = new Literal(0, CoreSystemTypes.Int32);

      Literal.Int32One = new Literal(1, CoreSystemTypes.Int32);

      Literal.Int32Two = new Literal(2, CoreSystemTypes.Int32);

      Literal.Int32Sixteen = new Literal(16, CoreSystemTypes.Int32);

      Literal.Int64Zero = new Literal(0L, CoreSystemTypes.Int64);

      Literal.Int64One = new Literal(1L, CoreSystemTypes.Int64);

      Literal.Null = new Literal(null, CoreSystemTypes.Object);

      Literal.SingleOne = new Literal(1.0f, CoreSystemTypes.Single);

      Literal.True = new Literal(true, CoreSystemTypes.Boolean);

    }

    public static void ClearStatics(){

      Literal.DoubleOne = null;

      Literal.False = null;

      Literal.Int32MinusOne = null;

      Literal.Int32Zero = null;

      Literal.Int32One = null;

      Literal.Int32Two = null;

      Literal.Int32Sixteen = null;

      Literal.Int64Zero = null;

      Literal.Int64One = null;

      Literal.Null = null;

      Literal.SingleOne = null;

      Literal.True = null;

    }

#endif

  }

  public class This : Parameter{

    public This(){

      this.NodeType = NodeType.This;

      this.Name = StandardIds.This;

    }

    public This(TypeNode type){

      this.NodeType = NodeType.This;

      this.Name = StandardIds.This;

      this.Type = type;

    }

#if !MinimalReader

    public bool IsCtorCall = false;

    public This(SourceContext sctx, bool isCtorCall){

      this.NodeType = NodeType.This;

      this.Name = StandardIds.This;

      this.SourceContext = sctx;

      this.IsCtorCall = isCtorCall;

    }

    public This(TypeNode type, SourceContext sctx){

      this.NodeType = NodeType.This;

      this.Name = StandardIds.This;

      this.Type = type;

      this.SourceContext = sctx;

    }

    public override bool Equals(object obj) {

      ThisBinding binding = obj as ThisBinding;

      return obj == this || binding != null && binding.BoundThis == this;

    }

    public override int GetHashCode(){

      return base.GetHashCode();

    }

#endif

#if ExtendedRuntime

    public override bool IsUniversallyDelayed {

      get {

        if (this.DeclaringMethod is InstanceInitializer && this.DeclaringMethod.DeclaringType != null &&

            !this.DeclaringMethod.DeclaringType.IsValueType) {

          // by default, class constructors should be delayed

          return !(this.DeclaringMethod.GetAttribute(ExtendedRuntimeTypes.NotDelayedAttribute) != null);

        }

        return (this.DeclaringMethod.GetAttribute(ExtendedRuntimeTypes.DelayedAttribute) != null);

      }

    }



#endif

  }

#if !MinimalReader

  public class ThisBinding : This, IUniqueKey{

    public This/*!*/ BoundThis;

    public ThisBinding(This/*!*/ boundThis, SourceContext sctx) {

      if (boundThis == null) throw new ArgumentNullException("boundThis");

      this.BoundThis = boundThis;

      this.SourceContext = sctx;

      this.Type = boundThis.Type;

      this.Name = boundThis.Name;

      this.TypeExpression = boundThis.TypeExpression;

      this.Attributes = boundThis.Attributes;

      this.DefaultValue = boundThis.DefaultValue;

      this.Flags = boundThis.Flags;

      this.MarshallingInformation = boundThis.MarshallingInformation;

      this.DeclaringMethod = boundThis.DeclaringMethod;

      this.ParameterListIndex = boundThis.ParameterListIndex;

      this.ArgumentListIndex = boundThis.ArgumentListIndex;

      //^ base();

    }

    public override int GetHashCode(){

      return this.BoundThis.GetHashCode();

    }

    public override bool Equals(object obj){

      ThisBinding pb = obj as ThisBinding;

      if (pb != null)

        return this.BoundThis.Equals(pb.BoundThis);

      else

        return this.BoundThis.Equals(obj);

    }

    int IUniqueKey.UniqueId{

      get {return this.BoundThis.UniqueKey;}

    }

    /// <summary>

    /// Must forward type to underlying binding, since ThisBindings get built at times when

    /// the bound This node does not have its final type yet.

    /// </summary>

    public override TypeNode Type {

      get {

        return BoundThis.Type;

      }

      set {

        BoundThis.Type = value;

      }

    }

  }

  public class Base : Expression{

    /// <summary>

    /// When the source uses the C# compatibility mode, base calls cannot be put after non-null

    /// field initialization, but must be put before the body. But the user can specify where

    /// the base ctor call should be performed by using "base;" as a marker. During parsing

    /// this flag is set so the right code transformations can be performed at code generation.

    /// </summary>

    public bool UsedAsMarker;

    public bool IsCtorCall = false;

    public Base()

      : base(NodeType.Base){

    }

    public Base(SourceContext sctx, bool isCtorCall)

      : base(NodeType.Base){

      this.SourceContext = sctx;

      this.IsCtorCall = isCtorCall;

    }

  }

  public class ImplicitThis : Expression{

    public int LexLevel;

    public Class MostNestedScope;

    public ImplicitThis()

      : base(NodeType.ImplicitThis){

    }

    public ImplicitThis(Class mostNestedScope, int lexLevel)

      : base(NodeType.ImplicitThis){

      this.LexLevel = lexLevel;

      this.MostNestedScope = mostNestedScope;

    }

  }

  public class CurrentClosure : Expression{

    public Method Method;

    public CurrentClosure()

      : base(NodeType.CurrentClosure){

    }

    public CurrentClosure(Method method, TypeNode type)

      : base(NodeType.CurrentClosure){

      this.Method = method;

      this.Type = type;

    }

    public CurrentClosure(Method method, TypeNode type, SourceContext sctx)

      : base(NodeType.CurrentClosure){

      this.Method = method;

      this.Type = type;

      this.SourceContext = sctx;

    }

  }

  public class SetterValue : Expression{

    public SetterValue()

      : base(NodeType.SetterValue){

    }

  }

#endif

  public class Identifier : Expression{

    private int hashCode;

    internal int length;

    private string name;

    private int offset;

#if !FxCop

    private DocumentText text;

#endif

#if !MinimalReader

    public Identifier Prefix;

#endif

    /// <summary>An identifier with the empty string ("") as its value.</summary>

    public static readonly Identifier/*!*/ Empty = new Identifier("");

#if !FxCop

    private Identifier(DocumentText/*!*/ text, int offset, int length)

      : base(NodeType.Identifier){

      this.text = text;

      this.offset = offset;

      this.length = length;

      ulong hcode = 0;

      for (int i = offset, n = length+i; i < n; i++){

        char ch = text[i];

        hcode = hcode*17 + ch;

      }

      this.hashCode = ((int)hcode) & int.MaxValue;

    }

    public static Identifier/*!*/ For(SourceContext sctx) {

      DocumentText text = null;

      if (sctx.Document != null) text = sctx.Document.Text;

      if (text == null) text = new DocumentText("");

      Identifier id = new Identifier(text, sctx.StartPos, sctx.EndPos-sctx.StartPos);

      id.SourceContext = sctx;

      return id;

    }

#endif

    public Identifier(string name)

      : base(NodeType.Identifier){

      if (name == null) name = "";

      this.name = name;

      int n = this.length = name.Length;

      ulong hcode = 0;

      for (int i = 0; i < n; i++){

        char ch = name[i];

        hcode = hcode*17 + ch;

      }

      this.hashCode = ((int)hcode) & int.MaxValue;

    }

#if !MinimalReader

    public Identifier(string name, SourceContext sctx)

      : this(name){

      this.SourceContext = sctx;

    }

#endif

    public static Identifier/*!*/ For(string/*!*/ name) {

      return new Identifier(name);

    }

    private unsafe Identifier(byte* pointer, int offset)

      : base(NodeType.Identifier){

      this.offset = offset;

      bool isASCII = true;

      int length = 0;

      ulong hcode = 0;

      for (int i = offset; ; i++){

        byte b = *(pointer+i);

        if (b == 0) break;

        if ((b & 0x80) != 0) isASCII = false;

        hcode = hcode*17 + b;

        length++;

      }

      if (isASCII){

        this.hashCode = ((int)hcode) & int.MaxValue;

        this.length = length;

        this.name = new string((sbyte*)pointer, offset, length, Encoding.ASCII);

        return;

      }

      hcode = 0;

      string name = this.name = new string((sbyte*)pointer, offset, length, Encoding.UTF8);

      for (int i = 0, n = this.length = name.Length; i < n; i++){

        char ch = name[i];

        hcode = hcode*17 + ch;

      }

      this.hashCode = ((int)hcode) & int.MaxValue;

    }

    /// <summary>

    /// Use when pointer+offset points to a null terminated string of UTF8 code points.

    /// </summary>

    internal unsafe static Identifier/*!*/ For(byte* pointer, int offset) {

      //TODO: first look for identifier in cache

      return new Identifier(pointer, offset);

    }



    private unsafe Identifier(byte* pointer, uint length)

      : base(NodeType.Identifier){

      //this.offset = 0;

      this.length = (int)length;

      ulong hcode = 0;

      for (uint i = 0; i < length; i++){

        byte b = *(pointer+i);

        if ((b & 0x80) != 0) goto doUTF8decoding;

        hcode = hcode*17 + b;

      }

      this.hashCode = ((int)hcode) & int.MaxValue;

      this.name = new string((sbyte*)pointer, 0, this.length, Encoding.ASCII);

      return;

    doUTF8decoding:

      string name = this.name = new string((sbyte*)pointer, 0, this.length, Encoding.UTF8);

      for (int i = 0, n = this.length = name.Length; i < n; i++){

        char ch = name[i];

        hcode = hcode*17 + ch;

      }

      this.hashCode = ((int)hcode) & int.MaxValue;

    }

    /// <summary>

    /// Use when pointer points to a string of UTF8 code points of a given length

    /// </summary>

    internal unsafe static Identifier/*!*/ For(byte* pointer, uint length) {

      //TODO: first look for identifier in cache

      return new Identifier(pointer, length);

    }

    private static readonly object/*!*/ Lock = new object();

    private struct CanonicalIdentifier{

      internal string/*!*/ Name;

      internal int UniqueIdKey;

      internal int HashCode;



      internal CanonicalIdentifier(string/*!*/ name, int uniqueIdKey, int hashCode) {

        this.Name = name;

        this.UniqueIdKey = uniqueIdKey;

        this.HashCode = hashCode;

      }

    }

    private static CanonicalIdentifier[]/*!*/ HashTable = new CanonicalIdentifier[16*1024];

    private static int count;

    private int GetUniqueIdKey(){

      lock(Identifier.Lock){

        int hcode = this.hashCode;

        CanonicalIdentifier[] hTable = Identifier.HashTable;

        int length = hTable.Length;

        int i = hcode % length;

        CanonicalIdentifier id = hTable[i];

        while (id.Name != null){

          if (this.HasSameNameAs(id)) return id.UniqueIdKey;

          i = (i+1) % length;

          id = hTable[i];

        }

        int count = Identifier.count;

        int countp1 = count+1;

        Identifier.count = countp1;

        string name = this.Name; //Get a local copy of the name and drop any reference to a DocumentText instance

        hTable[i] = new CanonicalIdentifier(name, countp1, hcode);

        if (countp1 > length/2) Rehash(); //Threshold exceeded, need to rehash        

        return countp1;

      }

    }

    private unsafe bool HasSameNameAs(CanonicalIdentifier id) {

      int myLength = this.length;

      int idLength = id.Name.Length;

      if (myLength != idLength) return false;

      string myName = this.name;

      string idName = id.Name;

#if !FxCop

      if (myName == null){

        int myOffset = this.offset;

        if (this.text != null && this.text.Equals(idName, myOffset, myLength)){

          this.name = idName;

          this.text = null;

          return true;

        }

        return false;

      }

#endif

      return myName == idName;

    }

    public string/*!*/ Name{ //TODO: need a better name for this property

      get{

#if !FxCop

        if (this.name != null) return this.name;

        lock(this){

          if (this.name != null) return this.name;

          //^ assume this.text != null;

          int length = this.length;

          int offset = this.offset;

          this.name = this.text.Substring(offset, length);

          this.text = null;

          return this.name;

        }

#else

        return this.name;

#endif

      }

    }

    private static void Rehash(){

      CanonicalIdentifier[] hTable = Identifier.HashTable;

      int n = hTable.Length;

      int n2 = n*2;

      CanonicalIdentifier[] newhTable = new CanonicalIdentifier[n2];

      for (int i = 0; i < n; i++){

        CanonicalIdentifier id = hTable[i];

        if (id.Name == null) continue;

        int j = id.HashCode % n2;

        CanonicalIdentifier id2 = newhTable[j];

        while (id2.Name != null){

          j = (j+1) % n2;

          id2 = newhTable[j];

        }

        newhTable[j] = id;

      }

      Identifier.HashTable = newhTable;

    }

    public override string/*!*/ ToString(){

#if !MinimalReader

      if (this.Prefix != null)

        return this.Prefix.Name+":"+this.Name;

#endif

      if (this.Name == null) return "";

      return this.Name;

    }

    private int uniqueIdKey;

    /// <summary>

    /// Returns an integer that is the same for every Identifier instance that has the same string value, and that is different from

    /// every other identifier instance that has a different string value. Useful for efficient equality tests when hashing identifiers.

    /// </summary>

    public int UniqueIdKey{

      get{

        int result = this.uniqueIdKey;

        if (result != 0) return result;

        return this.uniqueIdKey = this.GetUniqueIdKey();

      }

    }

    [Obsolete("Use Identifier.UniqueIdKey instead")]

    public new int UniqueKey{

      get{

        int result = this.uniqueIdKey;

        if (result != 0) return result;

        return this.uniqueIdKey = this.GetUniqueIdKey();

      }

    }

  }

#if !MinimalReader

  public class QualifiedIdentifier : Expression{

    public Identifier Identifier;

    public Expression Qualifier;

    public Expression BoundMember;

    public bool QualifierIsNamespace;



    public QualifiedIdentifier()

      : base(NodeType.QualifiedIdentifer){

    }

    public QualifiedIdentifier(Expression qualifier, Identifier identifier)

      : base(NodeType.QualifiedIdentifer){

      this.Identifier = identifier;

      this.Qualifier = qualifier;

    }

    public QualifiedIdentifier(Expression qualifier, Identifier identifier, SourceContext sourceContext)

      : base(NodeType.QualifiedIdentifer){

      this.Identifier = identifier;

      this.Qualifier = qualifier;

      this.SourceContext = sourceContext;

    }

    public QualifiedIdentifier(Expression qualifier, Identifier identifier, SourceContext sourceContext, bool qualifierIsNamespace)

      : base(NodeType.QualifiedIdentifer){

      this.Identifier = identifier;

      this.Qualifier = qualifier;

      this.SourceContext = sourceContext;

      this.QualifierIsNamespace = qualifierIsNamespace;

    }

    public override string/*!*/ ToString(){

      string str = this.Identifier == null ? "" : this.Identifier.ToString();

      if (this.Qualifier == null) return str;

      string separator = this.QualifierIsNamespace ? "::" : "+";

      return this.Qualifier.ToString()+separator+str;

    }

  }

  public class Quantifier : Expression{

    public NodeType QuantifierType;

    public TypeNode SourceType; // the type of elements the quantifier consumes

    public Comprehension Comprehension;

    public Quantifier()

      : base(NodeType.Quantifier){

    }

    public Quantifier(Comprehension comprehension)

      : base(NodeType.Quantifier){

      this.Comprehension = comprehension;

    }

    public Quantifier(NodeType t, Comprehension comprehension)

      : base(NodeType.Quantifier){

      this.QuantifierType = t;

      this.Comprehension = comprehension;

    }

  }

  public enum ComprehensionBindingMode {In, Gets};

  public class ComprehensionBinding : Expression{

    public ComprehensionBindingMode Mode = ComprehensionBindingMode.In;

    public TypeNode TargetVariableType;

    public TypeNode TargetVariableTypeExpression;

    public Expression TargetVariable;



    public TypeNode AsTargetVariableType;

    public TypeNode AsTargetVariableTypeExpression;



    public Expression SourceEnumerable;

    public BlockScope ScopeForTemporaryVariables;

    public ComprehensionBinding()

      : base(NodeType.ComprehensionBinding){

    }

  }  

  public enum ComprehensionMode {Reduction, Comprehension};

  // {1,2,3} ==> Comprehension with BindingsAndFilters = null and Elements = [1,2,3]

  // i.e., for a "display", there are no bindings and the elements have one entry per value in the comprehension

  // { int x in A, P(x); T(x); default } ==> Comprehension with BindingsAndFilters = [int x in A, P(x)] and Elements = [T(x), default]

  // i.e., for "true" comprehensions, the list of elements will always have either one or two elements (two if there is a default)

  public class Comprehension : Expression{

    public ComprehensionMode Mode = ComprehensionMode.Comprehension;

    public ExpressionList BindingsAndFilters;

    public ExpressionList Elements;



    public Node nonEnumerableTypeCtor; // used only when the comprehension should generate code for an IList, e.g.

    public Method AddMethod; // used only when the comprehension should generate code for an IList, e.g.

    public TypeNode TemporaryHackToHoldType;



    public Comprehension()

      : base(NodeType.Comprehension){

    }



    public bool IsDisplay{ 

      get{ 

        return this.BindingsAndFilters == null;

      }

    }

  }

  public class NameBinding : Expression{

    public Identifier Identifier;

    public MemberList BoundMembers;

    public Expression BoundMember;

    public int LexLevel;

    public Class MostNestedScope;

    public NameBinding()

      : base(NodeType.NameBinding){

    }

    public NameBinding(Identifier identifier, MemberList boundMembers)

      : base(NodeType.NameBinding){

      this.Identifier = identifier;

      this.BoundMembers = boundMembers;

    }

    public NameBinding(Identifier identifier, MemberList boundMembers, SourceContext sctx)

      : base(NodeType.NameBinding){

      this.Identifier = identifier;

      this.BoundMembers = boundMembers;

      this.SourceContext = sctx;

    }

    public NameBinding(Identifier identifier, MemberList boundMembers, Class mostNestedScope, int lexLevel)

      : base(NodeType.NameBinding){

      this.Identifier = identifier;

      this.BoundMembers = boundMembers;

      this.LexLevel = lexLevel;

      this.MostNestedScope = mostNestedScope;

    }

    public NameBinding(Identifier identifier, MemberList boundMembers, Class mostNestedScope, int lexLevel, SourceContext sctx)

      : base(NodeType.NameBinding) {

      this.Identifier = identifier;

      this.BoundMembers = boundMembers;

      this.LexLevel = lexLevel;

      this.MostNestedScope = mostNestedScope;

      this.SourceContext = sctx;

    }

    public override string ToString() {

      return this.Identifier == null ? "" : this.Identifier.ToString();

    }

  }

  public class TemplateInstance : Expression{

    public Expression Expression;

    public TypeNodeList TypeArguments;

    public TypeNodeList TypeArgumentExpressions;

    public bool IsMethodTemplate;

    public MemberList BoundMembers;



    public TemplateInstance()

      : this(null, null){

    }

    public TemplateInstance(Expression expression, TypeNodeList typeArguments)

      : base(NodeType.TemplateInstance){

      this.Expression = expression;

      this.TypeArguments = typeArguments;

    }

  }

  public class StackAlloc : Expression{

    public TypeNode ElementType;

    public TypeNode ElementTypeExpression;

    public Expression NumberOfElements;



    public StackAlloc()

      : base(NodeType.StackAlloc){

    }

    public StackAlloc(TypeNode elementType, Expression numberOfElements, SourceContext sctx)

      : base(NodeType.StackAlloc){

      this.ElementType = this.ElementTypeExpression = elementType;

      this.NumberOfElements = numberOfElements;

      this.SourceContext = sctx;

    }

  }

#endif

  public class MethodCall : NaryExpression{

    private Expression callee;

    private TypeNode constraint;

    private bool isTailCall;     

#if !MinimalReader

    public Expression CalleeExpression;

    public bool GiveErrorIfSpecialNameMethod;

    public bool ArgumentListIsIncomplete;

    public MethodCall(){

      this.NodeType = NodeType.MethodCall;

    }

    public MethodCall(Expression callee, ExpressionList arguments)

      : base(arguments, NodeType.MethodCall){

      this.callee = this.CalleeExpression = callee;

      this.isTailCall = false;

    }

#endif

    public MethodCall(Expression callee, ExpressionList arguments, NodeType typeOfCall)

      : base(arguments, typeOfCall){

      this.callee = callee;

#if !MinimalReader      

      this.CalleeExpression = callee;

#endif

      //this.isTailCall = false;

    }

#if !MinimalReader

    public MethodCall(Expression callee, ExpressionList arguments, NodeType typeOfCall, TypeNode resultType)

      : this(callee, arguments, typeOfCall){

      this.Type = resultType;

    }

    public MethodCall(Expression callee, ExpressionList arguments, NodeType typeOfCall, TypeNode resultType, SourceContext sctx)

      : this(callee, arguments, typeOfCall, resultType){

      this.SourceContext = sctx;

    }

#endif

    public Expression Callee{

      get{return this.callee;}

      set{this.callee = value;}

    }

    public bool IsTailCall{

      get{return this.isTailCall;}

      set{this.isTailCall = value;}

    }

    public TypeNode Constraint{

      get{return this.constraint;}

      set{this.constraint = value;}

    }

  }

  public class Construct : NaryExpression{

    private Expression constructor;

#if !MinimalReader

    public Expression Owner;

#endif

    public Construct(){

      this.NodeType = NodeType.Construct;

    }

    public Construct(Expression constructor, ExpressionList arguments)

      : base(arguments, NodeType.Construct){

      this.constructor = constructor;

    }

#if !MinimalReader

    public Construct(Expression constructor, ExpressionList arguments, SourceContext sctx)

      : base(arguments, NodeType.Construct){

      this.constructor = constructor;

      this.SourceContext = sctx;

    }

    public Construct(Expression constructor, ExpressionList arguments, TypeNode type)

      : base(arguments, NodeType.Construct){

      this.constructor = constructor;

      this.Type = type;

    }

    public Construct(Expression constructor, ExpressionList arguments, TypeNode type, SourceContext sctx)

      : base(arguments, NodeType.Construct) {

      this.constructor = constructor;

      this.Type = type;

      this.SourceContext = sctx;

    }

#endif

    public Expression Constructor{

      get{return this.constructor;}

      set{this.constructor = value;}

    }

  }

  public class ConstructArray : NaryExpression{

    private TypeNode elementType;

    private int rank;

#if !MinimalReader

    public TypeNode ElementTypeExpression;

    public ExpressionList Initializers;

    public Expression Owner;

#endif

    public ConstructArray(){

      this.NodeType = NodeType.ConstructArray;

      this.rank = 1;

    }

    public ConstructArray(TypeNode elementType, ExpressionList sizes, ExpressionList initializers)

      : base(sizes, NodeType.ConstructArray){

      this.elementType = elementType;

      this.Operands = sizes;

      this.rank = sizes == null ? 1 : sizes.Count;

#if !MinimalReader

      this.Initializers = initializers;

#endif

    }

#if !MinimalReader

    public ConstructArray(TypeNode elementType, ExpressionList initializers)

      : base(null, NodeType.ConstructArray){

      this.elementType = elementType;

      this.Initializers = initializers;

      this.rank = 1;

      if (elementType != null)

        this.Type = elementType.GetArrayType(1);

    }

    public ConstructArray(TypeNode elementType, int rank, ExpressionList initializers)

      : base(null, NodeType.ConstructArray){

      this.elementType = elementType;

      this.Initializers = initializers;

      this.rank = rank;

      if (elementType != null)

        this.Type = elementType.GetArrayType(1);

    }

#endif

    public TypeNode ElementType{

      get{return this.elementType;}

      set{this.elementType = value;}

    }

    public int Rank{

      get{return this.rank;}

      set{this.rank = value;}

    }

  }

#if !MinimalReader

  public class ConstructFlexArray : NaryExpression{

    public TypeNode ElementType;

    public TypeNode ElementTypeExpression;

    public ExpressionList Initializers;

    public ConstructFlexArray(){

      this.NodeType = NodeType.ConstructFlexArray;

    }

    public ConstructFlexArray(TypeNode elementType, ExpressionList sizes, ExpressionList initializers)

      : base(sizes, NodeType.ConstructFlexArray){

      this.ElementType = elementType;

      this.Operands = sizes;

      this.Initializers = initializers;

    }

  }

  public class ConstructDelegate : Expression{

    public TypeNode DelegateType;

    public TypeNode DelegateTypeExpression;

    public Identifier MethodName;

    public Expression TargetObject;

    public ConstructDelegate()

      : base(NodeType.ConstructDelegate){

    }

    public ConstructDelegate(TypeNode delegateType, Expression targetObject, Identifier methodName)

      : base(NodeType.ConstructDelegate) {

      this.DelegateType = delegateType;

      this.MethodName = methodName;

      this.TargetObject = targetObject;

    }

    public ConstructDelegate(TypeNode delegateType, Expression targetObject, Identifier methodName, SourceContext sctx)

      : base(NodeType.ConstructDelegate){

      this.DelegateType = delegateType;

      this.MethodName = methodName;

      this.TargetObject = targetObject;

      this.SourceContext = sctx;

    }

  }

  public class ConstructIterator : Expression{

    public Class State;

    public Block Body;

    public TypeNode ElementType;

    public ConstructIterator()

      : base(NodeType.ConstructIterator){

    }

    public ConstructIterator(Class state, Block body, TypeNode elementType, TypeNode type)

      : base(NodeType.ConstructIterator){

      this.State = state;

      this.Body = body;

      this.ElementType = elementType;

      this.Type = type;

    }

  }

  public class ConstructTuple : Expression{

    public FieldList Fields;

    public ConstructTuple()

      : base(NodeType.ConstructTuple){

    }

  }

  public class CoerceTuple : ConstructTuple{

    public Expression OriginalTuple;

    public Local Temp;

    public CoerceTuple(){

      this.NodeType = NodeType.CoerceTuple;

    }

  }

#endif

  public class Indexer : NaryExpression{

#if !MinimalReader

    public Property CorrespondingDefaultIndexedProperty;

    public bool ArgumentListIsIncomplete;

#endif

    public Indexer(){

      this.NodeType = NodeType.Indexer;

    }

    public Indexer(Expression @object, ExpressionList arguments)

      : base(arguments, NodeType.Indexer){

      this.@object = @object;

    }

#if !MinimalReader

    public Indexer(Expression Object, ExpressionList arguments, SourceContext sctx)

      : base(arguments, NodeType.Indexer){

      this.@object = Object;

      this.SourceContext = sctx;

    }

    public Indexer(Expression Object, ExpressionList arguments, TypeNode elementType)

      : base(arguments, NodeType.Indexer){

      this.@object = Object;

      this.elementType = this.Type = elementType;

    }

    public Indexer(Expression Object, ExpressionList arguments, TypeNode elementType, SourceContext sctx)

      : base(arguments, NodeType.Indexer){

      this.@object = Object;

      this.elementType = this.Type = elementType;

      this.SourceContext = sctx;

    }

#endif

    private Expression @object;

    public Expression Object{

      get{return this.@object;}

      set{this.@object = value;}

    }

    private TypeNode elementType;

    /// <summary>

    /// This type is normally expected to be the same the value of Type. However, if the indexer applies to an array of enums, then

    /// Type will be the enum type and ElementType will be the underlying type of the enum.

    /// </summary>

    public TypeNode ElementType{

      get{return this.elementType;}

      set{this.elementType = value;}

    }

  }

#if !MinimalReader

  public class CollectionEnumerator : Expression{

    public Expression Collection;

    public Method DefaultIndexerGetter;

    public Method LengthPropertyGetter;

    public Method GetEnumerator;

    public Method MoveNext;

    public Method GetCurrent;

    public Local ElementLocal;

    public Expression ElementCoercion;

    public CollectionEnumerator()

      : base(NodeType.CollectionEnumerator){

    }

  }

  /// <summary>

  /// An expression that is used on the left hand as well as the right hand side of an assignment statement. For example, e in (e += 1).

  /// </summary>

  public class LRExpression : Expression{

    public Expression Expression;

    public LocalList Temporaries;

    public ExpressionList SubexpressionsToEvaluateOnce;

    public LRExpression(Expression/*!*/ expression)

      : base(NodeType.LRExpression){

      this.Expression = expression;

      this.Type = expression.Type;

    }

  }

  public class AssignmentExpression : Expression{

    public Statement AssignmentStatement;

    public AssignmentExpression()

      : base(NodeType.AssignmentExpression){

    }

    public AssignmentExpression(AssignmentStatement assignment)

      : base(NodeType.AssignmentExpression){

      this.AssignmentStatement = assignment;

    }

  }

#endif

#if !MinimalReader || FxCop

  public class BlockExpression : Expression{

    public Block Block;

    public BlockExpression()

      : base(NodeType.BlockExpression){

    }

    public BlockExpression(Block block)

      : base(NodeType.BlockExpression){

      this.Block = block;

    }

    public BlockExpression(Block block, TypeNode type)

      : base(NodeType.BlockExpression){

      this.Block = block;

      this.Type = type;

    }

    public BlockExpression(Block block, TypeNode type, SourceContext sctx)

      : base(NodeType.BlockExpression){

      this.Block = block;

      this.Type = type;

      this.SourceContext = sctx;

    }

  }

#endif

#if !MinimalReader

  public class AnonymousNestedFunction : Expression{

    public ParameterList Parameters;

    public Block Body;

    public Method Method;

    public Expression Invocation;

    

    public AnonymousNestedFunction()

      : base(NodeType.AnonymousNestedFunction){

    }

    public AnonymousNestedFunction(ParameterList parameters, Block body)

      : base(NodeType.AnonymousNestedFunction){

      this.Parameters = parameters;

      this.Body = body;

    }

    public AnonymousNestedFunction(ParameterList parameters, Block body, SourceContext sctx)

      : base(NodeType.AnonymousNestedFunction){

      this.Parameters = parameters;

      this.Body = body;

      this.SourceContext = sctx;

    }

  }

#endif

  public class Instruction : Node{

    private OpCode opCode;

    private int offset;

    private object value;

    public Instruction()

      : base(NodeType.Instruction){

    }

    public Instruction(OpCode opCode, int offset)

      : this(opCode, offset, null){

    }

    public Instruction(OpCode opCode, int offset, object value) 

      : base(NodeType.Instruction){

      this.opCode = opCode;

      this.offset = offset;

      this.value = value;

    }

    /// <summary>The actual value of the opcode</summary>

    public OpCode OpCode{

      get{return this.opCode;}

      set{this.opCode = value;}

    }

    /// <summary>The offset from the start of the instruction stream of a method</summary>

    public int Offset{

      get{return this.offset;}

      set{this.offset = value;}

    }

    /// <summary>Immediate data such as a string, the address of a branch target, or a metadata reference, such as a Field</summary>

    public object Value{

      get{return this.value;}

      set{this.value = value;}

    }

  }

  public class Statement : Node{

#if FxCop

    internal int ILOffset;

#endif

#if !FxCop && ILOFFSETS

    public int ILOffset;

#endif

    public Statement(NodeType nodeType)

      : base(nodeType){

    }

#if !MinimalReader

    public Statement(NodeType nodeType, SourceContext sctx)

      : base(nodeType) {

      this.SourceContext = sctx;

    }

#endif

  }

  public class Block : Statement{

    private StatementList statements;

#if !MinimalReader

    public bool Checked;

    public bool SuppressCheck;

#endif

#if !MinimalReader || !NoWriter

    public bool HasLocals;

#endif

#if !MinimalReader

    public bool IsUnsafe;

    public BlockScope Scope;

#endif

    public Block()

      : base(NodeType.Block){

    }

    public Block(StatementList statements)

      : base(NodeType.Block){

      this.statements = statements;

    }

#if !MinimalReader

    public Block(StatementList statements, SourceContext sourceContext)

      : base(NodeType.Block){

      this.SourceContext = sourceContext;

      this.statements = statements;

    }

    public Block(StatementList statements, bool Checked, bool SuppressCheck, bool IsUnsafe)

      : base(NodeType.Block){

      this.Checked = Checked;

      this.IsUnsafe = IsUnsafe;

      this.SuppressCheck = SuppressCheck;

      this.statements = statements;

    }

    public Block(StatementList statements, SourceContext sourceContext, bool Checked, bool SuppressCheck, bool IsUnsafe)

      : base(NodeType.Block){

      this.Checked = Checked;

      this.IsUnsafe = IsUnsafe;

      this.SuppressCheck = SuppressCheck;

      this.SourceContext = sourceContext;

      this.statements = statements;

    }

    public override string ToString() {

      return "B#" + this.UniqueKey.ToString();

    }

#endif

    public StatementList Statements{    

      get{return this.statements;}

      set{this.statements = value;}

    }

  }

#if !MinimalReader

  public class LabeledStatement : Block{

    public Identifier Label;

    public Statement Statement;

    public LabeledStatement(){

      this.NodeType = NodeType.LabeledStatement;

    }

  }

  public class FunctionDeclaration : Statement{

    public Identifier Name;

    public ParameterList Parameters;

    public TypeNode ReturnType;

    public TypeNode ReturnTypeExpression;

    public Block Body;

    public Method Method;



    public FunctionDeclaration()

      : base(NodeType.FunctionDeclaration){

    }

    public FunctionDeclaration(Identifier name, ParameterList parameters, TypeNode returnType, Block body)

      : base(NodeType.FunctionDeclaration){

      this.Name = name;

      this.Parameters = parameters;

      this.ReturnType = returnType;

      this.Body = body;

    }

  }

  public class Assertion : Statement{

    public Expression Condition;

    // a string that a user wants associated with the assertion

    public Literal userMessage;

    public Assertion()

      : base(NodeType.Assertion){

    }

    public Assertion(Expression condition)

      : base(NodeType.Assertion){

      this.Condition = condition;

    }

  }

  public class Assumption : Statement{

    public Expression Condition;

    // a string that a user wants associated with the assumption

    public Literal userMessage;

    public Assumption()

      : base(NodeType.Assumption){

    }

    public Assumption(Expression condition)

      : base(NodeType.Assumption){

      this.Condition = condition;

    }

  }

#endif

  public class AssignmentStatement : Statement{

    private NodeType @operator;

    private Expression source;

    private Expression target;

#if !MinimalReader

    public Method OperatorOverload;

    ///<summary>A Type two which both operands must be coerced before carrying out the operation (if any).</summary>

    public TypeNode UnifiedType;

#endif

    public AssignmentStatement()

      : base(NodeType.AssignmentStatement){

      this.Operator = NodeType.Nop;

    }

    public AssignmentStatement(Expression target, Expression source)

      : this(target, source, NodeType.Nop){

    }

#if !MinimalReader

    public AssignmentStatement(Expression target, Expression source, SourceContext context)

      : this(target, source, NodeType.Nop){

      this.SourceContext = context;

    }

#endif

    public AssignmentStatement(Expression target, Expression source, NodeType @operator)

      : base(NodeType.AssignmentStatement){

      this.target = target;

      this.source = source;

      this.@operator = @operator;

    }

#if !MinimalReader

    public AssignmentStatement(Expression target, Expression source, NodeType Operator, SourceContext context)

      : this(target, source, Operator){

      this.SourceContext = context;

    }

#endif

    public NodeType Operator{

      get{return this.@operator;}

      set{this.@operator = value;}

    }

    public Expression Source{

      get{return this.source;}

      set{this.source = value;}

    }

    public Expression Target{

      get{return this.target;}

      set{this.target = value;}

    }

  }

  public class ExpressionStatement : Statement{

    private Expression expression;

    public ExpressionStatement()

      : base(NodeType.ExpressionStatement){

    }

    public ExpressionStatement(Expression expression)

      : base(NodeType.ExpressionStatement){

      this.Expression = expression;

    }

#if !MinimalReader

    public ExpressionStatement(Expression expression, SourceContext sctx)

      : base(NodeType.ExpressionStatement){

      this.Expression = expression;

      this.SourceContext = sctx;

    }

#endif

    public Expression Expression{

      get{return this.expression;}

      set{this.expression = value;}

    }

  }

  public class Branch : Statement{

    private Expression condition;

    private bool leavesExceptionBlock;

    internal bool shortOffset;

    private Block target;

    public bool BranchIfUnordered;

    public Branch()

      : base(NodeType.Branch){

    }

#if !MinimalReader

    public Branch(Expression condition, Block target)

      : this(condition, target, false, false, false){

    }

    public Branch(Expression condition, Block target, SourceContext sourceContext)

      : this(condition, target, false, false, false){

      this.SourceContext = sourceContext;

    }

    public Branch(Expression condition, Block target, SourceContext sourceContext, bool unordered)

      : this(condition, target, false, false, false){

      this.BranchIfUnordered = unordered;

      this.SourceContext = sourceContext;

    }

#endif

    public Branch(Expression condition, Block target, bool shortOffset, bool unordered, bool leavesExceptionBlock)

      : base(NodeType.Branch){

      this.BranchIfUnordered = unordered;

      this.condition = condition;

      this.leavesExceptionBlock = leavesExceptionBlock;

      this.shortOffset = shortOffset;

      this.target = target;

    }

    public Expression Condition{

      get{return this.condition;}

      set{this.condition = value; }

    }

    public bool LeavesExceptionBlock{

      get{return this.leavesExceptionBlock;}

      set{this.leavesExceptionBlock = value;}

    }

    public bool ShortOffset{

      get{return this.shortOffset;}

      set{this.shortOffset = value;}

    }

    public Block Target{

      get{return this.target;}

      set{this.target = value; }

    }

  }

#if FxCop

  public class ReturnNode : ExpressionStatement{

    public ReturnNode()

#else

  public class Return : ExpressionStatement{

    public Return()

#endif

      : base(){

      this.NodeType = NodeType.Return;

    }

#if FxCop

    public ReturnNode(Expression expression)

#else

    public Return(Expression expression)

#endif

      : base(expression){

      this.NodeType = NodeType.Return;

    }

#if !MinimalReader

    public Return(SourceContext sctx)

      : base() {

      this.NodeType = NodeType.Return;

      this.SourceContext = sctx;

    }

    public Return(Expression expression, SourceContext sctx)

      : base(expression) {

      this.NodeType = NodeType.Return;

      this.SourceContext = sctx;

    }

#endif

  }

#if !MinimalReader

  /// <summary>

  /// Represents the return value in a post condition

  /// </summary>

  public class ReturnValue : Expression

  {

    public ReturnValue() : base(NodeType.ReturnValue)

    { }



    public ReturnValue(SourceContext sc)

      : this()

    {

      this.SourceContext = sc;

    }



    public ReturnValue(TypeNode returnType, SourceContext sc)

      : this(sc)

    {

      this.Type = returnType;

    }

    public ReturnValue(TypeNode returnType)

      : this()

    {

      this.Type = returnType;

    }

  }



  public class Yield : ExpressionStatement{

    public Yield()

      : base(){

      this.NodeType = NodeType.Yield;

    }

    public Yield(Expression expression)

      : base(expression){

      this.NodeType = NodeType.Yield;

    }

    public Yield(Expression expression, SourceContext sctx)

      : base(expression){

      this.NodeType = NodeType.Yield;

      this.SourceContext = sctx;

    }

  }

  public class Try : Statement{

    private CatchList catchers;

    private FilterList filters;

    private FaultHandlerList faultHandlers;

    private Finally finallyClause;

    private Block tryBlock;

    public Try()

      : base(NodeType.Try){

    }

    public Try(Block tryBlock, CatchList catchers, FilterList filters, FaultHandlerList faultHandlers, Finally Finally)

      : base(NodeType.Try){

      this.catchers = catchers;

      this.faultHandlers = faultHandlers;

      this.filters = filters;

      this.finallyClause = Finally;

      this.tryBlock = tryBlock;

    }

    public CatchList Catchers{

      get{return this.catchers;}

      set{this.catchers = value;}

    }

    public FilterList Filters{

      get{return this.filters;}

      set{this.filters = value;}

    }

    public FaultHandlerList FaultHandlers{

      get{return this.faultHandlers;}

      set{this.faultHandlers = value;}

    }

    public Finally Finally{

      get{return this.finallyClause;}

      set{this.finallyClause = value;}

    }

    public Block TryBlock{

      get{return this.tryBlock;}

      set{this.tryBlock = value;}

    }

  }

  public class Catch : Statement{

    private Block block;

    private TypeNode type;

    private Expression variable;

    public TypeNode TypeExpression;

    public Catch()

      : base(NodeType.Catch){

    }

    public Catch(Block block, Expression variable, TypeNode type)

      : base(NodeType.Catch){

      this.block = block;

      this.variable = variable;

      this.type = type;

    }

    public Block Block{

      get{return this.block;}

      set{this.block = value;}

    }

    public TypeNode Type{

      get{return this.type;}

      set{this.type = value;}

    }

    public Expression Variable{

      get{return this.variable;}

      set{this.variable = value;}

    }

  }

  public class Finally : Statement{

    private Block block;

    public Finally()

      : base(NodeType.Finally){

    }

    public Finally(Block block)

      : base(NodeType.Finally){

      this.block = block;

    }

    public Block Block{

      get{return this.block;}

      set{this.block = value;}

    }

  }

#endif

  public class EndFinally : Statement{

    public EndFinally()

      : base(NodeType.EndFinally){

    }

  }

#if !MinimalReader || FxCop

  public class Filter : Statement{

    private Block block;

    private Expression expression;

#if FxCop

    internal int handlerEnd;

#endif

    public Filter()

      : base(NodeType.Filter){

    }

    public Filter(Block block, Expression expression)

      : base(NodeType.Filter){

      this.block = block;

      this.expression = expression;

    }

    public Block Block{

      get{return this.block;}

      set{this.block = value;}

    }

    public Expression Expression{

      get{return this.expression;}

      set{this.expression = value;}

    }

  }

#endif

  public class EndFilter : Statement{

    private Expression value;

    public EndFilter()

      : base(NodeType.EndFilter){

    }

    public EndFilter(Expression value)

      : base(NodeType.EndFilter){

      this.value = value;

    }

    public Expression Value{

      get{return this.value;}

      set{this.value = value;}

    }

  }

#if !MinimalReader || FxCop

  public class FaultHandler : Statement{

    private Block block;

#if FxCop

    internal int handlerEnd;

#endif

    public FaultHandler()

      : base(NodeType.FaultHandler){

    }

    public FaultHandler(Block block)

      : base(NodeType.FaultHandler){

      this.block = block;

    }

    public Block Block{

      get{return this.block;}

      set{this.block = value;}

    }

  }

#endif

#if FxCop

  public class ThrowNode : Statement{

#else

  public class Throw : Statement{

#endif

    private Expression expression;

#if FxCop

    public ThrowNode()

      : base(NodeType.Throw){

    }

    public ThrowNode(Expression expression)

      : base(NodeType.Throw){

      this.expression = expression;

    }

#else

    public Throw()

      : base(NodeType.Throw){

    }

    public Throw(Expression expression)

      : base(NodeType.Throw){

      this.expression = expression;

    }

#endif

#if !MinimalReader

    public Throw(Expression expression, SourceContext context)

      : base(NodeType.Throw){

      this.expression = expression;

      this.SourceContext = context;

    }

#endif

    public Expression Expression{

      get{return this.expression;}

      set{this.expression = value;}

    }

  }

#if !MinimalReader

  public class If : Statement{

    public Expression Condition;

    public Block TrueBlock;

    public Block FalseBlock;

    public SourceContext ConditionContext;

    public SourceContext ElseContext;

    public SourceContext EndIfContext;

    public If()

      : base(NodeType.If){

    }

    public If(Expression condition, Block trueBlock, Block falseBlock)

      : base(NodeType.If){

      this.Condition = condition;

      if (condition != null)

        this.ConditionContext = condition.SourceContext;

      this.TrueBlock = trueBlock;

      this.FalseBlock = falseBlock;

    }

  }

  public class For : Statement{

    public Block Body;

    public Expression Condition;

    public StatementList Incrementer;

    public StatementList Initializer;

    public ExpressionList Invariants;

    public For()

      : base(NodeType.For){

    }

    public For(StatementList initializer, Expression condition, StatementList incrementer, Block body)

      : base(NodeType.For){

      this.Body = body;

      this.Condition = condition;

      this.Incrementer = incrementer;

      this.Initializer = initializer;

    }

  }

  public class ForEach : Statement{

    public Block Body;

    public Expression SourceEnumerable;

    public BlockScope ScopeForTemporaryVariables;

    public Expression TargetVariable;

    public TypeNode TargetVariableType;

    public TypeNode TargetVariableTypeExpression;

    public Expression InductionVariable;

    public ExpressionList Invariants;

    public bool StatementTerminatesNormallyIfEnumerableIsNull = true;

    public bool StatementTerminatesNormallyIfEnumeratorIsNull = true;

    public ForEach()

      : base(NodeType.ForEach){

    }

    public ForEach(TypeNode targetVariableType, Expression targetVariable, Expression sourceEnumerable, Block body)

      : base(NodeType.ForEach){

      this.TargetVariable = targetVariable;

      this.TargetVariableType = targetVariableType;

      this.SourceEnumerable = sourceEnumerable;

      this.Body = body;

    }

  }

  public class Exit : Statement{

    public Literal Level;

    public Exit()

      : base(NodeType.Exit){

    }

    public Exit(Literal level)

      : base(NodeType.Exit){

      this.Level = level;

    }

  }

  public class Continue : Statement{

    public Literal Level;

    public Continue()

      : base(NodeType.Continue){

    }

    public Continue(Literal level)

      : base(NodeType.Continue){

      this.Level = level;

    }

  }

  public class Switch : Statement{

    public SwitchCaseList Cases;

    public Expression Expression;

    public Local Nullable;

    public Expression NullableExpression;

    public BlockScope Scope;

    public Switch()

      : base(NodeType.Switch){

    }

    public Switch(Expression expression, SwitchCaseList cases)

      : base(NodeType.Switch){

      this.Cases = cases;

      this.Expression = expression;

    }

  }

  public class SwitchCase : Node{

    public Block Body;

    public Expression Label;

    public SwitchCase()

      : base(NodeType.SwitchCase){

    }

    public SwitchCase(Expression label, Block body)

      : base(NodeType.SwitchCase){

      this.Body = body;

      this.Label = label;

    }

  }

  public class GotoCase : Statement{

    public Expression CaseLabel;

    public GotoCase(Expression caseLabel)

      : base(NodeType.GotoCase){

      this.CaseLabel = caseLabel;

    }

  }

#endif

  public class SwitchInstruction : Statement{

    private Expression expression;

    private BlockList targets;

    public SwitchInstruction()

      : base(NodeType.SwitchInstruction){

    }

    public SwitchInstruction(Expression expression, BlockList targets)

      : base(NodeType.SwitchInstruction){

      this.expression = expression;

      this.targets = targets;

    }

    public Expression Expression{

      get{return this.expression;}

      set{this.expression = value;}

    }

    public BlockList Targets{

      get{return this.targets;}

      set{this.targets = value;}

    }

  }

#if !MinimalReader

  public class Typeswitch : Statement{

    public TypeswitchCaseList Cases;

    public Expression Expression;

    public Typeswitch()

      : base(NodeType.Typeswitch){

    }

    public Typeswitch(Expression expression, TypeswitchCaseList cases)

      : base(NodeType.Typeswitch){

      this.Cases = cases;

      this.Expression = expression;

    }

  }

  public class TypeswitchCase : Node{

    public Block Body;

    public TypeNode LabelType;

    public TypeNode LabelTypeExpression;

    public Expression LabelVariable;

    public TypeswitchCase()

      : base(NodeType.TypeswitchCase){

    }

    public TypeswitchCase(TypeNode labelType, Expression labelVariable, Block body)

      : base(NodeType.TypeswitchCase){

      this.Body = body;

      this.LabelType = labelType;

      this.LabelVariable = labelVariable;

    }

  }

  public class While : Statement{

    public Expression Condition;

    public ExpressionList Invariants;

    public Block Body;

    public While()

      : base(NodeType.While){

    }

    public While(Expression condition, Block body)

      : base(NodeType.While){

      this.Condition = condition;

      this.Body = body;

    }

  }

  public class DoWhile : Statement{

    public Expression Condition;

    public ExpressionList Invariants;

    public Block Body;

    public DoWhile()

      : base(NodeType.DoWhile){

    }

    public DoWhile(Expression condition, Block body)

      : base(NodeType.DoWhile){

      this.Condition = condition;

      this.Body = body;

    }

  }

  public class Repeat : Statement{

    public Expression Condition;

    public Block Body;

    public Repeat()

      : base(NodeType.Repeat){

    }

    public Repeat(Expression condition, Block body)

      : base(NodeType.Repeat){

      this.Condition = condition;

      this.Body = body;

    }

  }

  public class Fixed : Statement{

    public Statement Declarators;

    public Block Body;

    public BlockScope ScopeForTemporaryVariables;

    public Fixed()

      : base(NodeType.Fixed){

    }

  }

  public class Lock : Statement{

    public Expression Guard;

    public Block Body;

    public BlockScope ScopeForTemporaryVariable;

    public Lock()

      : base(NodeType.Lock){

    }

  }

  public class ResourceUse : Statement{

    public Statement ResourceAcquisition;

    public Block Body;

    public BlockScope ScopeForTemporaryVariable;

    public ResourceUse()

      : base(NodeType.ResourceUse){

    }

  }

  public class Goto : Statement{

    public Identifier TargetLabel;

    public Goto()

      : base(NodeType.Goto){

    }

    public Goto(Identifier targetLabel)

      : base(NodeType.Goto){

      this.TargetLabel = targetLabel;

    }

  }

  public class VariableDeclaration : Statement{

    public Expression Initializer;

    public Identifier Name;

    public TypeNode Type;

    public TypeNode TypeExpression;

    public Field Field;

    public VariableDeclaration()

      : base(NodeType.VariableDeclaration){

    }

    public VariableDeclaration(Identifier name, TypeNode type, Expression initializer)

      : base(NodeType.VariableDeclaration){

      this.Initializer = initializer;

      this.Name = name;

      this.Type = type;

    }

  }

  public class LocalDeclaration : Node{

    public Field Field; 

    public Identifier Name;

    public Expression InitialValue;

    /// <summary>

    /// Used when converting a declaration with initializer into an assignment statement.

    /// Usually Nop, but could be set to CopyReference to avoid dereferencing on either side.

    /// </summary>

    public NodeType AssignmentNodeType = NodeType.Nop;

    public LocalDeclaration()

      : base(NodeType.LocalDeclaration){

    }

    public LocalDeclaration(Identifier name, Expression initialValue)

      : base(NodeType.LocalDeclaration){

      this.Name = name;

      this.InitialValue = initialValue;

    }

    public LocalDeclaration(Identifier name, Expression initialValue, NodeType assignmentNodeType)

      : base(NodeType.LocalDeclaration){

      this.Name = name;

      this.InitialValue = initialValue;

      this.AssignmentNodeType = assignmentNodeType;

    }



  }

  public class LocalDeclarationsStatement : Statement{

    public bool Constant;

    public bool InitOnly;

    public TypeNode Type;

    public TypeNode TypeExpression;

    public LocalDeclarationList Declarations;

    public LocalDeclarationsStatement()

      : base(NodeType.LocalDeclarationsStatement){

    }

    public LocalDeclarationsStatement(LocalDeclaration ldecl, TypeNode type)

      : base(NodeType.LocalDeclarationsStatement){

      Declarations = new LocalDeclarationList();

      Declarations.Add(ldecl);

      this.Type = type;

    }

  }

  public class StatementSnippet : Statement{

    public IParserFactory ParserFactory;



    public StatementSnippet()

      : base(NodeType.StatementSnippet){

    }

    public StatementSnippet(IParserFactory parserFactory, SourceContext sctx)

      : base(NodeType.StatementSnippet){

      this.ParserFactory = parserFactory;

      this.SourceContext = sctx;

    }

  }

  /// <summary>

  /// Associates an identifier with a type or a namespace or a Uri or a list of assemblies. 

  /// In C# alias identifiers are used as root identifiers in qualified expressions, or as identifier prefixes.

  /// </summary>

  public class AliasDefinition : Node{

    

    /// <summary>The identifier that serves as an alias for the type, namespace, Uri or list of assemblies.</summary>

    public Identifier Alias;



    /// <summary>The list of assemblies being aliased.</summary>

    public AssemblyReferenceList AliasedAssemblies;

    

    /// <summary>The expression that was (or should be) resolved into a type, namespace or Uri.</summary>

    public Expression AliasedExpression;

    

    /// <summary>The namespace being aliased.</summary>

    public Identifier AliasedNamespace;

    

    /// <summary>A reference to the type being aliased.</summary>

    public TypeReference AliasedType;

    

    /// <summary>The Uri being aliased.</summary>

    public Identifier AliasedUri;



    /// <summary>

    /// If an alias definition conflicts with a type definition and this causes an ambiguity, the conflicting type is stored here

    /// by the code that detects the ambiguity. A later visitor is expected to report an error if this is not null.

    /// </summary>

    public TypeNode ConflictingType;



    public bool RestrictToInterfaces;

    public bool RestrictToClassesAndInterfaces;



    public AliasDefinition()

      : base(NodeType.AliasDefinition){

    }

    public AliasDefinition(Identifier alias, Expression aliasedExpression)

      : base(NodeType.AliasDefinition){

      this.Alias = alias;

      this.AliasedExpression = aliasedExpression;

    }

    public AliasDefinition(Identifier alias, Expression aliasedExpression, SourceContext sctx)

      : base(NodeType.AliasDefinition){

      this.Alias = alias;

      this.AliasedExpression = aliasedExpression;

      this.SourceContext = sctx;

    }

  }

  public class UsedNamespace : Node{

    public Identifier Namespace;

    public Identifier URI;

    public UsedNamespace()

      : base(NodeType.UsedNamespace){

    }

    public UsedNamespace(Identifier Namespace)

      : base(NodeType.UsedNamespace){

      this.Namespace = Namespace;

    }

    public UsedNamespace(Identifier Namespace, SourceContext sctx)

      : base(NodeType.UsedNamespace){

      this.Namespace = Namespace;

      this.SourceContext = sctx;

    }

  }

#endif

#if !FxCop

  public class ExceptionHandler : Node{

    private NodeType handlerType;

    private Block tryStartBlock;

    private Block blockAfterTryEnd;

    private Block handlerStartBlock;

    private Block blockAfterHandlerEnd;

    private Block filterExpression;

    private TypeNode filterType;

    public ExceptionHandler()

      : base(NodeType.ExceptionHandler){

    }

    public NodeType HandlerType{

      get{return this.handlerType;}

      set{this.handlerType = value;}

    }

    public Block TryStartBlock{

      get{return this.tryStartBlock;}

      set{this.tryStartBlock = value;}

    }

    public Block BlockAfterTryEnd{

      get{return this.blockAfterTryEnd;}

      set{this.blockAfterTryEnd = value;}

    }

    public Block HandlerStartBlock{

      get{return this.handlerStartBlock;}

      set{this.handlerStartBlock = value;}

    }

    public Block BlockAfterHandlerEnd{

      get{return this.blockAfterHandlerEnd;}

      set{this.blockAfterHandlerEnd = value;}

    }

    public Block FilterExpression{

      get{return this.filterExpression;}

      set{this.filterExpression = value;}

    }

    public TypeNode FilterType{

      get{return this.filterType;}

      set{this.filterType = value;}

    }

  }

#endif

  public class AttributeNode : Node{

#if !MinimalReader

    public bool IsPseudoAttribute;

#endif

    public AttributeNode()

      : base(NodeType.Attribute){

    }

    public AttributeNode(Expression constructor, ExpressionList expressions)

      : base(NodeType.Attribute){

      this.constructor = constructor;

      this.expressions = expressions;

      this.target = AttributeTargets.All;

    }

#if !MinimalReader

    public AttributeNode(Expression constructor, ExpressionList expressions, AttributeTargets target)

      : base(NodeType.Attribute){

      this.constructor = constructor;

      this.expressions = expressions;

      this.target = target;

    }

#endif

    private Expression constructor;

    public Expression Constructor{

      get{return this.constructor;}

      set{this.constructor = value;}

    }

    private ExpressionList expressions;

    /// <summary>

    /// Invariant: positional arguments occur first and in order in the expression list. Named arguments

    /// follow posititional arguments in any order.

    /// </summary>

    public ExpressionList Expressions{

      get{return this.expressions;}

      set{this.expressions = value;}

    }

    private AttributeTargets target;

    public AttributeTargets Target{

      get{return this.target;}

      set{this.target = value;}

    }

    private bool allowMultiple;

    public virtual bool AllowMultiple{

      get{

        if (this.usageAttribute == null) this.GetUsageInformation();

        return this.allowMultiple;

      }

      set{

        this.allowMultiple = value;

      }

    }

    private bool inherited;

    public virtual bool Inherited{

      get{

        if (this.usageAttribute == null) this.GetUsageInformation();

        return this.inherited;

      }

      set{

        this.inherited = value;

      }

    }

    private AttributeTargets validOn;

    public virtual AttributeTargets ValidOn{

      get{

        if (this.usageAttribute == null) this.GetUsageInformation();

        return this.validOn;

      }

      set{

        this.validOn = value;

      }

    }

    private TypeNode type;

    public virtual TypeNode Type{

      get{

        if (this.type == null){

          MemberBinding mb = this.Constructor as MemberBinding;

          Member cons = mb == null ? null : mb.BoundMember;

          this.type = cons == null ? null : cons.DeclaringType;

        }

        return this.type;

      }

      set{

        this.type = value;

      }

    }

    private AttributeNode usageAttribute;

    private void GetUsageInformation(){

      AttributeNode attr = null;

      TypeNode attrType = this.Type;

      while (attrType != null){

        attr = attrType.GetAttribute(SystemTypes.AttributeUsageAttribute);

        if (attr != null) break;

        attrType = attrType.BaseType;

      }

      if (attr == null){

        this.usageAttribute = AttributeNode.DoesNotExist;

        return;

      }

      ExpressionList args = attr.Expressions;

      if (args == null || args.Count < 1) return;

      Literal lit = args[0] as Literal;

      if (lit == null || !(lit.Value is int)) {

#if ExtendedRuntime

        MemberBinding mb = args[0] as MemberBinding;

        if (mb != null) {

          Field f = mb.BoundMember as Field;

          if (f != null && f.IsLiteral) {

            lit = f.Initializer as Literal;

          }

        }

        if (lit == null || !(lit.Value is int))

#endif

          return;

      }

      //^ assert lit.Value != null;

      this.validOn = (AttributeTargets)(int)lit.Value;

      for (int i = 1, n = args.Count; i < n; i++){

        NamedArgument narg = args[i] as NamedArgument;

        if (narg == null || narg.Name == null) continue;

        lit = narg.Value as Literal;

        if (lit == null) continue;

        if (narg.Name.UniqueIdKey == StandardIds.AllowMultiple.UniqueIdKey){

          if (lit.Value == null || !(lit.Value is bool)) continue;

          this.allowMultiple = (bool)lit.Value;

        }else if (narg.Name.UniqueIdKey == StandardIds.Inherited.UniqueIdKey){

          if (lit.Value == null || !(lit.Value is bool)) continue;

          this.inherited = (bool)lit.Value;

        }          

      }

    }

    public static readonly AttributeNode DoesNotExist = new AttributeNode();

#if !NoReflection

    public virtual System.Attribute GetRuntimeAttribute(){

      MemberBinding mb = this.Constructor as MemberBinding;

      if (mb == null) return null;

      InstanceInitializer constr = mb.BoundMember as InstanceInitializer;

      if (constr == null) return null;

      ParameterList parameters = constr.Parameters;

      int paramCount = parameters == null ? 0 : parameters.Count;

      object[] argumentValues = new object[paramCount];

      ExpressionList argumentExpressions = this.Expressions;

      int exprCount = argumentExpressions == null ? 0 : argumentExpressions.Count;

      for (int i = 0, j = 0; i < paramCount; i++){

        if (j >= exprCount) return null;

        //^ assert argumentExpressions != null;

        Expression argExpr = argumentExpressions[j++];

        Literal lit = argExpr as Literal;

        if (lit == null) continue;

        argumentValues[i] = this.GetCoercedLiteralValue(lit.Type, lit.Value);

      }

      System.Attribute attr = this.ConstructAttribute(constr, argumentValues);

      if (attr == null) return null;

      for (int i = 0; i < exprCount; i++){

        //^ assert argumentExpressions != null;

        NamedArgument namedArg = argumentExpressions[i] as NamedArgument;

        if (namedArg == null) continue;

        if (namedArg.Name == null) continue;

        Literal lit = namedArg.Value as Literal;

        if (lit == null) continue;

        object val = this.GetCoercedLiteralValue(lit.Type, lit.Value);

        if (namedArg.IsCustomAttributeProperty){

          TypeNode t = constr.DeclaringType;

          while (t != null){

            Property prop = t.GetProperty(namedArg.Name);

            if (prop != null){

              this.SetAttributeProperty(prop, attr, val);

              t = null;

            }else

              t = t.BaseType;

          }

        }else{

          TypeNode t = constr.DeclaringType;

          while (t != null){

            Field f = constr.DeclaringType.GetField(namedArg.Name);

            if (f != null){

              System.Reflection.FieldInfo fieldInfo = f.GetFieldInfo();

              if (fieldInfo != null) fieldInfo.SetValue(attr, val);

              t = null;

            }else

              t = t.BaseType;

          }

        }

      }

      return attr;

    }

    /// <summary>

    /// Gets the value of the literal coercing literals of TypeNode, EnumNode, TypeNode[], and EnumNode[] as needed.

    /// </summary>

    /// <param name="type">A TypeNode representing the type of the literal</param>

    /// <param name="value">The value of the literal</param>

    /// <returns>An object that has been coerced to the appropiate runtime type</returns>

    protected object GetCoercedLiteralValue(TypeNode type, object value){

      if (type == null || value == null) return null;

      switch (type.typeCode) {

        case ElementType.Class: 

          return ((TypeNode)value).GetRuntimeType();

        case ElementType.ValueType: 

          return System.Enum.ToObject(type.GetRuntimeType(), value);

        case ElementType.SzArray: 

          return this.GetCoercedArrayLiteral((ArrayType)type, (Array)value);

        default:

          Literal lit = value as Literal;

          if (lit != null && type == CoreSystemTypes.Object && lit.Type is EnumNode)

            return this.GetCoercedLiteralValue(lit.Type, lit.Value);

          break;

      }

      return value;

    }

    /// <summary>

    /// Gets the array literal in arrayValue coercing TypeNode[] and EnumNode[] as needed.

    /// </summary>

    /// <param name="arrayType">A TypeNode representing the array type</param>

    /// <param name="arrayValue">The value of the array literal to coerce</param>

    /// <returns>An Array object that has been coerced to the appropriate runtime type</returns>

    protected Array GetCoercedArrayLiteral(ArrayType arrayType, Array arrayValue){

      if (arrayType == null) return null;

      if (arrayValue == null) return null;

      // Multi-dimensional arrays are not legal in attribute instances according section 17.1.3 of the C# 1.0 spec

      if (arrayValue.Rank != 1) return null;

      TypeNode elemType = arrayType.ElementType;

      if (elemType.typeCode != ElementType.ValueType && elemType.typeCode != ElementType.Class)

        return arrayValue;

      int arraySize = arrayValue.GetLength(0);

      Type et = elemType.GetRuntimeType();

      if (et == null) return null;

      Array val = Array.CreateInstance(et, arraySize);

      for (int i = 0; i < arraySize; i++)

        val.SetValue(this.GetCoercedLiteralValue(elemType, arrayValue.GetValue(i)), i);

      return val;

    }

    private void SetAttributeProperty(Property/*!*/ prop, System.Attribute attr, object val) {

      //This could execute partially trusted code, so set up a very restrictive execution environment

      //TODO: skip this if the attribute is from a trusted assembly

      System.Reflection.PropertyInfo propInfo = prop.GetPropertyInfo();

      if (propInfo == null) return;

      //Because we invoke the setter through reflection, a stack walk is performed. The following two commented-out statements

      //would cause the stack walk to fail.

      //For now, we will run the setter in full trust until we work around this.

      //For VS2005 and later, we will construct a DynamicMethod, wrap it in a delegate, and invoke that.

      

      //System.Security.PermissionSet perm = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);

      //perm.PermitOnly();

      try{

        propInfo.SetValue(attr, val, null);

      }catch{}     

    }

    private System.Attribute ConstructAttribute(InstanceInitializer/*!*/ constr, object[] argumentValues){

      //This could execute partially trusted code, so set up a very restrictive execution environment

      //TODO: skip this if the attribute is from a trusted assembly

      System.Reflection.ConstructorInfo consInfo = constr.GetConstructorInfo();

      if (consInfo == null) return null;

      //Because we invoke the constructor through reflection, a stack walk is performed. The following two commented-out statements

      //would cause the stack walk to fail.

      //For VS2003 and earlier, we will run the constructor in full trust.

      //For VS2005 and later, we will construct a DynamicMethod, wrap it in a delegate, and invoke that.

      

      //System.Security.PermissionSet perm = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);

      //perm.PermitOnly();

      try{

        return consInfo.Invoke(argumentValues) as System.Attribute;

      }catch{}     

      return null;

    }

#endif

    public Expression GetPositionalArgument(int position){

      if (this.Expressions == null || this.Expressions.Count <= position) return null;

      Expression e = this.Expressions[position];

      NamedArgument na = e as NamedArgument;

      if (na != null) return null;

      return e;

    }

    public Expression GetNamedArgument(Identifier name) {

      if (name == null || this.Expressions == null) return null;

      foreach (Expression e in this.Expressions) {

        NamedArgument na = e as NamedArgument;

        if (na == null) continue;

        if (na.Name == null) continue;

        if (na.Name.UniqueIdKey == name.UniqueIdKey) return na.Value;

      }

      return null;

    }

  }

  public class SecurityAttribute : Node{

    public SecurityAttribute()

      : base(NodeType.SecurityAttribute){

    }

    private System.Security.Permissions.SecurityAction action;

    public System.Security.Permissions.SecurityAction Action{

      get{return this.action;}

      set{this.action = value;}

    }

    private AttributeList permissionAttributes;

    public AttributeList PermissionAttributes{

      get{return this.permissionAttributes;}

      set{this.permissionAttributes = value;}

    }

    protected string serializedPermissions;

    public string SerializedPermissions{

      get{

#if !NoReflection || FxCop

        if (this.serializedPermissions == null && this.PermissionAttributes != null){

          lock (this){

            if (this.serializedPermissions != null) return this.serializedPermissions;

            System.Security.PermissionSet permissions = this.Permissions;

            if (permissions == null) return null;

            System.Security.SecurityElement xml = permissions.ToXml();

            if (xml == null) return null;

            this.serializedPermissions = xml.ToString();

            //TODO: if the target platform is different from the host platform, replace references to host platform

            //assemblies with references to target platform assemblies

          }

        }

#endif

        return this.serializedPermissions;

      }

      set{

        this.serializedPermissions = value;

      }

    }

#if !NoReflection || FxCop

    protected System.Security.PermissionSet permissions;

    public System.Security.PermissionSet Permissions{

      get{

        if (this.permissions == null){

          lock (this){

            if (this.permissions != null) return this.permissions;

            System.Security.PermissionSet permissions = null;

#if !FxCop

            if (this.PermissionAttributes != null){

              permissions = this.InstantiatePermissionAttributes();

            }else if (this.serializedPermissions != null){

              permissions = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);

              permissions.FromXml(this.GetSecurityElement());

            }

#elif !TestBuild

            permissions = PermissionsHelper.GetPermissions(this);

#endif

            this.permissions = permissions;

          }

        }

        return this.permissions;

      }

      set{

        this.permissions = value;

      }

    }

#endif

#if !NoReflection

    protected System.Security.SecurityElement GetSecurityElement(){

#if WHIDBEY

      return System.Security.SecurityElement.FromString(this.serializedPermissions);

#else

      System.Reflection.Assembly mscorlib = CoreSystemTypes.SystemAssembly.GetRuntimeAssembly();

      if (mscorlib == null) { Debug.Fail(""); return null; }

      Type parserType = mscorlib.GetType("System.Security.Util.Parser", true, false);

      if (parserType == null) { Debug.Fail(""); return null; }

      System.Reflection.MethodInfo getTopElement = parserType.GetMethod("GetTopElement", BindingFlags.NonPublic|BindingFlags.Instance, null, new Type[]{}, null);

      if (getTopElement == null) { Debug.Fail(""); return null; }

      object parser = Activator.CreateInstance(parserType, BindingFlags.Instance|BindingFlags.NonPublic, null, new Object[]{this.serializedPermissions}, null);

      return (System.Security.SecurityElement)getTopElement.Invoke(parser, null);

#endif

    }

    protected System.Security.PermissionSet InstantiatePermissionAttributes(){

      System.Security.PermissionSet permissions = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);

      AttributeList permissionAttributes = this.PermissionAttributes;

      for (int i = 0, n = permissionAttributes == null ? 0 : permissionAttributes.Count; i < n; i++){

        //^ assert permissionAttributes != null;

        object result = this.GetPermissionOrSetOfPermissionsFromAttribute(permissionAttributes[i]);

        if (result == null) continue;

        if (result is System.Security.PermissionSet)

          permissions = permissions.Union((System.Security.PermissionSet)result);

        else{

          System.Security.IPermission permission = result as System.Security.IPermission;

          if (permission == null) continue;

          permissions.AddPermission(permission);

        }

      }

      return permissions;

    }

    protected object GetPermissionOrSetOfPermissionsFromAttribute(AttributeNode attr){

      if (attr == null) return null;

      System.Security.Permissions.SecurityAttribute secAttr = attr.GetRuntimeAttribute() as System.Security.Permissions.SecurityAttribute;

      if (secAttr == null) return null;

      System.Security.Permissions.PermissionSetAttribute pSetAttr = secAttr as System.Security.Permissions.PermissionSetAttribute;

      if (pSetAttr != null)

        return pSetAttr.CreatePermissionSet();

      else

        return this.CreatePermission(secAttr);

    }

    private System.Security.IPermission CreatePermission(System.Security.Permissions.SecurityAttribute/*!*/ secAttr) {

      //This could execute partially trusted code, so set up a very restrictive execution environment

      System.Security.PermissionSet perm = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);

      //TODO: add permissions if the attribute is from a trusted assembly

      perm.PermitOnly(); 

      try{

        return secAttr.CreatePermission(); 

      }catch{}

      return null;

    }

#endif

  }

  public struct Resource{

    private bool isPublic;

    private string name;

    private Module definingModule;

    private byte[] data;

    public bool IsPublic{

      get{return this.isPublic;}

      set{this.isPublic = value;}

    }

    public string Name{

      get{return this.name;}

      set{this.name = value;}

    }

    public Module DefiningModule{

      get{return this.definingModule;}

      set{this.definingModule = value;}

    }

    public byte[] Data{

      get{return this.data;}

      set{this.data = value;}

    }

  }

  public struct Win32Resource{

    private string typeName;

    private int typeId;

    private string name;

    private int id;

    private int languageId;

    private int codePage;

    private byte[] data;

    public string TypeName {

      get{return this.typeName;}

      set{this.typeName = value;}

    }

    public int TypeId{

      get{return this.typeId;}

      set{this.typeId = value;}

    }

    public string Name{

      get{return this.name;}

      set{this.name = value;}

    }

    public int Id{

      get{return this.id;}

      set{this.id = value;}

    }

    public int LanguageId{

      get{return this.languageId;}

      set{this.languageId = value;}

    }

    public int CodePage{

      get{return this.codePage;}

      set{this.codePage = value;}

    }

    public byte[] Data{

      get{return this.data;}

      set{this.data = value;}

    }

  }

#if FxCop

  public class ModuleNode : Node, IDisposable{

#else

  public class Module : Node, IDisposable{

#endif

    internal Reader reader;

    public delegate void TypeNodeListProvider(Module/*!*/ module);

    protected TypeNodeListProvider provideTypeNodeList;

    public delegate TypeNode TypeNodeProvider(Identifier/*!*/ @namespace, Identifier/*!*/ name);

    protected TypeNodeProvider provideTypeNode;

    protected TrivialHashtable namespaceTable = new TrivialHashtable();

    protected NamespaceList namespaceList;

    protected int savedTypesLength;

    public delegate void CustomAttributeProvider(Module/*!*/ module);

    protected CustomAttributeProvider provideCustomAttributes;

    public delegate void ResourceProvider(Module/*!*/ module);

    protected ResourceProvider provideResources;

    public delegate AssemblyNode AssemblyReferenceResolver(AssemblyReference/*!*/ assemblyReference, Module/*!*/ referencingModule);

    public event AssemblyReferenceResolver AssemblyReferenceResolution;

    public event AssemblyReferenceResolver AssemblyReferenceResolutionAfterProbingFailed;

#if !NoXml

    public delegate XmlDocument DocumentationResolver(Module referencingModule);

    public event DocumentationResolver DocumentationResolution = null;

#endif

#if !MinimalReader

    public bool IsNormalized;

#endif

#if !NoWriter

    public bool UsePublicKeyTokensForAssemblyReferences = true;

#endif

    internal int FileAlignment = 512;

    internal readonly static object GlobalLock = new object();

#if !NoWriter

    public bool StripOptionalModifiersFromLocals = true;

#endif

#if FxCop

    public ModuleNode()

#else

    public Module()

#endif

      : base(NodeType.Module){

#if !MinimalReader

      this.IsNormalized = false;

#endif

    }

#if FxCop

    public ModuleNode(TypeNodeProvider provider, TypeNodeListProvider listProvider, CustomAttributeProvider provideCustomAttributes, ResourceProvider provideResources)

#else

    public Module(TypeNodeProvider provider, TypeNodeListProvider listProvider, CustomAttributeProvider provideCustomAttributes, ResourceProvider provideResources)

#endif

      : base(NodeType.Module){

      this.provideCustomAttributes = provideCustomAttributes;

      this.provideResources = provideResources;

      this.provideTypeNode = provider;

      this.provideTypeNodeList = listProvider;

#if !MinimalReader

      this.IsNormalized = true;

#endif

    }

    public virtual void Dispose(){ 

      if (this.reader != null) this.reader.Dispose();

      this.reader = null;

      ModuleReferenceList mrefs = this.moduleReferences;

      for (int i = 0, n = mrefs == null ? 0 : mrefs.Count; i < n; i++){

        //^ assert mrefs != null;

        ModuleReference mr = mrefs[i];

        if (mr != null && mr.Module == null) continue;

        mr.Module.Dispose();

      }

      this.moduleReferences = null;

    }

    private AssemblyReferenceList assemblyReferences;

    public AssemblyReferenceList AssemblyReferences{

      get{return this.assemblyReferences;}

      set{this.assemblyReferences = value;}

    }

    private AssemblyNode containingAssembly;

    /// <summary>The assembly, if any, that includes this module in its ModuleReferences.</summary>

    public AssemblyNode ContainingAssembly{

      get{return this.containingAssembly;}

      set{this.containingAssembly = value;}

    }

    private ushort dllCharacteristics;

    public ushort DllCharacteristics {

      get { return this.dllCharacteristics; }

      set { this.dllCharacteristics = value; }

    }

    private string directory;

    public string Directory{

      get{return this.directory;}

      set{this.directory = value;}

    }

    private AssemblyHashAlgorithm hashAlgorithm = AssemblyHashAlgorithm.SHA1;

    public AssemblyHashAlgorithm HashAlgorithm{

      get{return this.hashAlgorithm;}

      set{this.hashAlgorithm = value;}

    }

    private byte[] hashValue;

    public byte[] HashValue{

      get{return this.hashValue;}

      set{this.hashValue = value;}

    }

    private ModuleKindFlags kind;

    /// <summary>An enumeration that indicates if the module is an executable, library or resource, and so on.</summary>

    public ModuleKindFlags Kind{

      get{return this.kind;}

      set{this.kind = value;}

    }

    private string location;

    /// <summary>The path of the file from which this module or assembly was loaded or will be stored in.</summary>

    public string Location{

      get{return this.location;}

      set{this.location = value;}

    }

    private System.Guid mvid;

    public System.Guid Mvid{

      get{return this.mvid;}

      set{this.mvid = value;}

    }

    private string targetRuntimeVersion;

    /// <summary>Identifies the version of the CLR that is required to load this module or assembly.</summary>

    public string TargetRuntimeVersion{

      get{return this.targetRuntimeVersion;}

      set{this.targetRuntimeVersion = value;}

    }

    private int linkerMajorVersion = 6;

    public int LinkerMajorVersion{

      get{return this.linkerMajorVersion;}

      set{this.linkerMajorVersion = value;}

    }

    private int linkerMinorVersion;

    public int LinkerMinorVersion{

      get{return this.linkerMinorVersion;}

      set{this.linkerMinorVersion = value;}

    }

    private int metadataFormatMajorVersion;

    public int MetadataFormatMajorVersion{

      get{return this.metadataFormatMajorVersion;}

      set{this.metadataFormatMajorVersion = value;}

    }

    private int metadataFormatMinorVersion;

    public int MetadataFormatMinorVersion{

      get{return this.metadataFormatMinorVersion;}

      set{this.metadataFormatMinorVersion = value;}

    }

    private string name;

    /// <summary>The name of the module or assembly. Includes the file extension if the module is not an assembly.</summary>

    public string Name{

      get{return this.name;}

      set{this.name = value;}

    }

    private PEKindFlags peKind = PEKindFlags.ILonly;

    public PEKindFlags PEKind{

      get{return this.peKind;}

      set{this.peKind = value;}

    }

    private bool trackDebugData;

    public bool TrackDebugData{

      get{return this.trackDebugData;}

      set{this.trackDebugData = value;}

    }

#if !FxCop

    private ArrayList metadataImportErrors;

    /// <summary>

    /// If any exceptions were encountered while reading in this module, they are recorded here. Since reading is lazy,

    /// this list can grow dynamically during the use of a module.

    /// </summary>

    public ArrayList MetadataImportErrors{

      get{return this.metadataImportErrors;}

      set{this.metadataImportErrors = value;}

    }

#endif

    protected AttributeList attributes;

    /// <summary>

    /// The attributes associated with this module or assembly. This corresponds to C# custom attributes with the assembly or module target specifier.

    /// </summary>

    public virtual AttributeList Attributes{

      get{

        if (this.attributes != null) return this.attributes;

        if (this.provideCustomAttributes != null){

          lock (Module.GlobalLock){

            if (this.attributes == null)

              this.provideCustomAttributes(this);

          }

        }else

          this.attributes = new AttributeList();

        return this.attributes;

      }

      set{

        this.attributes = value;

      }

    }



    protected SecurityAttributeList securityAttributes;

    /// <summary>

    /// Declarative security for the module or assembly.

    /// </summary>

    public virtual SecurityAttributeList SecurityAttributes{

      get{

        if (this.securityAttributes != null) return this.securityAttributes;

        if (this.provideCustomAttributes != null){

          AttributeList dummy = this.Attributes; //As a side effect, this.securityAttributes gets populated

          if (dummy != null) dummy = null;

        }else

          this.securityAttributes = new SecurityAttributeList();

        return this.securityAttributes;

      }

      set{

        this.securityAttributes = value;

      }

    }

#if !MinimalReader

    /// <summary>The source code, if any, corresponding to the value in Documentation.</summary>

    public Node DocumentationNode;

#endif

#if !NoXml

    protected XmlDocument documentation;

    /// <summary>An XML Document Object Model for a document containing all of the documentation comments applicable to members

    /// defined in this module.</summary>

    public virtual XmlDocument Documentation{

      get{

        XmlDocument documentation = this.documentation;

        if (documentation != null) return documentation;

        if (this.DocumentationResolution != null)

          documentation = this.documentation = this.DocumentationResolution(this);

        if (documentation != null) return documentation;

        XmlDocument doc = null;

        if (this.Directory != null && this.Name != null){

          string fileName = this.Name+".xml";

          System.Globalization.CultureInfo cc = System.Globalization.CultureInfo.CurrentUICulture;

          while (cc != null && cc != System.Globalization.CultureInfo.InvariantCulture) {

            doc = this.ProbeForXmlDocumentation(this.Directory, cc.Name, fileName);

            if (doc != null) break;

            cc = cc.Parent;

          }

          if (doc == null)

            doc = this.ProbeForXmlDocumentation(this.Directory, null, fileName);

        }

        if (doc == null) doc = new XmlDocument();

        return this.documentation = doc;

      }

      set{

        this.documentation = value;

      }

    }

    public virtual XmlDocument ProbeForXmlDocumentation(string dir, string subDir, string fileName){

      try{

        if (dir == null || fileName == null) return null;

        if (subDir != null) dir = Path.Combine(dir, subDir);

        string docFileName = Path.Combine(dir, fileName);

        if (File.Exists(docFileName)){

          XmlDocument doc = new XmlDocument();

          using (TextReader reader = File.OpenText(docFileName)){

            doc.Load(reader);

            return doc;

          }

        }

      }catch(Exception e){

        if (this.MetadataImportErrors == null) this.MetadataImportErrors = new ArrayList();

        this.MetadataImportErrors.Add(e);

      }

      return null;

    }

#endif

    protected internal static readonly Method NoSuchMethod = new Method();

    protected Method entryPoint;

    /// <summary>If this module is an executable, this method is the one that gets called to start the execution of managed code.</summary>

    public virtual Method EntryPoint{

      get{

        if (this.entryPoint == null){

          if (this.provideCustomAttributes != null){

            AttributeList dummy = this.Attributes; //Gets the entry point as a side effect

            if (dummy != null) dummy = null;

          }else

            this.entryPoint = Module.NoSuchMethod;

        }

        if (this.entryPoint == Module.NoSuchMethod) return null;

        return this.entryPoint;

      }

      set{

        this.entryPoint = value;

      }

    }

    protected ModuleReferenceList moduleReferences;

    /// <summary>The list of modules (excluding assemblies) defining members that are referred to in this module or assembly.</summary>

    public ModuleReferenceList ModuleReferences{

      get{

        //Populating the type list may cause module references to be added

        if (this.Types == null) return this.moduleReferences;

        return this.moduleReferences;

      }

      set{

        this.moduleReferences = value;

      }

    }

#if !MinimalReader

    public virtual bool ContainsModule(Module module) {

      if (module == null || this.ModuleReferences == null || this.ModuleReferences.Count == 0) return false;

      int n = this.ModuleReferences.Count;

      for (int i = 0; i < n; ++i) {

        ModuleReference mr = this.ModuleReferences[i];

        if (mr == null) continue;

        if (mr.Module == module)

          return true;

      }

      return false;

    }

#endif

    protected ResourceList resources;

    /// <summary>

    /// A list of managed resources linked or embedded into this module or assembly.

    /// </summary>

    public virtual ResourceList Resources{

      get{

        if (this.resources != null) return this.resources;

        if (this.provideResources != null){

          lock (Module.GlobalLock){

            if (this.resources == null)

              this.provideResources(this);

          }

        }else

          this.resources = new ResourceList();

        return this.resources;

      }

      set{

        this.resources = value;

      }

    }

    protected Win32ResourceList win32Resources;

    /// <summary>

    /// A list of Win32 resources embedded in this module or assembly.

    /// </summary>

    public virtual Win32ResourceList Win32Resources{

      get{

        if (this.win32Resources != null) return this.win32Resources;

        if (this.provideResources != null){

          ResourceList dummy = this.Resources; //gets the win32 resources as as side effect

          if (dummy != null) dummy = null;

        }else

          this.win32Resources = new Win32ResourceList();

        return this.win32Resources;

      }

      set{

        this.win32Resources = value;

      }

    }

#if !NoWriter

    public virtual void AddWin32ResourceFile(string win32ResourceFilePath){

      if (win32ResourceFilePath == null) return;

      Writer.AddWin32ResourceFileToModule(this, win32ResourceFilePath);

    }

    public virtual void AddWin32ResourceFile(Stream win32ResourceStream){

      if (win32ResourceStream == null) return;

      Writer.AddWin32ResourceFileToModule(this, win32ResourceStream);

    }

    public virtual void AddWin32Icon(string win32IconFilePath){

      if (win32IconFilePath == null) return;

      Writer.AddWin32Icon(this, win32IconFilePath);

    }

    public virtual void AddWin32Icon(Stream win32IconStream){

      Writer.AddWin32Icon(this, win32IconStream);

    }

    public void AddWin32VersionInfo(CompilerOptions options){

      if (options == null) return;

      Writer.AddWin32VersionInfo(this, options);

    }

#endif

    /// <summary>

    /// Gets the first attribute of the given type in the custom attribute list of this module. Returns null if none found.

    /// This should not be called until the module has been processed to replace symbolic references

    /// to members with references to the actual members.

    /// </summary>

    public virtual AttributeNode GetAttribute(TypeNode attributeType){

      AttributeList attributes = this.GetAttributes(attributeType, 1);

      if (attributes != null && attributes.Count > 0)

        return attributes[0];

      return null;

    }

	

    public virtual AttributeList GetAttributes(TypeNode attributeType){

      return GetAttributes(attributeType, Int32.MaxValue);

    }



    public virtual AttributeList GetAttributes(TypeNode attributeType, int maxCount){

      AttributeList foundAttributes = new AttributeList();

      if (attributeType == null) return foundAttributes;

      AttributeList attributes = this.Attributes;

      for (int i = 0, count = 0, n = attributes == null ? 0 : attributes.Count; i < n && count < maxCount; i++){

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null){

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != attributeType) continue;

          foundAttributes.Add(attr);

          count++;

          continue;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit == null) continue;

        if ((lit.Value as TypeNode) != attributeType) continue;

        foundAttributes.Add(attr);

        count++;

      }

      return foundAttributes;

    }

#if !NoXml

    protected TrivialHashtable memberDocumentationCache;

    public TrivialHashtable GetMemberDocumentationCache(){

      TrivialHashtable cache = this.memberDocumentationCache;

      if (cache != null) return cache;

      lock(this){

        if (this.memberDocumentationCache != null) return this.memberDocumentationCache;

        XmlDocument doc = this.Documentation;

        if (doc == null && this.ContainingAssembly != null && this.ContainingAssembly != this)

          return this.memberDocumentationCache = this.ContainingAssembly.memberDocumentationCache;

        cache = this.memberDocumentationCache = new TrivialHashtable();

        if (doc == null) return cache;

        XmlNode docElem = doc.DocumentElement;

        if (docElem == null) return cache;

        XmlNode membersNode = null;

        if (docElem.HasChildNodes){

          foreach (XmlNode dec in docElem.ChildNodes)

            if (dec.Name == "members"){membersNode = dec; break;}

        }

        if (membersNode == null) return cache;

        if (membersNode.HasChildNodes){

          foreach (XmlNode member in membersNode.ChildNodes){

            if (member.Name != "member") continue;

            XmlNode nameAttr = member.Attributes.GetNamedItem("name");

            if (nameAttr == null) continue;                   

            cache[Identifier.For(nameAttr.Value).UniqueIdKey] = member;

          }

        }

        return cache;

      }

    }

#endif

    protected TrivialHashtable validNamespaces;

    public NamespaceList GetNamespaceList(){

      if (this.reader != null) return this.GetNamespaceListFromReader();

#if !MinimalReader

      TypeNodeList types = this.Types;

      int n = types == null ? 0 : types.Count;

      if (this.namespaceList == null || n > this.savedTypesLength){

        lock(this){

          if (this.namespaceList != null && this.types != null && this.types.Count == this.savedTypesLength)

            return this.namespaceList;

          NamespaceList nsList = this.namespaceList = new NamespaceList();

          TrivialHashtable nsTable = this.validNamespaces = new TrivialHashtable();

          for (int i = 0; i < n; i++){

            //^ assert this.types != null;

            TypeNode t = this.types[i];

            if (t == null) continue;

            if (t.Namespace == null) t.Namespace = Identifier.Empty;

            Namespace ns = nsTable[t.Namespace.UniqueIdKey] as Namespace;

            if (ns != null){

              if (t.IsPublic) ns.isPublic = true;

              ns.Types.Add(t); continue;

            }

            ns = new Namespace(t.Namespace);

            ns.isPublic = t.IsPublic;

            ns.Types = new TypeNodeList();

            ns.Types.Add(t);

            nsTable[t.Namespace.UniqueIdKey] = ns;

            nsList.Add(ns);

          }

        }

      }

#endif

      return this.namespaceList;

    }

    private NamespaceList GetNamespaceListFromReader()

      //^ requires this.reader != null;

    {

      if (this.namespaceList == null){

        lock (Module.GlobalLock) {

          this.reader.GetNamespaces();

          NamespaceList nsList = this.namespaceList = this.reader.namespaceList;

          TrivialHashtable nsTable = this.validNamespaces = new TrivialHashtable();

          for (int i = 0, n = nsList == null ? 0 : nsList.Count; i < n; i++) {

            //^ assert nsList != null;

            Namespace ns = nsList[i];

            if (ns == null || ns.Name == null) continue;

            ns.ProvideTypes = new Namespace.TypeProvider(this.GetTypesForNamespace);

            nsTable[ns.Name.UniqueIdKey] = ns;

          }

        }

      }

      return this.namespaceList;

    }

    private void GetTypesForNamespace(Namespace nspace, object handle){

      if (nspace == null || nspace.Name == null) return;

      lock (Module.GlobalLock) {

        int key = nspace.Name.UniqueIdKey;

        TypeNodeList types = this.Types;

        TypeNodeList nsTypes = nspace.Types = new TypeNodeList();

        for (int i = 0, n = types == null ? 0 : types.Count; i < n; i++) {

          TypeNode t = types[i];

          if (t == null || t.Namespace == null) continue;

          if (t.Namespace.UniqueIdKey == key) nsTypes.Add(t);

        }

      }

    }

    public bool IsValidNamespace(Identifier nsName){

      if (nsName == null) return false;

      this.GetNamespaceList();

      //^ assert this.validNamespaces != null;

      return this.validNamespaces[nsName.UniqueIdKey] != null;

    }

    public bool IsValidTypeName(Identifier nsName, Identifier typeName){

      if (nsName == null || typeName == null) return false;

      if (!this.IsValidNamespace(nsName)) return false;

      if (this.reader != null) return this.reader.IsValidTypeName(nsName, typeName);

      return this.GetType(nsName, typeName) != null;

    }

    public Module GetNestedModule(string moduleName){

      if (this.Types == null){ Debug.Assert(false);} //Just get the types to pull in any exported types

      ModuleReferenceList moduleReferences = this.ModuleReferences; //This should now contain all interesting referenced modules

      for (int i = 0, n = moduleReferences == null ? 0 : moduleReferences.Count; i < n; i++){

        ModuleReference mref = moduleReferences[i];

        if (mref == null) continue;

        if (mref.Name == moduleName) return mref.Module;

      }

      return null;

    }

    internal TrivialHashtableUsingWeakReferences/*!*/ StructurallyEquivalentType {

      get {

        if (this.structurallyEquivalentType == null)

          this.structurallyEquivalentType = new TrivialHashtableUsingWeakReferences();

        return this.structurallyEquivalentType;

      }

    }

    private TrivialHashtableUsingWeakReferences structurallyEquivalentType;

    /// <summary>

    /// The identifier represents the structure via some mangling scheme. The result can be either from this module,

    /// or any module this module has a reference to.

    /// </summary>

    public virtual TypeNode GetStructurallyEquivalentType(Identifier ns, Identifier/*!*/ id) {

      return this.GetStructurallyEquivalentType(ns, id, id, true);

    }

    public virtual TypeNode GetStructurallyEquivalentType(Identifier ns, Identifier/*!*/ id, Identifier uniqueMangledName, bool lookInReferencedAssemblies) {

      if (uniqueMangledName == null) uniqueMangledName = id;

      TypeNode result = (TypeNode)this.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey];

      if (result == Class.DoesNotExist) return null;

      if (result != null) return result;

      lock (Module.GlobalLock){

        result = this.GetType(ns, id);

        if (result != null){

          this.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey] = result;

          return result;

        }

        if (!lookInReferencedAssemblies)

          goto notfound;

        AssemblyReferenceList refs = this.AssemblyReferences;

        for (int i = 0, n = refs == null ? 0 : refs.Count; i < n; i++){

          AssemblyReference ar = refs[i];

          if (ar == null) continue;

          AssemblyNode a = ar.Assembly;

          if (a == null) continue;

          result = a.GetType(ns, id);

          if (result != null){

            this.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey] = result;

            return result;

          }

        }

      notfound:

        this.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey] = Class.DoesNotExist;

        return null;

      }

    }

    public virtual TypeNode GetType(Identifier @namespace, Identifier name, bool lookInReferencedAssemblies){

      return this.GetType(@namespace, name, lookInReferencedAssemblies, lookInReferencedAssemblies ? new TrivialHashtable() : null);

    }

    protected virtual TypeNode GetType(Identifier @namespace, Identifier name, bool lookInReferencedAssemblies, TrivialHashtable assembliesAlreadyVisited){

      if (assembliesAlreadyVisited != null) {

        if (assembliesAlreadyVisited[this.UniqueKey] != null) return null;

        assembliesAlreadyVisited[this.UniqueKey] = this;

      }

      TypeNode result = this.GetType(@namespace, name);

      if (result != null || !lookInReferencedAssemblies) return result;

      AssemblyReferenceList refs = this.AssemblyReferences;

      for (int i = 0, n = refs == null ? 0 : refs.Count; i < n; i++) {

        AssemblyReference ar = refs[i];

        if (ar == null) continue;

        AssemblyNode a = ar.Assembly;

        if (a == null) continue;

        result = a.GetType(@namespace, name, true, assembliesAlreadyVisited);

        if (result != null) return result;

      }

      return null;

    }

    public virtual TypeNode GetType(Identifier @namespace, Identifier name){

      if (@namespace == null || name == null) return null;

      TypeNode result = null;

      if (this.namespaceTable == null) this.namespaceTable = new TrivialHashtable();

      TrivialHashtable nsTable = (TrivialHashtable)this.namespaceTable[@namespace.UniqueIdKey];

      if (nsTable != null){

        result = (TypeNode)nsTable[name.UniqueIdKey];

        if (result == Class.DoesNotExist) return null;

        if (result != null) return result;

      }else{      

        lock (Module.GlobalLock){

          nsTable = (TrivialHashtable)this.namespaceTable[@namespace.UniqueIdKey];

          if (nsTable == null)

            this.namespaceTable[@namespace.UniqueIdKey] = nsTable = new TrivialHashtable(32);

        }

      }

      if (this.provideTypeNode != null){

        lock (Module.GlobalLock){

          result = (TypeNode)nsTable[name.UniqueIdKey];

          if (result == Class.DoesNotExist) return null;

          if (result != null) return result;

          result = this.provideTypeNode(@namespace, name);

          if (result != null){

            nsTable[name.UniqueIdKey] = result; 

            return result;

          }

          nsTable[name.UniqueIdKey] = Class.DoesNotExist;

          return null;

        }

      }

      if (this.types != null && this.types.Count > this.savedTypesLength){

        int n = this.savedTypesLength = this.types.Count;

        for (int i = 0; i < n; i++){

          TypeNode t = this.types[i];

          if (t == null) continue;

          if (t.Namespace == null) t.Namespace = Identifier.Empty;

          nsTable = (TrivialHashtable)this.namespaceTable[t.Namespace.UniqueIdKey];

          if (nsTable == null) this.namespaceTable[t.Namespace.UniqueIdKey] = nsTable = new TrivialHashtable();

          nsTable[t.Name.UniqueIdKey] = t;

        }

        return this.GetType(@namespace, name);

      }

      return null;

    }

    protected internal TypeNodeList types;

    /// <summary>The types contained in this module or assembly.</summary>

    public virtual TypeNodeList Types{

      get{

        if (this.types != null) return this.types;

        if (this.provideTypeNodeList != null){

          lock (Module.GlobalLock){

            if (this.types == null)

              this.provideTypeNodeList(this);

          }

        }else

          this.types = new TypeNodeList();

        return this.types;

      }

      set{

        this.types = value;

      }

    }

#if !MinimalReader

    protected TrivialHashtable referencedModulesAndAssemblies;

#endif

    public virtual bool HasReferenceTo(Module module){

      if (module == null) return false;

      AssemblyNode assembly = module as AssemblyNode;

      if (assembly != null){

        AssemblyReferenceList arefs = this.AssemblyReferences;

        for (int i = 0, n = arefs == null ? 0 : arefs.Count; i < n; i++) {

          AssemblyReference aref = arefs[i];

          if (aref == null) continue;

          if (aref.Matches(assembly.Name, assembly.Version, assembly.Culture, assembly.PublicKeyToken))

            return true;

        }

      }

      if (this.ContainingAssembly != module.ContainingAssembly)

        return false;

      ModuleReferenceList mrefs = this.ModuleReferences;

      for (int i = 0, n = mrefs == null ? 0 : mrefs.Count; i < n; i++) {

        //^ assert mrefs != null;

        ModuleReference mref = mrefs[i];

        if (mref == null || mref.Name == null) continue;

        if (0 == PlatformHelpers.StringCompareOrdinalIgnoreCase(mref.Name, module.Name))

          return true;

      }

      return false;

    }

    internal void InitializeAssemblyReferenceResolution(Module referringModule){

      if (this.AssemblyReferenceResolution == null && referringModule != null) {

        this.AssemblyReferenceResolution = referringModule.AssemblyReferenceResolution;

        this.AssemblyReferenceResolutionAfterProbingFailed = referringModule.AssemblyReferenceResolutionAfterProbingFailed;

      }

    }

#if !MinimalReader

    public static Module GetModule(byte[] buffer){

      return Module.GetModule(buffer, null, false, false, true, false);

    }

    public static Module GetModule(byte[] buffer, IDictionary cache){

      return Module.GetModule(buffer, null, false, false, false, false);

    }

    public static Module GetModule(byte[] buffer, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return Module.GetModule(buffer, cache, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static Module GetModule(byte[] buffer, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches){

      if (buffer == null) return null;

      return (new Reader(buffer, cache, doNotLockFile, getDebugInfo, useGlobalCache, false)).ReadModule();

    }

#endif

    public static Module GetModule(string location){

      return Module.GetModule(location, null, false, false, true, false);

    }

    public static Module GetModule(string location, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return Module.GetModule(location, null, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static Module GetModule(string location, IDictionary cache){

      return Module.GetModule(location, cache, false, false, false, false);      

    }

    public static Module GetModule(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return Module.GetModule(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, false);      

    }

    public static Module GetModule(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches){

      if (location == null) return null;

      return (new Reader(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches)).ReadModule();

    }

    public virtual AssemblyNode Resolve(AssemblyReference assemblyReference){

      if (this.AssemblyReferenceResolution == null) return null;

      return this.AssemblyReferenceResolution(assemblyReference, this);

    }

    public virtual AssemblyNode ResolveAfterProbingFailed(AssemblyReference assemblyReference){

      if (this.AssemblyReferenceResolutionAfterProbingFailed == null) return null;

      return this.AssemblyReferenceResolutionAfterProbingFailed(assemblyReference, this);

    }

#if !NoWriter

    public virtual void WriteModule(string/*!*/ location, bool writeDebugSymbols) {

      this.Location = location;

      Writer.WritePE(location, writeDebugSymbols, this);

    }

    public virtual void WriteModule(Stream/*!*/ executable, Stream debugSymbols) {

      Writer.WritePE(executable, debugSymbols, this);

    }

    public virtual void WriteModule(out byte[] executable){

      Writer.WritePE(out executable, this);

    }

    public virtual void WriteModule(out byte[] executable, out byte[] debugSymbols){

      Writer.WritePE(out executable, out debugSymbols, this);

    }

    public virtual void WriteModule(string/*!*/ location, System.CodeDom.Compiler.CompilerParameters/*!*/ options) {

      this.Location = location;

      Writer.WritePE(options, this);

    }

#endif

#if !NoXml

    public virtual void WriteDocumentation(System.IO.TextWriter doc){

      if (this.documentation == null) return;

      XmlTextWriter xwriter = new XmlTextWriter(doc);

      xwriter.Formatting = Formatting.Indented;

      xwriter.Indentation = 2;

      xwriter.WriteProcessingInstruction("xml", "version=\"1.0\"");

      xwriter.WriteStartElement("doc");

      AssemblyNode assem = this as AssemblyNode;

      if (assem != null){

        xwriter.WriteStartElement("assembly");

        xwriter.WriteElementString("name", assem.Name);

        xwriter.WriteEndElement();

      }

      xwriter.WriteStartElement("members");

      TypeNodeList types = this.Types;

      for (int i = 1, n = types == null ? 0 : types.Count; i < n; i++){

        //^ assert types != null;

        TypeNode t = types[i]; if (t == null) continue;

        t.WriteDocumentation(xwriter);

      }

      xwriter.WriteEndElement();

      xwriter.WriteEndElement();

      xwriter.Close();

    }

#endif

#if !NoWriter

    public delegate MethodBodySpecializer/*!*/ MethodBodySpecializerFactory(Module/*!*/ m, TypeNodeList/*!*/ pars, TypeNodeList/*!*/ args);

    public MethodBodySpecializerFactory CreateMethodBodySpecializer;

    public MethodBodySpecializer/*!*/ GetMethodBodySpecializer(TypeNodeList/*!*/ pars, TypeNodeList/*!*/ args) {

      if (CreateMethodBodySpecializer != null)

        return this.CreateMethodBodySpecializer(this, pars, args);

      return new MethodBodySpecializer(this, pars, args);

    }

#endif

  }

  public class AssemblyNode : Module{ //An assembly is a module with a strong name

#if !NoWriter

    public string KeyContainerName;

    public byte[] KeyBlob;

#endif

#if !NoReflection

    private static Hashtable CompiledAssemblies;// so we can find in-memory compiled assemblies later (contains weak references)

#endif

#if !MinimalReader

    protected AssemblyNode contractAssembly;

    /// <summary>A separate assembly that supplied the type and method contracts for this assembly.</summary>

    public virtual AssemblyNode ContractAssembly{

      get{

        return this.contractAssembly;

      }

      set{

        if (this.contractAssembly != null){Debug.Assert(false); return;}

        this.contractAssembly = value;

        if (value == null) return;

        #region Copy over any external references from the contract assembly to this one (if needed)

        // These external references are needed only for the contract deserializer

        AssemblyReferenceList ars = new AssemblyReferenceList();

        AssemblyReferenceList contractReferences = value.AssemblyReferences;

        // see if contractReferences[i] is already in the external references of "this"

        for (int i = 0, n = contractReferences == null ? 0 : contractReferences.Count; i < n; i++){

          //^ assert contractReferences != null;

          AssemblyReference aref = contractReferences[i];

          if (aref == null) continue;

          if (aref.Assembly != this){ // don't copy the contract's external reference to "this"

            int j = 0;

            int m = this.AssemblyReferences == null ? 0 : this.AssemblyReferences.Count;

            while (j < m){

              if (aref.Assembly.Name != null &&

                this.AssemblyReferences[j].Name != null &&

                aref.Assembly.Name.Equals(this.AssemblyReferences[j].Name))

                  break;

              j++;

            }

            if (j == m){ // then it wasn't found in the list of the real references

              ars.Add(contractReferences[i]);

            }

          }

        }

        if (this.AssemblyReferences == null) 

          this.AssemblyReferences = new AssemblyReferenceList();

        for (int i = 0, n = ars.Count; i < n; i++){

          this.AssemblyReferences.Add(ars[i]);

        }

        #endregion Copy over any external references from the contract assembly to this one (if needed)



#if ExtendedRuntime

        #region Copy over any assembly-level attributes from the Contracts namespace

        int contractsNamespaceKey = SystemTypes.NonNullType.Namespace.UniqueIdKey;

        // Copy the assembly-level contract attributes over to the shadowed assembly.

        foreach(AttributeNode attr in contractAssembly.Attributes) {

          if(attr.Type != SystemTypes.ShadowsAssemblyAttribute // can't copy this one or the real assembly will be treated as a shadow assembly!

            &&

            attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey)

            this.Attributes.Add(attr);

        }

        #endregion Copy over any assembly-level attributes from the Contracts namespace

#endif



        TypeNodeList instantiatedTypes = null;

        if (this.reader != null) instantiatedTypes = this.reader.GetInstantiatedTypes();

        if (instantiatedTypes != null)

          for (int i = 0, n = instantiatedTypes.Count; i < n; i++){

            TypeNode t = instantiatedTypes[i];

            if (t == null) continue;



            if (t.members == null) {

#if ExtendedRuntime

              // Then will never get to ApplyOutOfBandContracts and will never have any

              // type-level attributes copied over. So need to do this here as well as

              // within ApplyOutOfBandContracts

              TypeNode contractType = this.ContractAssembly.GetType(t.Namespace, t.Name);

              if (contractType == null) continue;

              // Copy the type-level contract attributes over to the shadowed type.

              foreach (AttributeNode attr in contractType.Attributes) {

                if (attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey)

                  t.Attributes.Add(attr);

              }

#endif

              continue;

            }

#if ExtendedRuntime

            t.ApplyOutOfBandContracts();

#endif

          }

      }

    }

#endif

    internal static readonly AssemblyNode/*!*/ Dummy = new AssemblyNode();

    protected string strongName;

    /// <summary>

    /// A string containing the name, version, culture and key of this assembly, formatted as required by the CLR loader.

    /// </summary>

    public virtual string/*!*/ StrongName{

      get{

        if (this.strongName == null)

          this.strongName = AssemblyNode.GetStrongName(this.Name, this.Version, this.Culture, this.PublicKeyOrToken, (this.Flags & AssemblyFlags.Retargetable) != 0);

        return this.strongName;

      }

    }



    [Obsolete("Please use GetAttribute(TypeNode attributeType)")]

    public virtual AttributeNode GetAttributeByName(TypeNode attributeType){

      if (attributeType == null) return null;

      AttributeList attributes = this.Attributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

        //^ assert attributes != null;

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null){

          if (mb.BoundMember == null || mb.BoundMember.DeclaringType == null) continue;

          if (mb.BoundMember.DeclaringType.FullName != attributeType.FullName) continue;

          return attr;

        }

      }

      return null;

    }



    /// <summary>

    /// Gets the first attribute of the given type in the custom attribute list of this member. Returns null if none found.

    /// The member is assumed to be either imported, or already in a form suitable for export.

    /// </summary>

    public virtual AttributeNode GetModuleAttribute(TypeNode attributeType){

      if (attributeType == null) return null;

      AttributeList attributes = this.ModuleAttributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

        //^ assert attributes != null;

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null){

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != attributeType) continue;

          return attr;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit == null) continue;

        if ((lit.Value as TypeNode) != attributeType) continue;

        return attr;

      }

      return null;

    }



    public AssemblyNode()

      : base(){

      this.NodeType = NodeType.Assembly;

      this.ContainingAssembly = this;

    }

    public AssemblyNode(TypeNodeProvider provider, TypeNodeListProvider listProvider,

      CustomAttributeProvider provideCustomAttributes, ResourceProvider provideResources, string directory)

      : base(provider, listProvider, provideCustomAttributes, provideResources){

      this.Directory = directory;

      this.NodeType = NodeType.Assembly;

      this.ContainingAssembly = this;

    }

    public override void Dispose(){

#if !NoReflection

      if (this.cachedRuntimeAssembly != null)

        this.cachedRuntimeAssembly.Dispose();

      this.cachedRuntimeAssembly = null;

#endif

      lock (Reader.StaticAssemblyCache) {

        foreach (object key in new ArrayList(Reader.StaticAssemblyCache.Keys)){

          if (Reader.StaticAssemblyCache[key] == this)

            Reader.StaticAssemblyCache.Remove(key);

        }

        if(TargetPlatform.AssemblyReferenceForInitialized) {

          AssemblyReference aRef = (AssemblyReference)TargetPlatform.AssemblyReferenceFor[Identifier.For(this.Name).UniqueIdKey];

          if (aRef != null && aRef.Assembly == this){

            aRef.Assembly = null;

            //TODO: what about other static references to the assembly, such as SystemTypes.SystemXmlAssembly?

          }

        }

      }

      base.Dispose();

    }

    private string culture;

    /// <summary>The target culture of any localized resources in this assembly.</summary>

    public string Culture{

      get{return this.culture;}

      set{this.culture = value;}

    }

    private AssemblyFlags flags;

    /// <summary>An enumeration that identifies the what kind of assembly this is.</summary>

    public AssemblyFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private string moduleName;

    /// <summary>Attributes that specifically target a module rather an assembly.</summary>

    public string ModuleName{ //An assembly can have a different name from the module.

      get{return this.moduleName;}

      set{this.moduleName = value;}

    }

    private byte[] publicKeyOrToken;

    /// <summary>The public part of the key pair used to sign this assembly, or a hash of the public key.</summary>

    public byte[] PublicKeyOrToken{

      get{return this.publicKeyOrToken;}

      set{this.publicKeyOrToken = value;}

    }

    private System.Version version;

    /// <summary>The version of this assembly.</summary>

    public System.Version Version{

      get{return this.version;}

      set{this.version = value;}

    }

    private DateTime fileLastWriteTimeUtc;

    public DateTime FileLastWriteTimeUtc{

      get{return this.fileLastWriteTimeUtc;}

      set{this.fileLastWriteTimeUtc = value;}

    }

    protected TypeNodeList exportedTypes;

    /// <summary>

    /// Public types defined in other modules making up this assembly and to which other assemblies may refer to.

    /// </summary>

    public virtual TypeNodeList ExportedTypes{

      get{

        if (this.exportedTypes != null) return this.exportedTypes;

        if (this.provideTypeNodeList != null){

          TypeNodeList types = this.Types; //Gets the exported types as a side-effect

          if (types != null) types = null;

        }else

          this.exportedTypes = new TypeNodeList();

        return this.exportedTypes;

      }

      set{

        this.exportedTypes = value;

      }

    }

    public bool GetDebugSymbols{

      get{ 

        if (this.reader == null) return false;

        return this.reader.getDebugSymbols;

      }

      set{ 

        if (this.reader == null) return;

        this.reader.getDebugSymbols = value;

      }

    }

#if !MinimalReader

    public static AssemblyNode GetAssembly(byte[] buffer){

      return AssemblyNode.GetAssembly(buffer, null, false, false, true, false);

    }

    public static AssemblyNode GetAssembly(byte[] buffer, IDictionary cache){

      return AssemblyNode.GetAssembly(buffer, cache, false, false, false, false);

    }

    public static AssemblyNode GetAssembly(byte[] buffer, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(buffer, cache, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static AssemblyNode GetAssembly(byte[] buffer, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches){

      if (buffer == null) return null;

      if (CoreSystemTypes.SystemAssembly == null) Debug.Fail("");

      return (new Reader(buffer, cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches)).ReadModule() as AssemblyNode;

    }

#endif

    public static AssemblyNode GetAssembly(string location){

      return AssemblyNode.GetAssembly(location, null, false, false, true, false);

    }

    public static AssemblyNode GetAssembly(string location, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(location, null, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static AssemblyNode GetAssembly(string location, IDictionary cache){

      return AssemblyNode.GetAssembly(location, cache, false, false, false, false);

    }

    public static AssemblyNode GetAssembly(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

#if !MinimalReader

    /// <summary>

    /// Calls the post load event only if the assembly is not already loaded/found in the cache.

    /// </summary>

    public static AssemblyNode GetAssembly(string location, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, PostAssemblyLoadProcessor postLoadEvent)

    {

      return AssemblyNode.GetAssembly(location, null, doNotLockFile, getDebugInfo, useGlobalCache, false, postLoadEvent);

    }

    public static AssemblyNode GetAssembly(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, PostAssemblyLoadProcessor postLoadEvent)

    {

      return AssemblyNode.GetAssembly(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, false, postLoadEvent);

    }

    public static AssemblyNode GetAssembly(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches)

    {

      return GetAssembly(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches, null);

    }

    public static AssemblyNode GetAssembly(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches, PostAssemblyLoadProcessor postLoadEvent)

    {

      if (location == null) return null;

      if (CoreSystemTypes.SystemAssembly == null) Debug.Fail("");

      return (new Reader(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches)).ReadModule(postLoadEvent) as AssemblyNode;

    }

#else 

    public static AssemblyNode GetAssembly(string location, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches)

    {

      if (location == null) return null;

      if (CoreSystemTypes.SystemAssembly == null) Debug.Fail("");

      return (new Reader(location, cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches)).ReadModule() as AssemblyNode;

    }

#endif



#if !MinimalReader || !NoXml || !NoData

    public static AssemblyNode GetAssembly(AssemblyReference assemblyReference){

      return AssemblyNode.GetAssembly(assemblyReference, null, false, false, true, false);

    }

    public static AssemblyNode GetAssembly(AssemblyReference assemblyReference, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(assemblyReference, null, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static AssemblyNode GetAssembly(AssemblyReference assemblyReference, IDictionary cache){

      return AssemblyNode.GetAssembly(assemblyReference, cache, false, false, false, false);

    }

    public static AssemblyNode GetAssembly(AssemblyReference assemblyReference, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(assemblyReference, cache, doNotLockFile, getDebugInfo, useGlobalCache, false);

    }

    public static AssemblyNode GetAssembly(AssemblyReference assemblyReference, IDictionary cache, bool doNotLockFile, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches){

      if (assemblyReference == null) return null;

      if (CoreSystemTypes.SystemAssembly == null) Debug.Fail("");

      Reader reader = new Reader(cache, doNotLockFile, getDebugInfo, useGlobalCache, preserveShortBranches);

      return assemblyReference.Assembly = reader.GetAssemblyFromReference(assemblyReference);

    }

#endif

#if !NoReflection

    public static AssemblyNode GetAssembly(System.Reflection.Assembly runtimeAssembly){

      return AssemblyNode.GetAssembly(runtimeAssembly, null, false, true, false);

    }

    public static AssemblyNode GetAssembly(System.Reflection.Assembly runtimeAssembly, IDictionary cache){

      return AssemblyNode.GetAssembly(runtimeAssembly, cache, false, false, false);

    }

    public static AssemblyNode GetAssembly(System.Reflection.Assembly runtimeAssembly, IDictionary cache, bool getDebugInfo, bool useGlobalCache){

      return AssemblyNode.GetAssembly(runtimeAssembly, cache, getDebugInfo, useGlobalCache, false);

    }

    public static AssemblyNode GetAssembly(System.Reflection.Assembly runtimeAssembly, IDictionary cache, bool getDebugInfo, bool useGlobalCache, bool preserveShortBranches){

      if (runtimeAssembly == null) return null;

      if (CoreSystemTypes.SystemAssembly == null) Debug.Fail("");

      if (runtimeAssembly.GetName().Name == "mscorlib") {

        return CoreSystemTypes.SystemAssembly;

      }

      if (AssemblyNode.CompiledAssemblies != null) {

        WeakReference weakRef = (WeakReference)AssemblyNode.CompiledAssemblies[runtimeAssembly];

        if (weakRef != null){

          AssemblyNode assem = (AssemblyNode)weakRef.Target;

          if (assem == null) AssemblyNode.CompiledAssemblies.Remove(runtimeAssembly); //Remove the dead WeakReference

          return assem;

        }

      }

      if (runtimeAssembly.Location != null && runtimeAssembly.Location.Length > 0)

        return AssemblyNode.GetAssembly(runtimeAssembly.Location, cache, false, getDebugInfo, useGlobalCache, preserveShortBranches);

      //Get here for in memory assemblies that were not loaded from a known AssemblyNode

      //Need CLR support to handle such assemblies. For now return null.

      return null;

    }

#endif

    public void SetupDebugReader(string pdbSearchPath){

      if (this.reader == null){Debug.Assert(false); return;}

      this.reader.SetupDebugReader(this.Location, pdbSearchPath);

    }

    internal static string/*!*/ GetStrongName(string name, Version version, string culture, byte[] publicKey, bool retargetable){

      if (version == null) version = new Version();

      StringBuilder result = new StringBuilder();

      result.Append(name);

      result.Append(", Version="); result.Append(version.ToString());

      result.Append(", Culture="); result.Append(((culture == null || culture.Length == 0) ? "neutral" : culture));

      result.Append(AssemblyNode.GetKeyString(publicKey));

      if (retargetable)

        result.Append(", Retargetable=Yes");

      return result.ToString();

    }

    private System.Reflection.AssemblyName assemblyName;

    public System.Reflection.AssemblyName GetAssemblyName(){

      if (this.assemblyName == null){

        System.Reflection.AssemblyName aName = new System.Reflection.AssemblyName();

        if (this.Location != null && this.Location != "unknown:location"){

          StringBuilder sb = new StringBuilder("file:///");

          sb.Append(Path.GetFullPath(this.Location));

          sb.Replace('\\', '/');

          aName.CodeBase = sb.ToString();

        }

        aName.CultureInfo = new System.Globalization.CultureInfo(this.Culture);

        if (this.PublicKeyOrToken != null && this.PublicKeyOrToken.Length > 8)

          aName.Flags = System.Reflection.AssemblyNameFlags.PublicKey;

        if ((this.Flags & AssemblyFlags.Retargetable) != 0)

          aName.Flags |= (System.Reflection.AssemblyNameFlags)AssemblyFlags.Retargetable;

        aName.HashAlgorithm = (System.Configuration.Assemblies.AssemblyHashAlgorithm)this.HashAlgorithm;

        if (this.PublicKeyOrToken != null && this.PublicKeyOrToken.Length > 0)

          aName.SetPublicKey(this.PublicKeyOrToken);

        else

          aName.SetPublicKey(new byte[0]);

        aName.Name = this.Name;

        aName.Version = this.Version;

        switch (this.Flags & AssemblyFlags.CompatibilityMask){

          case AssemblyFlags.NonSideBySideCompatible:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameDomain;

            break;

          case AssemblyFlags.NonSideBySideProcess:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameProcess;

            break;

          case AssemblyFlags.NonSideBySideMachine:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameMachine;

            break;

        }

        this.assemblyName = aName;

      }

      return this.assemblyName;

    }

#if !NoReflection

    private sealed class CachedRuntimeAssembly : IDisposable{

      internal System.Reflection.Assembly Value;

      internal CachedRuntimeAssembly(System.Reflection.Assembly assembly){

        this.Value = assembly;

      }

      ~CachedRuntimeAssembly(){

        this.Dispose();

      }

      public void Dispose(){

        if (this.Value != null){

          if (AssemblyNode.CompiledAssemblies != null)

            AssemblyNode.CompiledAssemblies.Remove(this.Value);

        }

        this.Value = null;

        GC.SuppressFinalize(this);

      }

    }

    private CachedRuntimeAssembly cachedRuntimeAssembly;

    public System.Reflection.Assembly GetRuntimeAssembly(){

      return this.GetRuntimeAssembly(null, null);

    }

#endif

#if !NoReflection

    public System.Reflection.Assembly GetRuntimeAssembly(System.Security.Policy.Evidence evidence){

      return this.GetRuntimeAssembly(evidence, null);

    }

    public System.Reflection.Assembly GetRuntimeAssembly(AppDomain targetAppDomain){

      return this.GetRuntimeAssembly(null, targetAppDomain);

    }

    public System.Reflection.Assembly GetRuntimeAssembly(System.Security.Policy.Evidence evidence, AppDomain targetAppDomain){

      System.Reflection.Assembly result = this.cachedRuntimeAssembly == null ? null : this.cachedRuntimeAssembly.Value;

      if (result == null || evidence != null || targetAppDomain != null){

        lock(this){

          if (this.cachedRuntimeAssembly != null && evidence == null && targetAppDomain == null) return this.cachedRuntimeAssembly.Value;

          if (targetAppDomain == null) targetAppDomain = AppDomain.CurrentDomain;

          if (this.Location != null){

            string name = this.StrongName;

            System.Reflection.Assembly[] alreadyLoadedAssemblies = targetAppDomain.GetAssemblies();

            if (alreadyLoadedAssemblies != null)

              for (int i = 0, n = alreadyLoadedAssemblies.Length; i < n; i++){

                System.Reflection.Assembly a = alreadyLoadedAssemblies[i];

                if (a == null) continue;

                if (a.FullName == name){

                  result = a; break;

                }

              }

            if (result == null){

              if (evidence != null)

                result = targetAppDomain.Load(this.GetAssemblyName(), evidence);

              else

                result = targetAppDomain.Load(this.GetAssemblyName());

            }

          }

#if !NoWriter

          // without the writer, it is impossible to get the runtime

          // assembly for an AssemblyNode which does not correspond

          // to a file on disk, we will return null in that case.

          else{

            byte[] executable = null;

            byte[] debugSymbols = null;

            if ((this.Flags & (AssemblyFlags.EnableJITcompileTracking|AssemblyFlags.DisableJITcompileOptimizer)) != 0){

              this.WriteModule(out executable, out debugSymbols);

              if (evidence != null)

                result = targetAppDomain.Load(executable, debugSymbols, evidence);

              else

                result = targetAppDomain.Load(executable, debugSymbols);

            }else{

              this.WriteModule(out executable);

              if (evidence != null)

                result = targetAppDomain.Load(executable, null, evidence);

              else

                result = targetAppDomain.Load(executable);

            }        

          }

#endif

          if (result != null && evidence == null && targetAppDomain == AppDomain.CurrentDomain){

            this.AddCachedAssembly(result);

            this.cachedRuntimeAssembly = new CachedRuntimeAssembly(result);

          }

        }

      }

      return result;

    }

    private void AddCachedAssembly(System.Reflection.Assembly/*!*/ runtimeAssembly) {

      if (AssemblyNode.CompiledAssemblies == null) 

        AssemblyNode.CompiledAssemblies = Hashtable.Synchronized(new Hashtable());

      AssemblyNode.CompiledAssemblies[runtimeAssembly] = new WeakReference(this);

    }

#endif

    private static string GetKeyString(byte[] publicKey){

      if (publicKey == null) return null;

      int n = publicKey.Length;

      StringBuilder str;

      if (n > 8){

#if !ROTOR

        System.Security.Cryptography.SHA1 sha1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();

        publicKey = sha1.ComputeHash(publicKey);

        byte[] token = new byte[8];

        for (int i = 0, m = publicKey.Length-1; i < 8; i++)

          token[i] = publicKey[m-i];

        publicKey = token;

        n = 8;

#else

        n = 0; //TODO: figure out how to compute the token on ROTOR

#endif

      }

      if (n == 0)

        str = new StringBuilder(", PublicKeyToken=null");

      else

        str = new StringBuilder(", PublicKeyToken=", n*2+17);

      for (int i = 0; i < n; i++)

        str.Append(publicKey[i].ToString("x2"));

      return str.ToString();

    }

    protected TrivialHashtable friends;

    public virtual bool MayAccessInternalTypesOf(AssemblyNode assembly){

      if (this == assembly) return true;

      if (assembly == null || SystemTypes.InternalsVisibleToAttribute == null) return false;

      if (this.friends == null) this.friends = new TrivialHashtable();

      object ob = this.friends[assembly.UniqueKey];

      if (ob == (object)string.Empty) return false;

      if (ob == this) return true;

      AttributeList attributes = assembly.Attributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

        //^ assert attributes != null;

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null){

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != SystemTypes.InternalsVisibleToAttribute) continue;

        }else{

          Literal lit = attr.Constructor as Literal;

          if (lit == null) continue;

          if ((lit.Value as TypeNode) != SystemTypes.InternalsVisibleToAttribute) continue;

        }

        if (attr.Expressions == null || attr.Expressions.Count < 1) continue;

        Literal argLit = attr.Expressions[0] as Literal;

        if (argLit == null) continue;

        string friendName = argLit.Value as string;

        if (friendName == null) continue;

        try{

          AssemblyReference ar = new AssemblyReference(friendName);

          byte[] tok = ar.PublicKeyToken;

          if (tok != null && this.PublicKeyOrToken != null) tok = this.PublicKeyToken;

          if (!ar.Matches(this.Name, ar.Version, ar.Culture, tok)) continue;

#if !FxCop

        }catch(ArgumentException e){

          if (this.MetadataImportErrors == null) this.MetadataImportErrors = new ArrayList();

          this.MetadataImportErrors.Add(e.Message);

          continue;

        }

#else

        }finally{}

#endif

        this.friends[assembly.UniqueKey] = this;

        return true;

      }

      this.friends[assembly.UniqueKey] = string.Empty;

      return false;

    }

    public AssemblyReferenceList GetFriendAssemblies(){

      if (SystemTypes.InternalsVisibleToAttribute == null) return null;

      AttributeList attributes = this.Attributes;

      if (attributes == null) return null;

      int n = attributes.Count; if (n == 0) return null;

      AssemblyReferenceList result = new AssemblyReferenceList(n);

      for (int i = 0; i < n; i++){

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null){

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != SystemTypes.InternalsVisibleToAttribute) continue;

        }else{

          Literal lit = attr.Constructor as Literal;

          if (lit == null) continue;

          if ((lit.Value as TypeNode) != SystemTypes.InternalsVisibleToAttribute) continue;

        }

        if (attr.Expressions == null || attr.Expressions.Count < 1) continue;

        Literal argLit = attr.Expressions[0] as Literal;

        if (argLit == null) continue;

        string friendName = argLit.Value as string;

        if (friendName == null) continue;

        result.Add(new AssemblyReference(friendName));

      }

      return result;

    }

    /// <summary>

    /// The attributes associated with this module. This corresponds to C# custom attributes with the module target specifier.

    /// </summary>

    public virtual AttributeList ModuleAttributes {

      get {

        if (this.moduleAttributes != null) return this.moduleAttributes;

        if (this.provideCustomAttributes != null) {

          lock (Module.GlobalLock) {

            if (this.moduleAttributes == null)

              this.provideCustomAttributes(this);

          }

        } else

          this.moduleAttributes = new AttributeList();

        return this.moduleAttributes;

      }

      set {

        this.moduleAttributes = value;

      }

    }

    protected AttributeList moduleAttributes;



    protected byte[] token;

    public virtual byte[] PublicKeyToken{

      get{

        if (this.token != null) return this.token;

        if (this.PublicKeyOrToken == null || this.PublicKeyOrToken.Length == 0) return null;

        if (this.PublicKeyOrToken.Length == 8) return this.token = this.PublicKeyOrToken;

#if !ROTOR

        System.Security.Cryptography.SHA1 sha1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();

        byte[] hashedKey = sha1.ComputeHash(this.PublicKeyOrToken);

        byte[] token = new byte[8];

        for (int i = 0, n = hashedKey.Length-1; i < 8; i++) token[i] = hashedKey[n-i];

        return this.token = token;

#else

        return null;

#endif

      }

    }

#if !MinimalReader

    public override string ToString() {

      return this.Name;

    }

    public delegate void PostAssemblyLoadProcessor (AssemblyNode loadedAssembly);

    public event PostAssemblyLoadProcessor AfterAssemblyLoad;

    internal PostAssemblyLoadProcessor GetAfterAssemblyLoad()

    {

      return this.AfterAssemblyLoad;

    }

#endif

  }

  public class AssemblyReference : Node{

#if !MinimalReader

    public IdentifierList Aliases;

#endif

    private byte[] token;

    internal Reader Reader;

    public AssemblyReference()

      : base(NodeType.AssemblyReference){

    }

    public AssemblyReference(AssemblyNode/*!*/ assembly)

      : base(NodeType.AssemblyReference){

      this.culture = assembly.Culture;

      this.flags = assembly.Flags & ~AssemblyFlags.PublicKey;

      this.hashValue = assembly.HashValue;

      this.name = assembly.Name;

      this.publicKeyOrToken = assembly.PublicKeyOrToken;

      if (assembly.PublicKeyOrToken != null && assembly.PublicKeyOrToken.Length > 8)

        this.flags |= AssemblyFlags.PublicKey;

      this.location = assembly.Location;

      this.version = assembly.Version;

      this.assembly = assembly;

    }

#if !MinimalReader

    public AssemblyReference(string assemblyStrongName, SourceContext sctx)

      : this(assemblyStrongName){

      this.SourceContext = sctx;

    }

#endif

    public AssemblyReference(string assemblyStrongName)

      : base(NodeType.AssemblyReference){

      AssemblyFlags flags = AssemblyFlags.None;

      if (assemblyStrongName == null){Debug.Assert(false); assemblyStrongName = "";}

      int i = 0, n = assemblyStrongName.Length;

      string name = ParseToken(assemblyStrongName, ref i);           

      string version = null;

      string culture = null;

      string token = null;

      while (i < n){

        if (assemblyStrongName[i] != ',') throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,

          ExceptionStrings.InvalidAssemblyStrongName, assemblyStrongName), "assemblyStrongName");

        i++;

        while (i < n && char.IsWhiteSpace(assemblyStrongName[i])) i++;

        switch (assemblyStrongName[i]){

          case 'v': case 'V': version = ParseAssignment(assemblyStrongName, "Version", ref i); break;

          case 'c': case 'C': culture = ParseAssignment(assemblyStrongName, "Culture", ref i); break;

          case 'p': case 'P':

            if (PlatformHelpers.StringCompareOrdinalIgnoreCase(assemblyStrongName, i, "PublicKeyToken", 0, "PublicKeyToken".Length) == 0)

              token = ParseAssignment(assemblyStrongName, "PublicKeyToken", ref i);

            else {

              token = ParseAssignment(assemblyStrongName, "PublicKey", ref i);

              flags |= AssemblyFlags.PublicKey;

            }

            break;

          case 'r': case 'R':

            string yesOrNo = ParseAssignment(assemblyStrongName, "Retargetable", ref i);

            if (PlatformHelpers.StringCompareOrdinalIgnoreCase(yesOrNo, "Yes") == 0)

              flags |= AssemblyFlags.Retargetable;

            break;

        }

        while (i < n && assemblyStrongName[i] == ']') i++;

      }

      while (i < n && char.IsWhiteSpace(assemblyStrongName[i])) i++;

      if (i < n) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,

        ExceptionStrings.InvalidAssemblyStrongName, assemblyStrongName), "assemblyStrongName");

      if (PlatformHelpers.StringCompareOrdinalIgnoreCase(culture, "neutral") == 0)

        culture = null;

      if (PlatformHelpers.StringCompareOrdinalIgnoreCase(token, "null") == 0)

        token = null;

      byte[] tok = null;

      if (token != null && (n = token.Length) > 0){

        if (n > 16){

          ArrayList tokArr = new ArrayList();

          if (n % 2 == 1){

            tokArr.Add(byte.Parse(token.Substring(0, 1), System.Globalization.NumberStyles.HexNumber, null));

            n--;

          }

          for (i = 0; i < n; i += 2) {

#if WHIDBEY

            byte b = 0;

            bool goodByte = byte.TryParse(token.Substring(i, 2), System.Globalization.NumberStyles.HexNumber, null, out b);

            Debug.Assert(goodByte);

#else

            byte b = byte.Parse(token.Substring(i, 2), System.Globalization.NumberStyles.HexNumber, null);

#endif

            tokArr.Add(b);

          }

          tok = (byte[])tokArr.ToArray(typeof(byte));

        }else{

          ulong tk = ulong.Parse(token, System.Globalization.NumberStyles.HexNumber, null);

          tok = new byte[8];

          tok[0] = (byte)(tk >> 56);

          tok[1] = (byte)(tk >> 48);

          tok[2] = (byte)(tk >> 40);

          tok[3] = (byte)(tk >> 32);

          tok[4] = (byte)(tk >> 24);

          tok[5] = (byte)(tk >> 16);

          tok[6] = (byte)(tk >> 8);

          tok[7] = (byte)tk;

        }

      }

      this.culture = culture;

      this.name = name;

      this.publicKeyOrToken = tok;

      this.version = version == null || version.Length == 0 ? null : new Version(version);

      this.flags = flags;

    }

    private static string ParseToken(string/*!*/ assemblyStrongName, ref int i) {

      Debug.Assert(assemblyStrongName != null);

      int n = assemblyStrongName.Length;

      Debug.Assert(0 <= i && i < n);

      while (i < n && char.IsWhiteSpace(assemblyStrongName[i])) i++;

      StringBuilder sb = new StringBuilder(n);

      while (i < n){

        char ch = assemblyStrongName[i];

        if (ch == ',' || ch == ']' || char.IsWhiteSpace(ch)) break;

        sb.Append(ch);

        i++;

      }

      while (i < n && char.IsWhiteSpace(assemblyStrongName[i])) i++;

      return sb.ToString();

    }

    private static string ParseAssignment(string/*!*/ assemblyStrongName, string/*!*/ target, ref int i) {

      Debug.Assert(assemblyStrongName != null && target != null);

      int n = assemblyStrongName.Length;

      Debug.Assert(0 < i && i < n);

      if (PlatformHelpers.StringCompareOrdinalIgnoreCase(assemblyStrongName, i, target, 0, target.Length) != 0)

        goto throwError;

      i += target.Length;

      while (i < n && char.IsWhiteSpace(assemblyStrongName[i])) i++;

      if (i >= n || assemblyStrongName[i] != '=') goto throwError;

      i++;

      if (i >= n) goto throwError;

      return ParseToken(assemblyStrongName, ref i);

    throwError:

      throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,

        ExceptionStrings.InvalidAssemblyStrongName, assemblyStrongName), "assemblyStrongName");

    }

    private string culture;

    public string Culture{

      get{return this.culture;}

      set{this.culture = value;}

    }

    private AssemblyFlags flags;

    public AssemblyFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private byte[] hashValue;

    public byte[] HashValue{

      get{return this.hashValue;}

      set{this.hashValue = value;}

    }

    private string name;

    public string Name{

      get{return this.name;}

      set{this.name = value;}

    }

    private byte[] publicKeyOrToken;

    public byte[] PublicKeyOrToken{

      get{return this.publicKeyOrToken;}

      set{this.publicKeyOrToken = value;}

    }

    private System.Version version;

    public System.Version Version{

      get{return this.version;}

      set{this.version = value;}

    }

    private string location;

    public string Location{

      get{return this.location;}

      set{this.location = value;}

    }

    protected internal AssemblyNode assembly;

    public virtual AssemblyNode Assembly{

      get{

        if (this.assembly != null) return this.assembly;

        if (this.Reader != null)

          return this.assembly = this.Reader.GetAssemblyFromReference(this);

        return null;

      }

      set{

        this.assembly = value;

      }

    }

    protected string strongName;

    public virtual string StrongName{

      get{

        if (this.strongName == null)

          this.strongName = AssemblyNode.GetStrongName(this.Name, this.Version, this.Culture, this.PublicKeyOrToken, (this.Flags & AssemblyFlags.Retargetable) != 0);

        return this.strongName;

      }

    }

    private System.Reflection.AssemblyName assemblyName;

    public System.Reflection.AssemblyName GetAssemblyName(){

      if (this.assemblyName == null){

        System.Reflection.AssemblyName aName = new System.Reflection.AssemblyName();

        aName.CultureInfo = new System.Globalization.CultureInfo(this.Culture == null ? "" : this.Culture);

        if (this.PublicKeyOrToken != null && this.PublicKeyOrToken.Length > 8)

          aName.Flags = System.Reflection.AssemblyNameFlags.PublicKey;

        if ((this.Flags & AssemblyFlags.Retargetable) != 0)

          aName.Flags |= (System.Reflection.AssemblyNameFlags)AssemblyFlags.Retargetable;

        aName.HashAlgorithm = System.Configuration.Assemblies.AssemblyHashAlgorithm.SHA1;

        if (this.PublicKeyOrToken != null){

          if (this.PublicKeyOrToken.Length > 8)

            aName.SetPublicKey(this.PublicKeyOrToken);

          else if (this.PublicKeyOrToken.Length > 0)

            aName.SetPublicKeyToken(this.PublicKeyOrToken);

        }

        else

          aName.SetPublicKey(new byte[0]);

        aName.Name = this.Name;

        aName.Version = this.Version;

        switch (this.Flags & AssemblyFlags.CompatibilityMask){

          case AssemblyFlags.NonSideBySideCompatible:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameDomain;

            break;

          case AssemblyFlags.NonSideBySideProcess:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameProcess;

            break;

          case AssemblyFlags.NonSideBySideMachine:

            aName.VersionCompatibility = System.Configuration.Assemblies.AssemblyVersionCompatibility.SameMachine;

            break;

        }

        this.assemblyName = aName;

      }

      return this.assemblyName;

    }

    public bool Matches(string name, Version version, string culture, byte[] publicKeyToken){

      if (culture != null && culture.Length == 0) culture = null;

      if (this.Culture != null && this.Culture.Length == 0) this.Culture = null;

      if (this.Version != version && this.Version != null && (version == null || !this.Version.Equals(version))) return false;

      if (PlatformHelpers.StringCompareOrdinalIgnoreCase(this.Name, name) != 0 ||

        PlatformHelpers.StringCompareOrdinalIgnoreCase(this.Culture, culture) != 0) return false;

      if ((this.Flags & AssemblyFlags.Retargetable) != 0) return true;

      byte[] thisToken = this.PublicKeyToken;

      if (publicKeyToken == null) return thisToken == null;

      if (thisToken == publicKeyToken) return true;

      if (thisToken == null) return false;

      int n = publicKeyToken.Length;

      if (n != thisToken.Length) return false;

      for (int i = 0; i < n; i++) if (thisToken[i] != publicKeyToken[i]) return false;

      return true;

    }

    public bool MatchesIgnoringVersion(AssemblyReference reference){

      if (reference == null) return false;

      return this.Matches(reference.Name, this.Version, reference.Culture, reference.PublicKeyToken);

    }

    public byte[] PublicKeyToken{

      get{

        if (this.token != null) return this.token;

        if (this.PublicKeyOrToken == null || this.PublicKeyOrToken.Length == 0) return null;

        if (this.PublicKeyOrToken.Length == 8) return this.token = this.PublicKeyOrToken;

#if !ROTOR

        System.Security.Cryptography.SHA1 sha = new System.Security.Cryptography.SHA1CryptoServiceProvider();

        byte[] hashedKey = sha.ComputeHash(this.PublicKeyOrToken);

        byte[] token = new byte[8];

        for (int i = 0, n = hashedKey.Length-1; i < 8; i++) token[i] = hashedKey[n-i];

        return this.token = token;

#else

        return null;

#endif

      }

    }

  }

  public class ModuleReference : Node{

    private Module module;

    private string name;

    public ModuleReference()

      : base(NodeType.ModuleReference){

    }

    public ModuleReference(string name, Module module)

      : base(NodeType.ModuleReference){

      this.name = name;

      this.module = module;

    }

    public Module Module {

      get{return this.module;}

      set{this.module = value;}

    }

    public string Name{

      get{return this.name;}

      set{this.name = value;}

    }

  }

  /// <summary>

  /// A member of a Namespace or a TypeNode

  /// </summary>

  public abstract class Member : Node{

#if !MinimalReader

    /// <summary>The namespace of which this node is a member. Null if this node is a member of type.</summary>

    public Namespace DeclaringNamespace;

    /// <summary>

    /// Indicates that the signature of this member may include unsafe types such as pointers. For methods and properties, it also indicates that the

    /// code may contain unsafe constructions such as pointer arithmetic.

    /// </summary>

    public bool IsUnsafe;

    /// <summary>A list of other nodes that refer to this member. Must be filled in by client code.</summary>

    public NodeList References;

#endif

    protected Member(NodeType nodeType)

      : base(nodeType){

    }

    protected Member(TypeNode declaringType, AttributeList attributes, Identifier name, NodeType nodeType)

      : base(nodeType){

      this.attributes = attributes;

      this.declaringType = declaringType;

      this.name = name;

    }

    private TypeNode declaringType;

    /// <summary>The type of which this node is a member. Null if this node is a member of a Namespace.</summary>

    public TypeNode DeclaringType{

      get{return this.declaringType;}

      set{this.declaringType = value;}

    }

    private Identifier name;

    /// <summary>The unqualified name of the member.</summary>

    public Identifier Name {

      get{return this.name;}

      set{ this.name = value; }

    }

#if ExtendedRuntime

    private Anonymity anonymity;

#endif

    protected AttributeList attributes;

    private bool notObsolete;

    private ObsoleteAttribute obsoleteAttribute;



    /// <summary>

    /// The attributes of this member. Corresponds to custom attribute annotations in C#.

    /// </summary>

    public virtual AttributeList Attributes{

      get{

        if (this.attributes != null) return this.attributes;

        return this.attributes = new AttributeList();

      }

      set{

        this.attributes = value;

      }

    }

    protected Member hiddenMember;

    public virtual Member HiddenMember{

      get{

        return this.hiddenMember;

      }

      set{

        this.hiddenMember = value;

      }

    }

    protected bool hidesBaseClassMemberSpecifiedExplicitly;

    protected bool hidesBaseClassMember;

    /// <summary>Indicates if this is a member of a subclass that intentionally has the same signature as a member of a base class. Corresponds to the "new" modifier in C#.</summary>

    public bool HidesBaseClassMember{

      get{

        if (this.hidesBaseClassMemberSpecifiedExplicitly) 

          return this.hidesBaseClassMember;

        else

          return this.HiddenMember != null;

      }

      set{

        this.hidesBaseClassMember = value;

        this.hidesBaseClassMemberSpecifiedExplicitly = true;

      }

    }

    protected Member overriddenMember;

    public virtual Member OverriddenMember{

      get{

        return this.overriddenMember;

      }

      set{

        this.overriddenMember = value;

      }

    }

    protected bool overridesBaseClassMemberSpecifiedExplicitly;

    protected bool overridesBaseClassMember;

    /// <summary>Indicates if this is a virtual method of a subclass that intentionally overrides a method of a base class. Corresponds to the "override" modifier in C#.</summary>

    public virtual bool OverridesBaseClassMember{

      get{

        if (this.overridesBaseClassMemberSpecifiedExplicitly) 

          return this.overridesBaseClassMember;

        else

          return this.OverriddenMember != null;

      }

      set{

        this.overridesBaseClassMember = value;

        this.overridesBaseClassMemberSpecifiedExplicitly = true;

      }

    }

    /// <summary>

    /// Gets the first attribute of the given type in the attribute list of this member. Returns null if none found.

    /// This should not be called until the AST containing this member has been processed to replace symbolic references

    /// to members with references to the actual members.

    /// </summary>

    public virtual AttributeNode GetAttribute(TypeNode attributeType) {

      if (attributeType == null) return null;

      AttributeList attributes = this.Attributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null) {

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != attributeType) continue;

          return attr;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit == null) continue;

        if ((lit.Value as TypeNode) != attributeType) continue;

        return attr;

      }

      return null;

    }

    public virtual AttributeList GetFilteredAttributes(TypeNode attributeType){

      if (attributeType == null) return this.Attributes;

      AttributeList attributes = this.Attributes;

      AttributeList filtered = new AttributeList();

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null) {

          if (mb.BoundMember != null && mb.BoundMember.DeclaringType == attributeType) continue;

          filtered.Add(attr);

          continue;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit != null && (lit.Value as TypeNode) == attributeType) continue;

        filtered.Add(attr);

      }

      return filtered;

    }

#if ExtendedRuntime

    public virtual AttributeList GetAllAttributes(TypeNode attributeType)

    {

      AttributeList filtered = new AttributeList();

      if (attributeType == null) return filtered;

      AttributeList attributes = this.Attributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null) {

          if (mb.BoundMember != null && mb.BoundMember.DeclaringType == attributeType)

            filtered.Add(attr);

          continue;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit != null && (lit.Value as TypeNode) == attributeType)

          filtered.Add(attr);

      }

      return filtered;

    }



    /// <summary>

    /// If this is true, the name of the member is meaningless and the member is intended as an "invisible" container for other members.

    /// The value of this property is controlled by the presence or absence of the Anonymous attribute.

    /// </summary>

    public bool IsAnonymous{

      get{ 

        switch (this.Anonymity){

          case Anonymity.None:

          case Anonymity.Unknown:

            return false;

          default:

            return true;

        }

      }

    }

    /// <summary>

    /// Exposes the value of the Anonymous attribute. The value is Anonimity.None if no attribute is present.

    /// </summary>

    public Anonymity Anonymity{

      get{

        if (this.anonymity == Anonymity.Unknown){

          AttributeNode attr = this.GetAttribute(SystemTypes.AnonymousAttribute);

          if (attr == null)

            this.anonymity = Anonymity.None;

          else{

            this.anonymity = Anonymity.Structural; // default

            if (attr.Expressions != null){

              for (int i = 0, n = attr.Expressions.Count; i < n; i++){

                NamedArgument na = attr.Expressions[i] as NamedArgument;

                if (na == null || na.Name != null) continue;

                if (na.Name.UniqueIdKey == StandardIds.Anonymity.UniqueIdKey){

                  Literal lit = na.Value as Literal;

                  if (lit == null) continue;

                  this.anonymity = (Anonymity)lit.Value;

                  break;

                }

              }

            }

          }

        }

        return this.anonymity;

      }

    }

    CciMemberKind cciKind;

    public CciMemberKind CciKind{

      get{

        if (cciKind == CciMemberKind.Unknown){

          AttributeNode a = GetAttribute(SystemTypes.CciMemberKindAttribute);

          if (a == null)

            cciKind = CciMemberKind.Regular;

          else

            cciKind = (CciMemberKind) ((Literal) a.Expressions[0]).Value;

        }

        return cciKind;

      }

      set{

        this.cciKind = value;

      }

    }

#endif

    /// <summary>

    /// The concatenation of the FullName of the containing member and the name of this member. 

    /// Separated with a '.' character if the containing member is a namespace and a '+' character if the containing member is a Type.

    /// Includes the parameter type full names when this member is a method or a property. Also includes (generic) template arguments.

    /// </summary>

    public abstract string/*!*/ FullName { get;}

    /// <summary>True if all references to this member must be from the assembly containing the definition of this member. </summary>

    public abstract bool IsAssembly{get;}

    /// <summary>

    /// True if access to this member is controlled by the compiler and not the runtime. Cannot be accessed from other assemblies since these

    /// are not necessarily controlled by the same compiler.

    /// </summary>

    public abstract bool IsCompilerControlled{get;}

    /// <summary>True if this member can only be accessed from subclasses of the class declaring this member.</summary>

    public abstract bool IsFamily{get;}

    /// <summary>True if this member can only be accessed from subclasses of the class declaring this member, provided that these subclasses are also

    /// contained in the assembly containing this member.</summary>

    public abstract bool IsFamilyAndAssembly{get;}

    /// <summary>True if all references to this member must either be from the assembly containing the definition of this member,

    /// or from a subclass of the class declaring this member.</summary>

    public abstract bool IsFamilyOrAssembly{get;}

    /// <summary>True if all references to this member must be from members of the type declaring this member./// </summary>

    public abstract bool IsPrivate{get;}

    /// <summary>True if the member can be accessed from anywhere./// </summary>

    public abstract bool IsPublic{get;}

    /// <summary>True if the name of this member conforms to a naming pattern with special meaning. For example the name of a property getter.</summary>

    public abstract bool IsSpecialName{get;}

    /// <summary>True if this member always has the same value or behavior for all instances the declaring type.</summary>

    public abstract bool IsStatic{get;}

    /// <summary>True if another assembly can contain a reference to this member.</summary>

    public abstract bool IsVisibleOutsideAssembly{get;}

    /// <summary>A cached reference to the first Obsolete attribute of this member. Null if no such attribute exsits.</summary>

    public ObsoleteAttribute ObsoleteAttribute{

      get{

        if (this.notObsolete) return null;

        if (this.obsoleteAttribute == null){

          AttributeNode attr = this.GetAttribute(SystemTypes.ObsoleteAttribute);

          if (attr != null){

            ExpressionList args = attr.Expressions;

            int numArgs = args == null ? 0 : args.Count;

            Literal lit0 = numArgs > 0 ? args[0] as Literal : null;

            Literal lit1 = numArgs > 1 ? args[1] as Literal : null;

            string message = lit0 != null ? lit0.Value as string : null;

            object isError = lit1 != null ? lit1.Value : null;

            if (isError is bool)

              return this.obsoleteAttribute = new ObsoleteAttribute(message, (bool)isError);

            else

              return this.obsoleteAttribute = new ObsoleteAttribute(message);

          }

          this.notObsolete = true;

        }

        return this.obsoleteAttribute;

      }

      set{

        this.obsoleteAttribute = value;

        this.notObsolete = false;

      }

    }

#if !MinimalReader

    /// <summary>The source code, if any, corresponding to the value in Documentation.</summary>

    public Node DocumentationNode;

#endif

#if !NoXml

    protected XmlNode documentation;

    /// <summary>The body of an XML element containing a description of this member. Used to associated documentation (such as this comment) with members.

    /// The fragment usually conforms to the structure defined in the C# standard.</summary>

    public virtual XmlNode Documentation{

      get{

        XmlNode documentation = this.documentation;

        if (documentation != null) return documentation;

        TypeNode t = this.DeclaringType;

        if (t == null) t = this as TypeNode;

        Module m = t == null ? null : t.DeclaringModule;

        TrivialHashtable cache = m == null ? null : m.GetMemberDocumentationCache();

        if (cache == null) return null;

        return this.documentation = (XmlNode)cache[this.DocumentationId.UniqueIdKey];

      }

      set{

        this.documentation = value;

      }

    }

    protected Identifier documentationId;

    protected virtual Identifier GetDocumentationId(){

      return Identifier.Empty;

    }

    /// <summary>

    /// The value of the name attribute of the XML element whose body is the XML fragment returned by Documentation.

    /// </summary>

    public Identifier DocumentationId{

      get{

        Identifier documentationId = this.documentationId;

        if (documentationId != null) return documentationId;

        return this.DocumentationId = this.GetDocumentationId();

      }

      set{

        this.documentationId = value;

      }

    }

    protected string helpText;

    /// <summary>

    /// The value of the summary child element of the XML fragment returned by Documentation. All markup is stripped from the value.

    /// </summary>

    public virtual string HelpText{

      get{

        string helpText = this.helpText;

        if (helpText != null) return helpText;

        XmlNode documentation = this.Documentation;

        if (documentation != null && documentation.HasChildNodes){

          //^ assume documentation.ChildNodes != null;

          foreach (XmlNode child in documentation.ChildNodes)

            if (child.Name == "summary")

              return this.helpText = this.GetHelpText(child);

        }

        return this.helpText = "";

      }

      set{

        this.helpText = value;

      }

    }

    public virtual string GetParameterHelpText(string parameterName){

      XmlNode documentation = this.Documentation;

      if (documentation == null || documentation.ChildNodes == null) return null;

      foreach (XmlNode cdoc in documentation.ChildNodes){

        if (cdoc == null) continue;

        if (cdoc.Name != "param") continue;

        if (cdoc.Attributes == null) continue;

        foreach (XmlAttribute attr in cdoc.Attributes){

          if (attr == null || attr.Name != "name" || attr.Value != parameterName) continue;

          if (!cdoc.HasChildNodes) continue;

          return this.GetHelpText(cdoc);

        }

      }

      return null;

    }

    private string GetHelpText(XmlNode node){

      if (node == null) return "";

      StringBuilder sb = new StringBuilder();

      if (node.HasChildNodes){

        foreach (XmlNode child in node.ChildNodes){

          switch (child.NodeType){

            case XmlNodeType.Element:

              string str = this.GetHelpText(child);

              if (str == null || str.Length == 0) continue;

              if (sb.Length > 0 && !Char.IsPunctuation(str[0]))

                sb.Append(' ');

              sb.Append(str);

              break;

            case XmlNodeType.CDATA:

            case XmlNodeType.Entity:

            case XmlNodeType.Text:

              this.AppendValue(sb, child);

              break;

          }

        }

      }else if (node.Attributes != null){

        foreach (XmlAttribute attr in node.Attributes){

          this.AppendValue(sb, attr);

        }

      }

      return sb.ToString();

    }

    private int filterPriority;

    public virtual System.ComponentModel.EditorBrowsableState FilterPriority {

      get {

        if (this.filterPriority > 0) return (System.ComponentModel.EditorBrowsableState)(this.filterPriority-1);

        int prio = 0;

        XmlNode documentation = this.Documentation;

        if (documentation != null && documentation.HasChildNodes) {

          foreach (XmlNode child in documentation.ChildNodes)

            if (child.Name == "filterpriority") {

              PlatformHelpers.TryParseInt32(child.InnerText, out prio);

              switch (prio) {

                case 2: this.filterPriority = (int)System.ComponentModel.EditorBrowsableState.Advanced; break;

                case 3: this.filterPriority = (int)System.ComponentModel.EditorBrowsableState.Never; break;

                default: this.filterPriority = (int)System.ComponentModel.EditorBrowsableState.Always; break;

              }

              this.filterPriority++;

              return (System.ComponentModel.EditorBrowsableState)(this.filterPriority - 1);

            }

        }

        AttributeList attributes = this.Attributes;

        for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

          //^ assert attributes != null;

          AttributeNode attr = attributes[i];

          if (attr == null || attr.Type == null) continue;

          if (attr.Expressions == null || attr.Expressions.Count < 1) continue;

          if (attr.Type.FullName != "System.ComponentModel.EditorBrowsableAttribute") continue;

          Literal lit = attr.Expressions[0] as Literal;

          if (lit == null || !(lit.Value is int)) continue;

          //^ assert lit.Value != null;

          prio = (int)lit.Value;

          return (System.ComponentModel.EditorBrowsableState)((this.filterPriority = prio+1) - 1);

        }

        return (System.ComponentModel.EditorBrowsableState)((this.filterPriority = 1) - 1);

      }

      set {

        this.filterPriority = ((int)value)+1;

      }

    }

    /// <summary>

    /// Writes out an element with tag "element", name attribute DocumentationId.ToString() and body Documentation using the provided XmlTextWriter instance.

    /// </summary>

    public virtual void WriteDocumentation(XmlTextWriter xwriter){

      if (this.documentation == null || xwriter == null) return;

      xwriter.WriteStartElement("member");

      if (this.DocumentationId == null) return;

      xwriter.WriteAttributeString("name", this.DocumentationId.ToString());

      this.documentation.WriteContentTo(xwriter);

      xwriter.WriteEndElement();

    }

    private readonly static char[]/*!*/ tags = {'E', 'F', 'M', 'P', 'T'};

    private void AppendValue(StringBuilder/*!*/ sb, XmlNode/*!*/ node) {

      string str = node.Value;

      if (str != null){

        str = str.Trim();

        if (str.Length > 2 && str[1] == ':' && str.LastIndexOfAny(tags, 0, 1) == 0){

          char tag = str[0];

          str = str.Substring(2);

          if (tag == 'T' && str.IndexOf(TargetPlatform.GenericTypeNamesMangleChar) >= 0) {

            Module mod = null;

            if (this.DeclaringType != null)

              mod = this.DeclaringType.DeclaringModule;

            else if (this is TypeNode)

              mod = ((TypeNode)this).DeclaringModule;

            if (mod != null){

              Identifier ns;

              Identifier tn;

              int i = str.LastIndexOf('.');

              if (i < 0 || i >= str.Length){

                ns = Identifier.Empty;

                tn = Identifier.For(str);

              }else{

                ns = Identifier.For(str.Substring(0, i));

                tn = Identifier.For(str.Substring(i + 1));

              }

              TypeNode t = mod.GetType(ns, tn, true);

              if (t != null) str = t.GetFullUnmangledNameWithTypeParameters();

            }

          }

        }

        if (str == null || str.Length == 0) return;

        bool lastCharWasSpace = false;

        if (sb.Length > 0 && !Char.IsPunctuation(str[0]) && !Char.IsWhiteSpace(str[0])){

          sb.Append(' ');

          lastCharWasSpace = true;

        }

        foreach (char ch in str){

          if (Char.IsWhiteSpace(ch)){

            if (lastCharWasSpace) continue;

            lastCharWasSpace = true;

            sb.Append(' ');

          }else{

            lastCharWasSpace = false;

            sb.Append(ch);

          }

        }

        if (sb.Length > 0 && Char.IsWhiteSpace(sb[sb.Length-1]))

          sb.Length -= 1;

      }

    }

#endif

#if FxCop

    internal string GetName(MemberFormat options)

    {

      StringBuilder name = new StringBuilder();

      GetName(options, name);

      return name.ToString();

    }

    internal virtual void GetName(MemberFormat options, StringBuilder name)

    {

      if (options.Type.TypeName != TypeNameFormat.None && this.DeclaringType != null)

      {

        this.DeclaringType.GetName(options, name);

        name.Append('.');

      }

      name.Append(this.Name.Name);

    }

#endif

  }

#if !MinimalReader

  public class TypeMemberSnippet : Member{

    public IParserFactory ParserFactory;



    public TypeMemberSnippet()

      : base(NodeType.TypeMemberSnippet){

    }

    public TypeMemberSnippet(IParserFactory parserFactory, SourceContext sctx)

      : base(NodeType.TypeMemberSnippet){

      this.ParserFactory = parserFactory;

      this.SourceContext = sctx;

    }

    public override string/*!*/ FullName {

      get{throw new InvalidOperationException();}

    }

    public override bool IsCompilerControlled{

      get{throw new InvalidOperationException();}

    }

    public override bool IsAssembly{

      get{throw new InvalidOperationException();}

    }

    public override bool IsFamily{

      get{throw new InvalidOperationException();}

    }

    public override bool IsFamilyAndAssembly{

      get{throw new InvalidOperationException();}

    }

    public override bool IsFamilyOrAssembly{

      get{throw new InvalidOperationException();}

    }

    public override bool IsPrivate{

      get{throw new InvalidOperationException();}

    }

    public override bool IsPublic{

      get{throw new InvalidOperationException();}

    }

    public override bool IsSpecialName{

      get{throw new InvalidOperationException();}

    }

    public override bool IsStatic{

      get{throw new InvalidOperationException();}

    }

    public override bool IsVisibleOutsideAssembly {

      get{throw new InvalidOperationException();}

    }



  }

#endif

  /// <summary>

  /// The common base class for all types. This type should not be extended directly.

  /// Instead extend one of the standard subclasses such as Class, Struct or Interface, since in

  /// the CLR a type has to be an instance of one the subclasses, and a type which does not extend

  /// one of these types will have no equivalent in the CLR.

  /// </summary>

  public abstract class TypeNode : Member

#if ExtendedRuntime

  , IEquatable<TypeNode>

#endif

  {

#if ExtendedRuntime

    /// <summary>The invariants and modelfield contracts associated with this type (for now only classes, interfaces, structs).</summary>

    public TypeContract Contract;

#endif

    private int classSize;

    /// <summary>Specifies the total size in bytes of instances of types with prescribed layout.</summary>

    public int ClassSize{

      get{return this.classSize;}

      set{this.classSize = value;}

    }

    private Module declaringModule;

    /// <summary>The module or assembly to which the compiled type belongs.</summary>

    public Module DeclaringModule{

      get{return this.declaringModule;}

      set{this.declaringModule = value;}

    }

    private TypeFlags flags;

    public TypeFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    /// <summary>The interfaces implemented by this class or struct, or the extended by this interface.</summary>

    public virtual InterfaceList Interfaces {

      get { if (this.interfaces == null) { this.interfaces = new InterfaceList(0);} return this.interfaces; }

      set { this.interfaces = value; }

    }

    protected InterfaceList interfaces;

#if !MinimalReader

    public InterfaceList InterfaceExpressions;

#endif

    private Identifier @namespace;

    /// <summary>The namespace to which this type belongs. Null if the type is nested inside another type.</summary>

    public Identifier Namespace{

      get{return this.@namespace;}

      set{this.@namespace = value;}

    }

    private int packingSize;

    /// <summary>Specifies the alignment of fields within types with prescribed layout.</summary>

    public int PackingSize{

      get{return this.packingSize;}

      set{this.packingSize = value;}

    }

#if !MinimalReader

    /// <summary>If this type is the combined result of a number of partial type definitions, this lists the partial definitions.</summary>

    public TypeNodeList IsDefinedBy;

#endif

    /// <summary>

    /// True if this type is the result of a template instantiation with arguments that are themselves template parameters. 

    /// Used to model template instantiations occurring inside templates.

    /// </summary>

    public bool IsNotFullySpecialized;

    public bool NewTemplateInstanceIsRecursive;

#if !MinimalReader

    /// <summary>

    /// If this type is a partial definition, the value of this is the combined type resulting from all the partial definitions.

    /// </summary>

    public TypeNode PartiallyDefines;

    /// <summary>

    /// The list of extensions of this type, if it's a non-extension type.

    /// all extensions implement the IExtendTypeNode interface (in the Sing# code base).

    /// null = empty list

    /// </summary>

    private TypeNodeList extensions = null;

    /// <summary>

    /// Whether or not the list of extensions has been examined;

    /// it's a bug to record a new extension after extensions have been examined.

    /// </summary>

    private bool extensionsExamined = false;

    /// <summary>

    /// Record another extension of this type.

    /// </summary>

    /// <param name="extension"></param>

    public void RecordExtension(TypeNode extension) { 

      Debug.Assert(!extensionsExamined, "adding an extension after they've already been examined");

      if (this.extensions == null) this.extensions = new TypeNodeList();

      this.extensions.Add(extension);

    }

    /// <summary>

    /// The property that should be accessed by clients to get the list of extensions of this type.

    /// </summary>

    public TypeNodeList Extensions {

      get {

        this.extensionsExamined = true;

        return this.extensions;

      }

      set {

        Debug.Assert(!extensionsExamined, "setting extensions after they've already been examined");

        this.extensions = value;

      }

    }

    /// <summary>

    /// When duplicating a type node, we want to transfer the extensions and the extensionsExamined flag without 

    /// treating this as a "touch" that sets the examined flag.  Pretty ugly, though.

    /// </summary>

    public TypeNodeList ExtensionsNoTouch{

      get{ return this.extensions; }

    }

    /// <summary>

    /// Copy a (possibly transformed) set of extensions from source to the

    /// receiver, including whether or not the extensions have been examined.

    /// </summary>

    public void DuplicateExtensions(TypeNode source, TypeNodeList newExtensions){

      if (source == null) return;

      this.extensions = newExtensions;

      this.extensionsExamined = source.extensionsExamined;

    }

    /// <summary>

    /// If the receiver is a type extension, return the extendee, otherwise return the receiver.

    /// [The identity function, except for dialects (e.g. Extensible Sing#) that allow

    /// extensions and differing views of types]

    /// </summary>

    public virtual TypeNode/*!*/ EffectiveTypeNode{

      get{

        return this;

      }

    }

    /// <summary>

    /// Return whether t1 represents the same type as t2 (or both are null).

    /// This copes with the cases where t1 and/or t2 may be type views and/or type extensions, as

    /// in Extensible Sing#.

    /// </summary>

    public static bool operator ==(TypeNode t1, TypeNode t2){

      return

        (object)t1 == null ?

          (object)t2 == null :

          (object)t2 != null && (object)t1.EffectiveTypeNode == (object)t2.EffectiveTypeNode;

    }

    // modify the other operations related to equality

    public static bool operator !=(TypeNode t1, TypeNode t2){

      return !(t1 == t2);

    }

    public override bool Equals(Object other){

      return this == (other as TypeNode);

    }

#if ExtendedRuntime

    public bool Equals(TypeNode other)

    {

      return this == other;

    }

#endif

    public override int GetHashCode(){

      TypeNode tn = this.EffectiveTypeNode;

      if ((object)tn == (object)this){

        return base.GetHashCode();

      } else {

        return tn.GetHashCode();

      }

    }

#endif

    /// <summary>

    /// A delegate that is called the first time Members is accessed, if non-null.

    /// Provides for incremental construction of the type node.

    /// Must not leave Members null.

    /// </summary>

    public TypeMemberProvider ProvideTypeMembers;

    /// <summary>

    /// The type of delegates that fill in the Members property of the given type.

    /// </summary>

    public delegate void TypeMemberProvider(TypeNode/*!*/ type, object/*!*/ handle);

    /// <summary>

    /// A delegate that is called the first time NestedTypes is accessed, if non-null.

    /// </summary>

    public NestedTypeProvider ProvideNestedTypes;

    /// <summary>

    /// The type of delegates that fill in the NestedTypes property of the given type.

    /// </summary>

    public delegate void NestedTypeProvider(TypeNode/*!*/ type, object/*!*/ handle);

    /// <summary>

    /// A delegate that is called the first time Attributes is accessed, if non-null.

    /// Provides for incremental construction of the type node.

    /// Must not leave Attributes null.

    /// </summary>

    public TypeAttributeProvider ProvideTypeAttributes;

    /// <summary>

    /// The type of delegates that fill in the Attributes property of the given type.

    /// </summary>

    public delegate void TypeAttributeProvider(TypeNode/*!*/ type, object/*!*/ handle);

    /// <summary>

    /// Opaque information passed as a parameter to the delegates in ProvideTypeMembers et al.

    /// Typically used to associate this namespace instance with a helper object.

    /// </summary>

    public object ProviderHandle;

    private TypeNodeList templateInstances;

    /// <summary>Contains all the types instantiated from this non generic template type.</summary>

    public TypeNodeList TemplateInstances{

      get{return this.templateInstances;}

      set{this.templateInstances = value;}

    }

    internal TypeNode(NodeType nodeType)

      : base(nodeType){

#if ExtendedRuntime

      this.Contract = new TypeContract(this, true);

#endif

    }

    internal TypeNode(NodeType nodeType, NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(nodeType){

      this.ProvideNestedTypes = provideNestedTypes;

      this.ProvideTypeAttributes = provideAttributes;

      this.ProvideTypeMembers = provideMembers;

      this.ProviderHandle = handle;

#if !MinimalReader      

      this.isNormalized = true;

#endif

#if ExtendedRuntime

      this.Contract = new TypeContract(this);

#endif

  }

    internal TypeNode(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags flags,

      Identifier Namespace, Identifier name, InterfaceList interfaces, MemberList members, NodeType nodeType)

      : base(null, attributes, name, nodeType){

      this.DeclaringModule = declaringModule;

      this.DeclaringType = declaringType;

      this.Flags = flags;

      this.Interfaces = interfaces;

      this.members = members;

      this.Namespace = Namespace;

#if ExtendedRuntime

      this.Contract = new TypeContract(this, true);

#endif

  }

    public override AttributeList Attributes{

      get{

        if (this.attributes == null){

          if (this.ProvideTypeAttributes != null && this.ProviderHandle != null){

            lock (Module.GlobalLock){

              if (this.attributes == null)

                this.ProvideTypeAttributes(this, this.ProviderHandle);

            }

          }else

            this.attributes = new AttributeList(0);

        }

        return this.attributes;

      }

      set{

        this.attributes = value;

      }

    }

    protected SecurityAttributeList securityAttributes;

    /// <summary>Contains declarative security information associated with the type.</summary>

    public SecurityAttributeList SecurityAttributes{

      get{

        if (this.securityAttributes != null) return this.securityAttributes;

        if (this.attributes == null){

          AttributeList al = this.Attributes; //Getting the type attributes also gets the security attributes, in the case of a type that was read in by the Reader

          if (al != null) al = null;

          if (this.securityAttributes != null) return this.securityAttributes;

        }

        return this.securityAttributes = new SecurityAttributeList(0);

      }

      set{

        this.securityAttributes = value;

      }

    }

    /// <summary>The type from which this type is derived. Null in the case of interfaces and System.Object.</summary>

    public virtual TypeNode BaseType{

      get{

        switch(this.NodeType){

          case NodeType.ArrayType: return CoreSystemTypes.Array;

          case NodeType.ClassParameter:

          case NodeType.Class: return ((Class)this).BaseClass;

          case NodeType.DelegateNode: return CoreSystemTypes.MulticastDelegate;

          case NodeType.EnumNode: return CoreSystemTypes.Enum;

          case NodeType.Struct:

#if !MinimalReader

          case NodeType.TupleType:

          case NodeType.TypeAlias: 

          case NodeType.TypeIntersection:

          case NodeType.TypeUnion: 

#endif

            return CoreSystemTypes.ValueType;

          default: return null;

        }

      }

    }

    protected internal MemberList defaultMembers;

    /// <summary>A list of any members of this type that have the DefaultMember attribute.</summary>

    public virtual MemberList DefaultMembers{

      get{

        int n = this.Members.Count;

        if (n != this.memberCount){

          this.UpdateMemberTable(n);

          this.defaultMembers = null;

        }

        if (this.defaultMembers == null){

          AttributeList attrs = this.Attributes;

          Identifier defMemName = null;

          for (int j = 0, m = attrs == null ? 0 : attrs.Count; j < m; j++){

            //^ assert attrs != null;

            AttributeNode attr = attrs[j];

            if (attr == null) continue;

            MemberBinding mb = attr.Constructor as MemberBinding;

            if (mb != null && mb.BoundMember != null && mb.BoundMember.DeclaringType == SystemTypes.DefaultMemberAttribute){

              if (attr.Expressions != null && attr.Expressions.Count > 0){

                Literal lit = attr.Expressions[0] as Literal;

                if (lit != null && lit.Value is string)

                  defMemName = Identifier.For((string)lit.Value);

              }

              break;

            }

            Literal litc = attr.Constructor as Literal;

            if (litc != null && (litc.Value as TypeNode) == SystemTypes.DefaultMemberAttribute){

              if (attr.Expressions != null && attr.Expressions.Count > 0){

                Literal lit = attr.Expressions[0] as Literal;

                if (lit != null && lit.Value is string)

                  defMemName = Identifier.For((string)lit.Value);

              }

              break;

            }

          }

          if (defMemName != null)

            this.defaultMembers = this.GetMembersNamed(defMemName);

          else

            this.defaultMembers = new MemberList(0);

        }

        return this.defaultMembers;

      }

      set{

        this.defaultMembers = value;

      }

    }

    protected string fullName;

    public override string/*!*/ FullName {

      get{

        if (this.fullName != null) return this.fullName;

         if (this.DeclaringType != null)

           return this.fullName = this.DeclaringType.FullName+"+"+(this.Name == null ? "" : this.Name.ToString());

         else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

           return this.fullName = this.Namespace.ToString()+"."+(this.Name == null ? "" : this.Name.ToString());

         else if (this.Name != null)

           return this.fullName = this.Name.ToString();

         else

           return this.fullName = "";

       }

     }

#if !MinimalReader

    // the same as FullName, except for dialects like Sing# with type extensions where names of

    // type extensions may get mangled; in that case, this reports the name of the effective type node.

    public virtual string FullNameDuringParsing {

      get{ return this.FullName; }

    }

#endif

     public virtual string GetFullUnmangledNameWithoutTypeParameters(){

       if (this.DeclaringType != null)

         return this.DeclaringType.GetFullUnmangledNameWithoutTypeParameters()+"+"+this.GetUnmangledNameWithoutTypeParameters();

       else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

         return this.Namespace.ToString()+"."+this.GetUnmangledNameWithoutTypeParameters();

       else

         return this.GetUnmangledNameWithoutTypeParameters();

     }

     public virtual string GetFullUnmangledNameWithTypeParameters(){

      if (this.DeclaringType != null)

        return this.DeclaringType.GetFullUnmangledNameWithTypeParameters()+"+"+this.GetUnmangledNameWithTypeParameters(true);

      else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

        return this.Namespace.ToString()+"."+this.GetUnmangledNameWithTypeParameters(true);

      else

        return this.GetUnmangledNameWithTypeParameters(true);

    }

    public virtual string GetUnmangledNameWithTypeParameters(){

      return this.GetUnmangledNameWithTypeParameters(false);

    }

    private string GetUnmangledNameWithTypeParameters(bool fullNamesForTypeParameters){

      StringBuilder sb = new StringBuilder(this.GetUnmangledNameWithoutTypeParameters());

      TypeNodeList templateParameters = this.TemplateParameters;

      if (this.Template != null) templateParameters = this.TemplateArguments;

      for (int i = 0, n = templateParameters == null ? 0 : templateParameters.Count; i < n; i++){

        //^ assert templateParameters != null;

        TypeNode tpar = templateParameters[i];

        if (tpar == null) continue;

        if (i == 0)

          sb.Append('<');

        else

          sb.Append(',');

        if (tpar.Name != null)

          if (fullNamesForTypeParameters)

            sb.Append(tpar.GetFullUnmangledNameWithTypeParameters());

          else

            sb.Append(tpar.GetUnmangledNameWithTypeParameters());

        if (i == n-1)

          sb.Append('>');

      }

      return sb.ToString();

    }

    protected static readonly char[]/*!*/ MangleChars = new char[]{'!', '>'};

    public virtual string/*!*/ GetUnmangledNameWithoutTypeParameters(){

      TypeNode.MangleChars[0] = TargetPlatform.GenericTypeNamesMangleChar;

      if (this.Template != null) return this.Template.GetUnmangledNameWithoutTypeParameters();

      if (this.Name == null) return "";

      string name = this.Name.ToString();

      if (this.TemplateParameters != null && this.TemplateParameters.Count > 0){

        int lastMangle = name.LastIndexOfAny(TypeNode.MangleChars);

        if (lastMangle >= 0){

          if (name[lastMangle] == '>') lastMangle++;

          return name.Substring(0, lastMangle);

        }

      }

      return name;

    }



#if !MinimalReader

    public virtual string GetSerializedTypeName() {

      bool isAssemblyQualified = true;

      return this.GetSerializedTypeName(this, ref isAssemblyQualified);

    }

    string GetSerializedTypeName(TypeNode/*!*/ type, ref bool isAssemblyQualified) {

      if (type == null) return null;

      StringBuilder sb = new StringBuilder();

      TypeModifier tMod = type as TypeModifier;

      if (tMod != null) 

        type = tMod.ModifiedType;

      ArrayType arrType = type as ArrayType;

      if (arrType != null) {

        type = arrType.ElementType;

        bool isAssemQual = false;

        this.AppendSerializedTypeName(sb, arrType.ElementType, ref isAssemQual);

        if (arrType.IsSzArray())

          sb.Append("[]");

        else {

          sb.Append('[');

          if (arrType.Rank == 1) sb.Append('*');

          for (int i = 1; i < arrType.Rank; i++) sb.Append(',');

          sb.Append(']');

        }

        goto done;

      }

      Pointer pointer = type as Pointer;

      if (pointer != null) {

        type = pointer.ElementType;

        bool isAssemQual = false;

        this.AppendSerializedTypeName(sb, pointer.ElementType, ref isAssemQual);

        sb.Append('*');

        goto done;

      }

      Reference reference = type as Reference;

      if (reference != null) {

        type = reference.ElementType;

        bool isAssemQual = false;

        this.AppendSerializedTypeName(sb, reference.ElementType, ref isAssemQual);

        sb.Append('&');

        goto done;

      }

      if (type.Template == null)

        sb.Append(type.FullName);

      else {

        sb.Append(type.Template.FullName);

        sb.Append('[');

        for (int i = 0, n = type.TemplateArguments == null ? 0 : type.TemplateArguments.Count; i < n; i++) {

          //^ assert type.TemplateArguments != null;

          bool isAssemQual = true;

          this.AppendSerializedTypeName(sb, type.TemplateArguments[i], ref isAssemQual);

          if (i < n-1) sb.Append(',');

        }

        sb.Append(']');

      }

    done:

      if (isAssemblyQualified)

        this.AppendAssemblyQualifierIfNecessary(sb, type, out isAssemblyQualified);

      return sb.ToString();

    }

    void AppendAssemblyQualifierIfNecessary(StringBuilder/*!*/ sb, TypeNode type, out bool isAssemQualified) {

      isAssemQualified = false;

      if (type == null) return;

      AssemblyNode referencedAssembly = type.DeclaringModule as AssemblyNode;

      if (referencedAssembly != null) {

        sb.Append(", ");

        sb.Append(referencedAssembly.StrongName);

        isAssemQualified = true;

      }

    }

    void AppendSerializedTypeName(StringBuilder/*!*/ sb, TypeNode type, ref bool isAssemQualified) {

      if (type == null) return;

      string argTypeName = this.GetSerializedTypeName(type, ref isAssemQualified);

      if (isAssemQualified) sb.Append('[');

      sb.Append(argTypeName);

      if (isAssemQualified) sb.Append(']');

    }

#endif



    /// <summary>

    /// Return the name the constructor should have in this type node.  By default, it's

    /// the same as the name of the enclosing type node, but it can be different in e.g. 

    /// extensions in Extensible Sing#

    /// </summary>

    public virtual Identifier ConstructorName {

      get {

        if (this.constructorName == null) {

          Identifier id = this.Name;

          if (this.IsNormalized && this.IsGeneric)

            id = Identifier.For(this.GetUnmangledNameWithoutTypeParameters());

          this.constructorName = id;

        }

        return this.constructorName;

      }

    }

    private Identifier constructorName;





    /// <summary>True if the type is an abstract class or an interface.</summary>

    public virtual bool IsAbstract{

      get{

        return (this.Flags & TypeFlags.Abstract) != 0;

      }

    }

    public override bool IsAssembly{

      get{

        TypeFlags visibility = this.Flags & TypeFlags.VisibilityMask;

        return visibility == TypeFlags.NotPublic || visibility == TypeFlags.NestedAssembly;

      }

    }

    public override bool IsCompilerControlled{

      get{return false;}

    }

    public override bool IsFamily{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamily;}

    }

    public override bool IsFamilyAndAssembly{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamANDAssem;}

    }

    public override bool IsFamilyOrAssembly{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamORAssem;}

    }

    protected bool isGeneric;

    /// <summary>True if this type is a template conforming to the rules of a generic type in the CLR.</summary>

    public virtual bool IsGeneric{

      get{

        return this.isGeneric;

      }

      set{

        this.isGeneric = value;

      }

    }

#if ExtendedRuntime

    public static bool IsImmutable(TypeNode type) {

      type = TypeNode.StripModifiers(type);

      if (type == null) return false;

      if (type.TypeCode != TypeCode.Object) return true;

      if (type.GetAttribute(SystemTypes.ImmutableAttribute) != null) return true;

      if (type.IsValueType && type.DeclaringModule == CoreSystemTypes.SystemAssembly) return true; //hack.

      return false;

    }

#endif

    public virtual bool IsNestedAssembly {

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedAssembly;}

    }

    public virtual bool IsNestedFamily{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamily;}

    }

    public virtual bool IsNestedFamilyAndAssembly{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamANDAssem;}

    }

    public virtual bool IsNestedInternal{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedFamORAssem;}

    }

    public virtual bool IsNestedIn(TypeNode type){

      for (TypeNode decType = this.DeclaringType; decType != null; decType = decType.DeclaringType){

        if (decType == type) return true;

      }

      return false;

    }

    public virtual bool IsNestedPublic{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedPublic;}

    }

    public virtual bool IsNonPublic{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NotPublic;}

    }

#if !MinimalReader

    protected bool isNormalized;

    /// <summary>

    /// True if the type node is in "normal" form. A node is in "normal" form if it is effectively a node in an AST formed directly

    /// from CLR module or assembly. Such a node can be written out as compiled code to an assembly or module without further processing.

    /// </summary>

    public virtual bool IsNormalized{

      get{

        if (this.isNormalized) return true;

        if (this.DeclaringModule == null) return false;

        return this.isNormalized = this.DeclaringModule.IsNormalized;

      }

      set{

        this.isNormalized = value;

      }

    }

#endif

    public override bool IsPrivate{

      get{return (this.Flags & TypeFlags.VisibilityMask) == TypeFlags.NestedPrivate;}

    }

    /// <summary>True if values of this type can be compared directly in CLR IL instructions.</summary>

    public virtual bool IsPrimitiveComparable{

      get{

        switch(this.typeCode){

          case ElementType.Boolean:

          case ElementType.Char:

          case ElementType.Int8:

          case ElementType.Int16:

          case ElementType.Int32:

          case ElementType.Int64:

          case ElementType.IntPtr:

          case ElementType.UInt8:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UIntPtr:

          case ElementType.Single:

          case ElementType.Double:

            return true;

          default:

            return !(this is Struct) || this is EnumNode || this is Pointer;

        }

      }

    }

    /// <summary>True if values of this type are integers that can be processed by CLR IL instructions.</summary>

    public virtual bool IsPrimitiveInteger{

      get{

        switch(this.typeCode){

          case ElementType.Int8:

          case ElementType.Int16:

          case ElementType.Int32:

          case ElementType.Int64:

          case ElementType.IntPtr:

          case ElementType.UInt8:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UIntPtr:

            return true;

          default:

            return false;

        }

      }

    }

    /// <summary>True if values of this type are integers or floating point numbers that can be processed by CLR IL instructions.</summary>

    public virtual bool IsPrimitiveNumeric{

      get{

        switch(this.typeCode){

          case ElementType.Int8:

          case ElementType.Int16:

          case ElementType.Int32:

          case ElementType.Int64:

          case ElementType.IntPtr:

          case ElementType.UInt8:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UIntPtr:

          case ElementType.Single:

          case ElementType.Double:

            return true;

          default:

            return false;

        }

      }

    }

    /// <summary>True if values of this type are unsigned integers that can be processed by CLR IL instructions.</summary>

    public virtual bool IsPrimitiveUnsignedInteger {

      get {

        switch (this.typeCode) {

          case ElementType.UInt8:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UIntPtr:

            return true;

          default:

            return false;

        }

      }

    }

    public override bool IsPublic {

      get{

        TypeFlags visibility = this.Flags & TypeFlags.VisibilityMask;

        return visibility == TypeFlags.Public || visibility == TypeFlags.NestedPublic;

      }

    }

    /// <summary>True if values of this type can be processed by CLR IL instructions.</summary>

    public virtual bool IsPrimitive{

      get{

        switch(this.typeCode){

          case ElementType.Boolean:

          case ElementType.Char:

          case ElementType.Double:

          case ElementType.Int16:

          case ElementType.Int32:

          case ElementType.Int64:

          case ElementType.Int8:

          case ElementType.IntPtr:

          case ElementType.Single:

          case ElementType.String:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UInt8:

          case ElementType.UIntPtr:

            return true;

          default:

            return false;

        }

      }

    }

    /// <summary>True if the type cannot be derived from.</summary>

    public virtual bool IsSealed{

      get{

        return (this.Flags & TypeFlags.Sealed) != 0;

      }

    }

    public override bool IsSpecialName{

      get{return (this.Flags & TypeFlags.SpecialName) != 0;}

    }

    public override bool IsStatic{

      get{return true;}

    }

    /// <summary>True if the identity of the type depends on its structure rather than its name. 

    /// Arrays, pointers and generic type instances are examples of such types.</summary>

    public virtual bool IsStructural{

      get{

        return this.Template != null;

      }

    }

    /// <summary>True if the type serves as a parameter to a type template.</summary>

    public virtual bool IsTemplateParameter{

      get{

        return false;

      }

    }



    /// <summary>True if the type is a value type containing only fields of unmanaged types.</summary>

    public virtual bool IsUnmanaged{

      get{

#if ExtendedRuntime

        return IsPointerFree;

#else

        return false;

#endif

      }

    }



    /// <summary>A list of the types that contribute to the structure of a structural type.</summary>

    public virtual TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.TemplateArguments;

        if (result != null && result.Count > 0) return result;

        return this.TemplateParameters;

      }

    }

    /// <summary>True if values of this type are unsigned integers that can be processed by CLR IL instructions.</summary>

    public virtual bool IsUnsignedPrimitiveNumeric{

      get{

        switch(this.typeCode){

          case ElementType.UInt8:

          case ElementType.UInt16:

          case ElementType.UInt32:

          case ElementType.UInt64:

          case ElementType.UIntPtr:

            return true;

          default:

            return false;

        }

      }

    }

    /// <summary>True if instances of this type have no identity other than their value and are copied upon assignment.</summary>

    public virtual bool IsValueType{

      get{

        switch(this.NodeType){

          case NodeType.EnumNode:

#if !MinimalReader

          case NodeType.ConstrainedType:

          case NodeType.TupleType:

          case NodeType.TypeAlias:

          case NodeType.TypeIntersection:

          case NodeType.TypeUnion: return true;

#endif

          case NodeType.Struct: return true;

          default: return false;

        }

      }

    }

#if ExtendedRuntime

    /// <summary>True if the type is a value type containing no managed or unmanaged pointers.</summary>

    public virtual bool IsPointerFree

    {

      get

      {

        return false;

      }

    }



    /// <summary>

    /// Returns true if the type is definitely a reference type.

    /// </summary>

    public virtual bool IsReferenceType {

      get {

        switch (this.NodeType) {

          case NodeType.Class:

          case NodeType.Interface:

          case NodeType.Pointer:

          case NodeType.ArrayType:

          case NodeType.DelegateNode:

            return this != SystemTypes.ValueType && this != SystemTypes.Enum;

          default:

            return false;

        }

      }

    }

#endif

    /// <summary>

    /// True if underlying type (modulo type modifiers) is a pointer type (Pointer)

    /// </summary>

    public virtual bool IsPointerType{

      get { return false; }

    }

    public override bool IsVisibleOutsideAssembly{

      get{

        if (this.DeclaringType != null && !this.DeclaringType.IsVisibleOutsideAssembly) return false;

        switch(this.Flags & TypeFlags.VisibilityMask){

          case TypeFlags.Public:

          case TypeFlags.NestedPublic:

            return true;

          case TypeFlags.NestedFamily:

          case TypeFlags.NestedFamORAssem:

            return this.DeclaringType != null && !this.DeclaringType.IsSealed;

          default:

            return false;

        }

      }

    }

    // This field stores those members declared syntactically within

    // this type node.  (Under Extended Sing#, additional members can

    // be logically part of a type node but declared in a separate

    // syntactic type node.)

    protected internal MemberList members;

    protected volatile internal bool membersBeingPopulated;

    /// <summary>

    /// The list of members contained inside this type, by default ignoring any extensions of this type.

    /// (Subclasses in the Extensible Sing# dialect override this to include members of visible extensions.)

    /// If the value of members is null and the value of ProvideTypeMembers is not null, the 

    /// TypeMemberProvider delegate is called to fill in the value of this property.

    /// </summary>

    public virtual MemberList Members{

      get{

        if (this.members == null || this.membersBeingPopulated)

          if (this.ProvideTypeMembers != null && this.ProviderHandle != null){

            lock (Module.GlobalLock){

              if (this.members == null){

                this.membersBeingPopulated = true;

                this.ProvideTypeMembers(this, this.ProviderHandle);

                this.membersBeingPopulated = false;

#if ExtendedRuntime

                this.ApplyOutOfBandContracts();

#endif

            }

            }

          }else

            this.members = new MemberList();

        return this.members;

      }

      set{

        this.members = value;

        this.memberCount = 0;

        this.memberTable = null;

        this.constructors = null;

        this.defaultMembers = null;

#if !MinimalReader

        this.explicitCoercionFromTable = null;

        this.explicitCoercionMethods = null;

        this.explicitCoercionToTable = null;

        this.implicitCoercionFromTable = null;

        this.implicitCoercionMethods = null;

        this.implicitCoercionToTable = null;

        this.opFalse = null;

        this.opTrue = null;

#endif

      }

  }

#if ExtendedRuntime

  protected internal TypeNode ContractType

  {

    get

    {

      AssemblyNode declaringAssembly = this.DeclaringModule as AssemblyNode;

      if (declaringAssembly == null || declaringAssembly.ContractAssembly == null) return null;

      if (this.DeclaringType == null)

      {

        return declaringAssembly.ContractAssembly.GetType(this.Namespace, this.Name);

      }

      else

      {

        TypeNode parentContractType = this.DeclaringType.ContractType;

        if (parentContractType == null) return null;

        return parentContractType.GetNestedType(this.Name);

      }

    }

  }

  protected internal virtual void ApplyOutOfBandContracts(){

      if (this.members == null) return;

      TypeNode contractType = this.ContractType;

      if (contractType == null) return;



      // Copy the type-level contract attributes over to the shadowed type, namely "this".

      int contractsNamespaceKey = SystemTypes.NonNullType.Namespace.UniqueIdKey;

      foreach (AttributeNode attr in contractType.Attributes) {

        if (attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey)

          this.Attributes.Add(attr);

      }



      if (this.BaseType != null) { MemberList junk = this.BaseType.Members; if (junk != null) junk = null; }

      Hashtable contractByFullName = new Hashtable();

      MemberList contractMembers = contractType.Members;

      for (int i = 0, n = contractMembers == null ? 0 : contractMembers.Count; i < n; i++){

        //^ assert contractMembers != null;

        Field f = contractMembers[i] as Field;

        if (f != null) {

          contractByFullName[f.FullName] = f;

          continue;

        }

        Method m = contractMembers[i] as Method;

        if (m == null ) continue;

        string methName = this.FullStrippedName(m);

        contractByFullName[methName] = m;

      }

      for (int i = 0, n = members.Count; i < n; i++){

        Field codeField = members[i] as Field;

        if (codeField != null) {

          Field contractField = contractByFullName[codeField.FullName] as Field;

          if (contractField != null && contractField.Type != null && contractField.Type != codeField.Type) {

            OptionalModifier optFieldType = contractField.Type as OptionalModifier;

            if (optFieldType != null && codeField.Type != null) {

              codeField.Type = OptionalModifier.For(optFieldType.Modifier, codeField.Type);

              codeField.HasOutOfBandContract = true;

            }

          }

          continue;

        }

        Method codeMethod = members[i] as Method;

        if (codeMethod == null) continue;

        // we include the return type since some conversion operators result

        // in overloaded methods whose signatures differ only in return type

        string methName = this.FullStrippedName(codeMethod);

        Method contractMethod = contractByFullName[methName] as Method;

        if (contractMethod != null) {

          this.CopyContractToMethod(contractMethod, codeMethod);

          if (codeMethod.OverridesBaseClassMember) {

            Method overridden = this.FindNearestOverriddenMethod(contractMethod);

            if (overridden != null)

              this.CopyContractToMethod(overridden, codeMethod);

          }

        } else {

          // Maybe there isn't a shadow method declared in contractType, but

          // there still might be out-of-band contracts on an interface method

          // that the codeMethod implements.

          if (codeMethod.ImplementedInterfaceMethods != null && codeMethod.ImplementedInterfaceMethods.Count > 0) {

            foreach (Method m in codeMethod.ImplementedInterfaceMethods) {

              this.CopyContractToMethod(m, codeMethod);

            }

          } else if (codeMethod.ImplicitlyImplementedInterfaceMethods != null) {

            foreach (Method m in codeMethod.ImplicitlyImplementedInterfaceMethods) {

              this.CopyContractToMethod(m, codeMethod);

            }

          }

        }

      }

    }

    protected virtual string/*!*/ FullStrippedName(Method/*!*/ m) {

      StringBuilder sb = new StringBuilder();

      sb.Append(m.DeclaringType.GetFullUnmangledNameWithTypeParameters());

      sb.Append('.');

      if (m.NodeType == NodeType.InstanceInitializer)

        sb.Append("#ctor");

      else if (m.Name != null)

        sb.Append(m.Name.ToString());

      ParameterList parameters = m.Parameters;

      for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){

        Parameter par = parameters[i];

        if (par == null || par.Type == null) continue;

        TypeNode parType = TypeNode.DeepStripModifiers(par.Type);

        Reference rt = parType as Reference;

        if (rt != null && rt.ElementType != null)

          parType = TypeNode.DeepStripModifiers(rt.ElementType).GetReferenceType();

        //^ assert parType != null;

        if (i == 0)

          sb.Append('(');

        else

          sb.Append(',');        

        sb.Append(parType.GetFullUnmangledNameWithTypeParameters());

        if (i == n-1)

          sb.Append(')');

      }

      if (m.ReturnType != null){

        TypeNode retType = TypeNode.DeepStripModifiers(m.ReturnType);

        //^ assert retType != null;

        sb.Append(retType.GetFullUnmangledNameWithTypeParameters());

      }

      return sb.ToString();

    }

    protected virtual void CopyContractToMethod(Method/*!*/ contractMethod, Method/*!*/ codeMethod) {

      codeMethod.HasOutOfBandContract = true;

      if (codeMethod.Contract == null)

        codeMethod.Contract = new MethodContract(codeMethod);

      // setting them to null forces deserialization upon next access to the property

      // NB: This means that out-of-band contracts can be applied *only* to code that

      // does *not* have any contracts since this will wipe them out!!

      codeMethod.Contract.Ensures = null;

      codeMethod.Contract.Modifies = null;

      codeMethod.Contract.Requires = null;



      int contractsNamespaceKey = SystemTypes.NonNullType.Namespace.UniqueIdKey;

      // Copy the method-level contract attributes over to the shadowed method.

      for (int a = 0; a < contractMethod.Attributes.Count; a++){

        AttributeNode attr = contractMethod.Attributes[a];

        if (attr != null && attr.Type != null && attr.Type.Namespace != null &&

          attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey)

          codeMethod.Attributes.Add(attr);

      }

      // Copy over any return attributes to the shadowed method

      for (int a = 0, n = contractMethod.ReturnAttributes == null ? 0 : contractMethod.ReturnAttributes.Count; a < n; a++) {

          AttributeNode attr = contractMethod.ReturnAttributes[a];

          if (attr != null) {

              if (attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey) {

                  if (codeMethod.ReturnAttributes == null) {

                      codeMethod.ReturnAttributes = new AttributeList();

                  }

                  codeMethod.ReturnAttributes.Add(attr);

              }

          }

      }





      // Copy the parameter-level contract attributes and type over to the shadowed method's parameters.

      ParameterList contractParameters = contractMethod.Parameters;

      ParameterList codeParameters = codeMethod.Parameters;

      if (contractParameters != null && codeParameters != null && contractParameters.Count <= codeParameters.Count) {

        for (int i = 0, n = contractParameters.Count; i < n; i++) {

          Parameter contractParameter = contractParameters[i];

          Parameter codeParameter = codeParameters[i];

          if (contractParameter == null || codeParameter == null) continue;

          for (int a = 0, m = contractParameter.Attributes == null ? 0 : contractParameter.Attributes.Count; a < m; a++){

            //^ assert contractParameter.Attributes != null;

            AttributeNode attr = contractParameter.Attributes[a];

            if (attr == null || attr.Type == null) continue;

            if (attr.Type.Namespace != null && attr.Type.Namespace.UniqueIdKey == contractsNamespaceKey){

              if (codeParameter.Attributes == null) codeParameter.Attributes = new AttributeList();

              codeParameter.Attributes.Add(attr);

            }

          }

          if (contractParameter.Type != codeParameter.Type)

            codeParameter.Type = this.CopyModifier(contractParameter.Type, codeParameter.Type);

        }

      }

      if (contractMethod.ReturnType != codeMethod.ReturnType)

        codeMethod.ReturnType = this.CopyModifier(contractMethod.ReturnType, codeMethod.ReturnType);

      codeMethod.fullName = null;

    }

    private TypeNode CopyModifier(TypeNode contractType, TypeNode codeType) {

      if (contractType == null) return codeType;

      Reference rcType = contractType as Reference;

      if (rcType != null) {

        contractType = rcType.ElementType;

        if (contractType == null) return codeType;

        Reference rcodeType = codeType as Reference;

        if (rcodeType == null || rcodeType.ElementType == null) return codeType;

        TypeNode t = CopyModifier(contractType, rcodeType.ElementType);

        return t.GetReferenceType();

      }

      ArrayType acType = contractType as ArrayType;

      if (acType != null) {

        contractType = acType.ElementType;

        if (contractType == null) return codeType;

        ArrayType acodeType = codeType as ArrayType;

        if (acodeType == null || acodeType.ElementType == null) return codeType;

        TypeNode t = CopyModifier(contractType, acodeType.ElementType);

        return t.GetArrayType(1);

      }

      OptionalModifier optModType = contractType as OptionalModifier;

      if (optModType != null && optModType.Modifier != null) {

        TypeNode t = CopyModifier(optModType.ModifiedType, codeType);

        codeType = OptionalModifier.For(optModType.Modifier, t);

      }

      if (contractType.Template != null && codeType.Template != null && contractType.TemplateArguments != null && codeType.TemplateArguments != null) {

        TypeNodeList args = contractType.TemplateArguments.Clone();

        TypeNodeList codeArgs = codeType.TemplateArguments;

        for (int i = 0, n = args.Count, m = codeArgs.Count; i < n && i < m; i++) {

          TypeNode argType = args[i];

          TypeNode codeArgType = codeArgs[i];

          if (argType != codeArgType)

            args[i] = this.CopyModifier(argType, codeArgType);

        }

        return codeType.Template.GetTemplateInstance(codeType, args);

      }

      return codeType;

    }

    public virtual Method FindNearestOverriddenMethod (Method method)

      //^ requires method.IsVirtual;

    {

      if (method == null) return null;

      if (!method.IsVirtual) return null;

      int numParams = method.Parameters == null ? 0 : method.Parameters.Count;

      TypeNode[] paramTypes = new TypeNode[numParams];

      for (int i=0; i<numParams; i++) paramTypes[i] = method.Parameters[i].Type;

      for (TypeNode scan = method.DeclaringType.BaseType; scan != null; scan = scan.BaseType){

        Method overridden = scan.GetMethod(method.Name, paramTypes);

        if (overridden != null) return overridden;

      }

      return null;

    }

    public TypeNodeList ReferencedTemplateInstances;

#endif

    protected TypeNode template;

    /// <summary>The (generic) type template from which this type was instantiated. Null if this is not a (generic) type template instance.</summary>

    public virtual TypeNode Template{

      get{

        TypeNode result = this.template;

        if (result == null){

          if (this.isGeneric || TargetPlatform.GenericTypeNamesMangleChar != '_') return null;

          AttributeList attributes = this.Attributes;

          lock(this){

            if (this.template != null){

              if (this.template == TypeNode.NotSpecified)

                return null;

              return this.template;

          }

#if ExtendedRuntime

          for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

            AttributeNode attr = attributes[i];

            if (attr == null) continue;

            MemberBinding mb = attr.Constructor as MemberBinding;

            if (mb == null || mb.BoundMember == null || mb.BoundMember.DeclaringType != SystemTypes.TemplateInstanceAttribute) continue;

            ExpressionList exprs = attr.Expressions;

            if (exprs == null || exprs.Count != 2) continue;

            Literal lit = exprs[0] as Literal;

            if (lit == null) continue;

            TypeNode templ = lit.Value as TypeNode;

            if (templ != null) {

              lit = exprs[1] as Literal;

              if (lit == null) continue;

              object[] types = lit.Value as object[];

              if (types == null) continue;

              int m = types == null ? 0 : types.Length;

              TypeNodeList templateArguments = new TypeNodeList(m);

              for (int j = 0; j < m; j++) {

                TypeNode t = types[j] as TypeNode;

                if (t == null) continue;

                templateArguments.Add(t);

              }

              this.TemplateArguments = templateArguments;

              return this.template = templ;

            }

          }

#endif

          if (result == null)

              this.template = TypeNode.NotSpecified;

          }

        }else if (result == TypeNode.NotSpecified)

          return null;

        return result;

      }

      set{

        this.template = value;

      }

    }

#if !MinimalReader

    public TypeNode TemplateExpression;

#endif

    protected TypeNodeList templateArguments;

    /// <summary>The arguments used when this (generic) type template instance was instantiated.</summary>

    public virtual TypeNodeList TemplateArguments{

      get{

        if (this.template == null){

          TypeNode templ = this.Template; //Will fill in the arguments

          if (templ != null) templ = null;

        }

        return this.templateArguments;

      }

      set{

        this.templateArguments = value;

      }

    }

#if !MinimalReader

    public TypeNodeList TemplateArgumentExpressions;

#endif

    internal TypeNodeList consolidatedTemplateArguments;

    public virtual TypeNodeList ConsolidatedTemplateArguments{

      get{

        if (this.consolidatedTemplateArguments == null)

          this.consolidatedTemplateArguments = this.GetConsolidatedTemplateArguments();

        return this.consolidatedTemplateArguments;

      }

      set{

        this.consolidatedTemplateArguments = value;

      }

    }

    private void AddTemplateParametersFromAttributeEncoding(TypeNodeList result)

    {

#if ExtendedRuntime

      if (result.Count == 0) {

        AttributeList attributes = this.Attributes;

        for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

          AttributeNode attr = attributes[i];

          if (attr == null) continue;

          MemberBinding mb = attr.Constructor as MemberBinding;

          if (mb == null || mb.BoundMember == null || mb.BoundMember.DeclaringType != SystemTypes.TemplateAttribute) continue;

          ExpressionList exprs = attr.Expressions;

          if (exprs == null || exprs.Count != 1) continue;

          Literal lit = exprs[0] as Literal;

          if (lit == null) continue;

          object[] types = lit.Value as object[];

          if (types == null) continue;

          for (int j = 0, m = types == null ? 0 : types.Length; j < m; j++) {

            TypeNode t = types[j] as TypeNode;

            if (t == null) continue;

            if (t.NodeType == NodeType.TypeParameter || t.NodeType == NodeType.ClassParameter)

              result.Add(t);

          }

          attributes[i] = null;

        }

      }

#endif

    }

    internal TypeNodeList templateParameters;

    /// <summary>The type parameters of this type. Null if this type is not a (generic) type template.</summary>

    public virtual TypeNodeList TemplateParameters{

      get{

        TypeNodeList result = this.templateParameters;

        if (result == null){

          if (this.isGeneric || TargetPlatform.GenericTypeNamesMangleChar != '_') return null; //Can happen when this is nested in a generic type

          TypeNodeList nestedTypes = this.NestedTypes;

          lock (this) {

            if ((result = this.templateParameters) != null) return result.Count == 0 ? null : result;

            result = new TypeNodeList();

            for (int i = 0, n = nestedTypes == null ? 0 : nestedTypes.Count; i < n; i++) {

              TypeNode nt = nestedTypes[i];

              if (nt == null) continue;

              if (nt is MethodTypeParameter) continue;

              if (nt.NodeType == NodeType.TypeParameter || nt.NodeType == NodeType.ClassParameter)

                result.Add(nt);

            }

            this.AddTemplateParametersFromAttributeEncoding(result);

            this.TemplateParameters = result;

          }

        }

        if (result.Count == 0) return null;

        return result;

      }

      set{

        if (value == null){

          if (this.templateParameters == null) return;

          if (this.templateParameters.Count > 0)

            value = new TypeNodeList(0);

        }

        this.templateParameters = value;

      }

    }

    protected internal TypeNodeList consolidatedTemplateParameters;

    public virtual TypeNodeList ConsolidatedTemplateParameters{

      get{

        if (this.consolidatedTemplateParameters == null)

          this.consolidatedTemplateParameters = this.GetConsolidatedTemplateParameters();

        return this.consolidatedTemplateParameters;

      }

      set{

        this.consolidatedTemplateParameters = value;

      }

    }

    internal ElementType typeCode = ElementType.Class;

    /// <summary>The System.TypeCode value that Convert.GetTypeCode will return pass an instance of this type as parameter.</summary>

    public virtual System.TypeCode TypeCode{

      get{

        switch(this.typeCode){

          case ElementType.Boolean : return System.TypeCode.Boolean;

          case ElementType.Char : return System.TypeCode.Char;

          case ElementType.Double : return System.TypeCode.Double;

          case ElementType.Int16 : return System.TypeCode.Int16;

          case ElementType.Int32 : return System.TypeCode.Int32;

          case ElementType.Int64 : return System.TypeCode.Int64;

          case ElementType.Int8 : return System.TypeCode.SByte;

          case ElementType.Single : return System.TypeCode.Single;

          case ElementType.UInt16 : return System.TypeCode.UInt16;

          case ElementType.UInt32 : return System.TypeCode.UInt32;

          case ElementType.UInt64 : return System.TypeCode.UInt64;

          case ElementType.UInt8 : return System.TypeCode.Byte;

          case ElementType.Void : return System.TypeCode.Empty;

          default:

            if (this == CoreSystemTypes.String) return System.TypeCode.String;

#if !MinimalReader

            if (this == CoreSystemTypes.Decimal) return System.TypeCode.Decimal;

            if (this == CoreSystemTypes.DateTime) return System.TypeCode.DateTime;

            if (this == CoreSystemTypes.DBNull) return System.TypeCode.DBNull;

#endif

            return System.TypeCode.Object;

        }

      }

    }   

    private readonly static TypeNode NotSpecified = new Class();

#if !FxCop

    protected

#endif

   internal TrivialHashtableUsingWeakReferences structurallyEquivalentMethod;

#if !MinimalReader

    /// <summary>

    /// Returns the methods of an abstract type that have been left unimplemented. Includes methods inherited from

    /// base classes and interfaces, and methods from any (known) extensions.

    /// </summary>

    /// <param name="result">A method list to which the abstract methods must be appended.</param>

    public virtual void GetAbstractMethods(MethodList/*!*/ result) {

      if (!this.IsAbstract) return;

      //For each interface, get abstract methods and keep those that are not implemented by this class or a base class

      InterfaceList interfaces = this.Interfaces;

      for (int i = 0, n = interfaces == null ? 0 : interfaces.Count; i < n; i++){

        Interface iface = interfaces[i];

        if (iface == null) continue;

        MemberList imembers = iface.Members;

        for (int j = 0, m = imembers == null ? 0 : imembers.Count; j < m; j++){

          Method meth = imembers[j] as Method;

          if (meth == null) continue;

          if (this.ImplementsExplicitly(meth)) continue;

          if (this.ImplementsMethod(meth, true)) continue;

          result.Add(meth);

        }

      }

    }

#endif

    protected internal TrivialHashtable szArrayTypes;

    /// <summary>

    /// Returns a type representing an array whose elements are of this type. Will always return the same instance for the same rank.

    /// </summary>

    /// <param name="rank">The number of dimensions of the array.</param>

    public virtual ArrayType/*!*/ GetArrayType(int rank) {

      return this.GetArrayType(rank, false);

    }

    public virtual ArrayType/*!*/ GetArrayType(int rank, bool lowerBoundIsUnknown) {

      if (rank > 1 || lowerBoundIsUnknown) return this.GetArrayType(rank, 0, 0, new int[0], new int[0]);

      if (this.szArrayTypes == null) this.szArrayTypes = new TrivialHashtable();

      ArrayType result = (ArrayType)this.szArrayTypes[rank];

      if (result != null) return result;

      lock(this){

        result = (ArrayType)this.szArrayTypes[rank];

        if (result != null) return result;

        this.szArrayTypes[rank] = result = new ArrayType(this, 1);

        result.Flags &= ~TypeFlags.VisibilityMask;

        result.Flags |= this.Flags & TypeFlags.VisibilityMask;

        return result;

      }

    }

    protected internal TrivialHashtable arrayTypes;

    /// <summary>

    /// Returns a type representing an array whose elements are of this type. Will always return the same instance for the same rank, sizes and bounds.

    /// </summary>

    /// <param name="rank">The number of dimensions of the array.</param>

    /// <param name="sizes">The size of each dimension.</param>

    /// <param name="loBounds">The lower bound for indices. Defaults to zero.</param>

    public virtual ArrayType/*!*/ GetArrayType(int rank, int[] sizes, int[] loBounds) {

      return this.GetArrayType(rank, sizes == null ? 0 : sizes.Length, loBounds == null ? 0 : loBounds.Length, sizes == null ? new int[0] : sizes, loBounds == null ? new int[0] : loBounds);

    }

    internal ArrayType/*!*/ GetArrayType(int rank, int numSizes, int numLoBounds, int[]/*!*/ sizes, int[]/*!*/ loBounds) {

      if (this.arrayTypes == null) this.arrayTypes = new TrivialHashtable();

      StringBuilder sb = new StringBuilder(rank*5);

      for (int i = 0; i < rank; i++){

        if (i < numLoBounds) sb.Append(loBounds[i]); else sb.Append('0');

        if (i < numSizes){sb.Append(':'); sb.Append(sizes[i]);}

        sb.Append(',');

      }

      Identifier id = Identifier.For(sb.ToString());

      ArrayType result = (ArrayType)this.arrayTypes[id.UniqueIdKey];

      if (result != null) return result;

      lock(this){

        result = (ArrayType)this.arrayTypes[id.UniqueIdKey];

        if (result != null) return result;

        if (loBounds == null) loBounds = new int[0];

        this.arrayTypes[id.UniqueIdKey] = result = new ArrayType(this, rank, sizes, loBounds);

        result.Flags &= ~TypeFlags.VisibilityMask;

        result.Flags |= this.Flags & TypeFlags.VisibilityMask;

        return result;

      }

    }

    protected internal MemberList constructors;

    public virtual MemberList GetConstructors(){

      if (this.Members.Count != this.memberCount) this.constructors = null;

      if (this.constructors != null) return this.constructors;

      lock(this){

        if (this.constructors != null) return this.constructors;

        return this.constructors = TypeNode.WeedOutNonSpecialMethods(this.GetMembersNamed(StandardIds.Ctor), MethodFlags.RTSpecialName);

      }

    }

    /// <summary>

    /// Returns the constructor with the specified parameter types. Returns null if this type has no such constructor.

    /// </summary>

    public virtual InstanceInitializer GetConstructor(params TypeNode[] types){

      return (InstanceInitializer)GetFirstMethod(this.GetConstructors(), types);

    }

#if !NoXml

    protected override Identifier GetDocumentationId(){

      if (this.DeclaringType == null)

        return Identifier.For("T:"+this.FullName);

      else

        return Identifier.For(this.DeclaringType.DocumentationId+"."+this.Name);

    }

    internal virtual void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (this.DeclaringType != null) {

        this.DeclaringType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

        sb.Append('.');

        sb.Append(this.GetUnmangledNameWithoutTypeParameters());

      }else

        sb.Append(this.GetFullUnmangledNameWithoutTypeParameters());

      TypeNodeList templateArguments = this.TemplateArguments;

      int n = templateArguments == null ? 0 : templateArguments.Count;

      if (n == 0) return;

      sb.Append('{');

      for (int i = 0; i < n; i++){

        //^ assert templateArguments != null;

        TypeNode templArg = templateArguments[i];

        if (templArg == null) continue;

        templArg.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

        if (i < n-1) sb.Append(',');

      }

      sb.Append('}');

    }

#endif

    internal TrivialHashtable modifierTable;

    internal TypeNode/*!*/ GetModified(TypeNode/*!*/ modifierType, bool optionalModifier) {

      if (this.modifierTable == null) this.modifierTable = new TrivialHashtable();

      TypeNode result = (TypeNode)this.modifierTable[modifierType.UniqueKey];

      if (result != null) return result;

      result = optionalModifier ? (TypeNode)new OptionalModifier(modifierType, this) : (TypeNode)new RequiredModifier(modifierType, this);

      this.modifierTable[modifierType.UniqueKey] = result;

      return result;

    }

    public virtual TypeNode/*!*/ GetGenericTemplateInstance(Module/*!*/ module, TypeNodeList/*!*/ consolidatedArguments) {

      if (this.DeclaringType == null)

        return this.GetTemplateInstance(module, null, null, consolidatedArguments);

      TypeNodeList myArgs = this.GetOwnTemplateArguments(consolidatedArguments);

      if (myArgs == consolidatedArguments)

        return this.GetTemplateInstance(module, null, this.DeclaringType, consolidatedArguments);

      int n = consolidatedArguments.Count;

      int m = myArgs == null ? 0 : myArgs.Count;

      int k = n - m;

      Debug.Assert(k > 0);

      TypeNodeList parentArgs = new TypeNodeList(k);

      for (int i = 0; i < k; i++) parentArgs.Add(consolidatedArguments[i]);

      TypeNode declaringType = this.DeclaringType.GetGenericTemplateInstance(module, parentArgs);

      TypeNode nestedType = declaringType.GetNestedType(this.Name);

      if (nestedType == null) {

        // can happen if a new nested type is added to a template

        // see if the type appears in the original parent template

        TypeNode declaringTypeTemplate = declaringType.Template;

        TypeNode nestedTemplate = declaringTypeTemplate.GetNestedType(this.Name);

        

        Duplicator duplicator = new Duplicator(module, null);

        duplicator.RecordOriginalAsTemplate = true;

        duplicator.SkipBodies = true;

        duplicator.TypesToBeDuplicated[this.UniqueKey] = this;

        nestedType = duplicator.VisitTypeNode(this, null, null, null, true);

        Specializer specializer = new Specializer(module, declaringTypeTemplate.ConsolidatedTemplateParameters, declaringType.ConsolidatedTemplateArguments);

        specializer.VisitTypeNode(nestedType);



        nestedType.DeclaringType = declaringType;

        declaringType.NestedTypes.Add(nestedType);



        // Debug.Fail("template declaring type dummy instance does not have a nested type corresponding to template"); nestedType = this;

      }

      if (m == 0){Debug.Assert(nestedType.template != null); return nestedType;}

      return nestedType.GetTemplateInstance(module, null, declaringType, myArgs);

    }

    public virtual TypeNode/*!*/ GetTemplateInstance(Module module, params TypeNode[] typeArguments) {

      return this.GetTemplateInstance(module, null, null, new TypeNodeList(typeArguments));

    }

    protected virtual void TryToFindExistingInstance(Module/*!*/ module, TypeNode declaringType, TypeNodeList/*!*/ templateArguments, Identifier/*!*/ mangledName,

      Identifier/*!*/ uniqueMangledName, out TypeNode result, out Identifier unusedMangledName){

      unusedMangledName = null;

      string mangledNameString = mangledName.Name;

      int n = templateArguments.Count;

      int tiCount = 0;

      bool lookInReferencedAssemblies = TargetPlatform.GenericTypeNamesMangleChar != '`'; //REVIEW: huh? why not use IsGeneric?

      result = module.GetStructurallyEquivalentType(this.Namespace == null ? Identifier.Empty : this.Namespace, mangledName, uniqueMangledName, lookInReferencedAssemblies);

      if (this.IsGeneric){

        if (result == null) unusedMangledName = mangledName;

        return;

      }

      while (result != null){

        //Mangled name is the same. But mangling is not unique (types are not qualified with assemblies), so check for equality.

        if (this == result.Template && (declaringType == result.DeclaringType || !this.IsGeneric)){

          bool goodMatch = (result.TemplateArguments != null || n == 0) && result.TemplateArguments.Count == n;

          for (int i = 0; goodMatch && i < n; i++)

            goodMatch = templateArguments[i] == result.TemplateArguments[i];

          if (goodMatch) return;

        }

        //Mangle some more

        mangledName = new Identifier(mangledNameString+(++tiCount).ToString());

        result = module.GetStructurallyEquivalentType(this.Namespace == null ? Identifier.Empty : this.Namespace, mangledName, null, lookInReferencedAssemblies);

      }

      if (result == null) unusedMangledName = mangledName;

    }

    public virtual Identifier/*!*/ GetMangledTemplateInstanceName(TypeNodeList/*!*/ templateArguments, out Identifier/*!*/ uniqueMangledName, out bool notFullySpecialized){

      StringBuilder mangledNameBuilder = new StringBuilder(this.Name.ToString());

      StringBuilder uniqueMangledNameBuilder = new StringBuilder(this.Name.ToString());

      uniqueMangledNameBuilder.Append(this.UniqueKey);

      notFullySpecialized = false;

      for (int i = 0, n = templateArguments.Count; i < n; i++){

        if (i == 0){mangledNameBuilder.Append('<'); uniqueMangledNameBuilder.Append('<');}

        TypeNode t = templateArguments[i];

        if (t == null || t.Name == null) continue;

        if (TypeIsNotFullySpecialized(t)) notFullySpecialized = true;

        mangledNameBuilder.Append(t.FullName);

        uniqueMangledNameBuilder.Append(t.FullName);

        uniqueMangledNameBuilder.Append(t.UniqueKey);

        if (i < n-1){

          mangledNameBuilder.Append(',');

          uniqueMangledNameBuilder.Append(','); 

        }else{

          mangledNameBuilder.Append('>');

          uniqueMangledNameBuilder.Append('>');

        }

      }

      uniqueMangledName = Identifier.For(uniqueMangledNameBuilder.ToString());

      return Identifier.For(mangledNameBuilder.ToString());

    }

    private static bool TypeIsNotFullySpecialized(TypeNode t) {

      TypeNode tt = TypeNode.StripModifiers(t);

      //^ assert tt != null;        

      if (tt is TypeParameter || tt is ClassParameter || tt.IsNotFullySpecialized)

        return true;

      for (int j = 0, m = tt.StructuralElementTypes == null ? 0 : tt.StructuralElementTypes.Count; j < m; j++) {

        TypeNode et = tt.StructuralElementTypes[j];

        if (et == null) continue;

        if (TypeIsNotFullySpecialized(et)) return true;

      }

      return false;

    }

    /// <summary>

    /// Gets an instance for the given template arguments of this (generic) template type.

    /// </summary>

    /// <param name="referringType">The type in which the reference to the template instance occurs. If the template is not

    /// generic, the instance becomes a nested type of the referring type so that it has the same access privileges as the

    /// code referrring to the instance.</param>

    /// <param name="templateArguments">The template arguments.</param>

    /// <returns>An instance of the template. Always the same instance for the same arguments.</returns>

    public virtual TypeNode/*!*/ GetTemplateInstance(TypeNode referringType, params TypeNode[] templateArguments) {

      return this.GetTemplateInstance(referringType, new TypeNodeList(templateArguments));

    }

    /// <summary>

    /// Gets an instance for the given template arguments of this (generic) template type.

    /// </summary>

    /// <param name="referringType">The type in which the reference to the template instance occurs. If the template is not

    /// generic, the instance becomes a nested type of the referring type so that it has the same access privileges as the

    /// code referrring to the instance.</param>

    /// <param name="templateArguments">The template arguments.</param>

    /// <returns>An instance of the template. Always the same instance for the same arguments.</returns>

    public virtual TypeNode/*!*/ GetTemplateInstance(TypeNode referringType, TypeNodeList templateArguments) {

      if (referringType == null) return this;

      Module module = referringType.DeclaringModule;

      return this.GetTemplateInstance(module, referringType, this.DeclaringType, templateArguments);

    }

    class CachingModuleForGenericsInstances : Module{

      public override TypeNode GetStructurallyEquivalentType(Identifier ns, Identifier/*!*/ id, Identifier uniqueMangledName, bool lookInReferencedAssemblies) {

        if (uniqueMangledName == null) return null;

        return (TypeNode)this.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey];

      }

    }

    protected static Module/*!*/ cachingModuleForGenericInstances = new CachingModuleForGenericsInstances();

    public virtual TypeNode/*!*/ GetTemplateInstance(Module module, TypeNode referringType, TypeNode declaringType, TypeNodeList templateArguments) {

      TypeNodeList templateParameters = this.TemplateParameters;

      if (module == null || templateArguments == null || (declaringType == null && (templateParameters == null || templateParameters.Count == 0)))

        return this;

      if (this.IsGeneric){

        referringType = null;

        module = TypeNode.cachingModuleForGenericInstances;

      }

      bool notFullySpecialized;

      Identifier/*!*/ uniqueMangledName;

      Identifier mangledName = this.GetMangledTemplateInstanceName(templateArguments, out uniqueMangledName, out notFullySpecialized);

      TypeNode result;

      Identifier dummyId;

      this.TryToFindExistingInstance(module, declaringType, templateArguments, mangledName, uniqueMangledName, out result, out dummyId);

      if (result != null) return result;

      if (this.NewTemplateInstanceIsRecursive) return this; //An instance of this template is trying to instantiate the template again

      lock (Module.GlobalLock){

        Identifier unusedMangledName;

        this.TryToFindExistingInstance(module, declaringType, templateArguments, mangledName, uniqueMangledName, out result, out unusedMangledName);

        if (result != null) return result;

        //^ assume unusedMangledName != null;

        TypeNodeList consolidatedTemplateArguments = 

          declaringType == null ? templateArguments : declaringType.GetConsolidatedTemplateArguments(templateArguments);

        Duplicator duplicator = new Duplicator(module, referringType);

        duplicator.RecordOriginalAsTemplate = true;

        duplicator.SkipBodies = true;

        duplicator.TypesToBeDuplicated[this.UniqueKey] = this;

        result = duplicator.VisitTypeNode(this, unusedMangledName, consolidatedTemplateArguments, this.Template == null ? this : this.Template, true);

        //^ assume result != null;

        if (module == this.DeclaringModule){

          if (this.TemplateInstances == null) this.TemplateInstances = new TypeNodeList();

          this.TemplateInstances.Add(result);

        }

        result.Name = unusedMangledName;

        result.Name.SourceContext = this.Name.SourceContext;

        result.fullName = null;

        if (this.IsGeneric) result.DeclaringModule = this.DeclaringModule;

        result.DeclaringType = this.IsGeneric || referringType == null ? declaringType : referringType;

        result.Template = this;

        result.templateParameters = new TypeNodeList(0);

        result.consolidatedTemplateParameters = new TypeNodeList(0);

        result.templateArguments = templateArguments;

        result.consolidatedTemplateArguments = consolidatedTemplateArguments;

        result.IsNotFullySpecialized = notFullySpecialized || (declaringType != null && TypeIsNotFullySpecialized(declaringType));

        module.StructurallyEquivalentType[unusedMangledName.UniqueIdKey] = result;

        module.StructurallyEquivalentType[uniqueMangledName.UniqueIdKey] = result;

        Specializer specializer = new Specializer(module, this.ConsolidatedTemplateParameters, consolidatedTemplateArguments);

        specializer.VisitTypeNode(result);

        TypeFlags visibility = this.Flags & TypeFlags.VisibilityMask;

        for (int i = 0, m = templateArguments.Count; i < m; i++){

          TypeNode t = templateArguments[i];

          if (t == null) continue;

          if (TypeIsNotFullySpecialized(t)) continue;

          visibility = TypeNode.GetVisibilityIntersection(visibility, t.Flags & TypeFlags.VisibilityMask);

        }

        result.Flags &= ~TypeFlags.VisibilityMask;

        result.Flags |= visibility;

        if (this.IsGeneric) return result;

#if ExtendedRuntime

        //Arrange for template instance to be emitted to module and to be recognized as a template instance when imported from module.

        if (referringType == null){

          if (visibility == TypeFlags.NestedPublic) 

            visibility = TypeFlags.Public;

          else if (visibility != TypeFlags.Public)

            visibility = TypeFlags.NotPublic;

          module.Types.Add(result);

        }else{

          switch (visibility){

            case TypeFlags.NestedFamANDAssem:

            case TypeFlags.NestedFamily:

            case TypeFlags.NestedPrivate:

              if (result != referringType && this != referringType)

                referringType.Members.Add(result);

              else{

                if (declaringType == null)

                  visibility = TypeFlags.NotPublic;

                goto default;

              }

              break;

            case TypeFlags.NestedAssembly:

              if (declaringType == null)

                visibility = TypeFlags.NotPublic;

              goto default;

            case TypeFlags.NestedPublic:

              if (declaringType == null)

                visibility = TypeFlags.Public;

              goto default;

            default:

              if (declaringType == null){

                result.DeclaringType = null;

                module.Types.Add(result);

              }else{

                result.DeclaringType = declaringType;

                declaringType.Members.Add(result);

              }

              break;

          }

        }

        result.Flags &= ~TypeFlags.VisibilityMask;

        result.Flags |= visibility;

        AttributeList attrs = result.Attributes;

        if (attrs == null) attrs = result.Attributes = new AttributeList(1);

        TypeNode typeArray = CoreSystemTypes.Type.GetArrayType(1);

        if (TypeNode.templateInstanceAttribute == null) {

          InstanceInitializer constr = SystemTypes.TemplateInstanceAttribute.GetConstructor(CoreSystemTypes.Type, typeArray);

          if (constr == null) { Debug.Fail(""); return result; }

          TypeNode.templateInstanceAttribute = new MemberBinding(null, constr);

        }

        int n = templateArguments.Count;

        TypeNode[] tArgs = new TypeNode[n];

        for (int i = 0; i < n; i++) tArgs[i] = templateArguments[i];

        AttributeNode attr = new AttributeNode(TypeNode.templateInstanceAttribute, 

          new ExpressionList(new Literal(this, CoreSystemTypes.Type), new Literal(tArgs, typeArray)));

        attr.Target = AttributeTargets.Delegate|AttributeTargets.Class|AttributeTargets.Enum|AttributeTargets.Interface|AttributeTargets.Struct;

        if (attrs.Count > 0 && attrs[0] == null)

          attrs[0] = attr;

        else

          attrs.Add(attr);

#endif

        return result;

      }

    }

    protected virtual TypeNodeList GetConsolidatedTemplateArguments(){

      TypeNodeList typeArgs = this.TemplateArguments;

      if (this.DeclaringType == null) return typeArgs;

      TypeNodeList result = this.DeclaringType.ConsolidatedTemplateArguments;

      if (result == null){

        if (this.DeclaringType.IsGeneric && this.DeclaringType.Template == null)

          result = this.DeclaringType.ConsolidatedTemplateParameters;

        if (result == null)

          return typeArgs;

      }

      int n = typeArgs == null ? 0 : typeArgs.Count;

      if (n == 0) return result;

      result = result.Clone();

      for (int i = 0; i < n; i++) result.Add(typeArgs[i]);

      return result;

    }

    protected virtual TypeNodeList GetConsolidatedTemplateArguments(TypeNodeList typeArgs){

      TypeNodeList result = this.ConsolidatedTemplateArguments;

      if (result == null || result.Count == 0){

        if (this.IsGeneric && this.Template == null)

          result = this.ConsolidatedTemplateParameters;

        else

          return typeArgs;

      }

      int n = typeArgs == null ? 0 : typeArgs.Count;

      if (n == 0) return result;

      //^ assert typeArgs != null;

      result = result.Clone();

      for (int i = 0; i < n; i++) result.Add(typeArgs[i]);

      return result;

    }

    protected virtual TypeNodeList GetConsolidatedTemplateParameters(){

      TypeNodeList typeParams = this.TemplateParameters;

      TypeNode declaringType = this.DeclaringType;

      if (declaringType == null) return typeParams;

      while (declaringType.Template != null) declaringType = declaringType.Template;

      TypeNodeList result = declaringType.ConsolidatedTemplateParameters;

      if (result == null) return typeParams;

      int n = typeParams == null ? 0 : typeParams.Count;

      if (n == 0) return result;

      result = result.Clone();

      for (int i = 0; i < n; i++) result.Add(typeParams[i]);

      return result;

    }

    protected virtual TypeNodeList GetOwnTemplateArguments(TypeNodeList consolidatedTemplateArguments){

      int n = this.TemplateParameters == null ? 0 : this.TemplateParameters.Count;

      int m = consolidatedTemplateArguments == null ? 0 : consolidatedTemplateArguments.Count;

      int k = m-n;

      if (k <= 0) return consolidatedTemplateArguments;

      TypeNodeList result = new TypeNodeList(n);

      if (consolidatedTemplateArguments != null)

        for (int i = 0; i < n; i++)

          result.Add(consolidatedTemplateArguments[i+k]);

      return result;

  }

#if ExtendedRuntime

    private static MemberBinding templateInstanceAttribute = null;

#endif

  protected internal Pointer pointerType;

    public virtual Pointer/*!*/ GetPointerType() {

      Pointer result = this.pointerType;

      if (result == null){

        lock(this){

          if (this.pointerType != null) return this.pointerType;

          result = this.pointerType = new Pointer(this);

          result.Flags &= ~TypeFlags.VisibilityMask;

          result.Flags |= this.Flags & TypeFlags.VisibilityMask;

          result.DeclaringModule = this.DeclaringModule;

        }

      }

      return result;

    }

    protected internal Reference referenceType;

    public virtual Reference/*!*/ GetReferenceType(){

      Reference result = this.referenceType;

      if (result == null){

        lock(this){

          if (this.referenceType != null) return this.referenceType;

          result = this.referenceType = new Reference(this);

          result.Flags &= ~TypeFlags.VisibilityMask;

          result.Flags |= this.Flags & TypeFlags.VisibilityMask;

          result.DeclaringModule = this.DeclaringModule;

        }

      }

      return result;

    }

    //^ [Microsoft.Contracts.SpecPublic]

    protected internal TrivialHashtable memberTable;

    protected internal int memberCount;

    /// <summary>

    /// Returns a list of all the members declared directly by this type with the specified name.

    /// Returns an empty list if this type has no such members.

    /// </summary>

    public virtual MemberList/*!*/ GetMembersNamed(Identifier name) {

      if (name == null) return new MemberList(0);

      MemberList members = this.Members;

      int n = members == null ? 0 : members.Count;

      if (n != this.memberCount || this.memberTable == null) this.UpdateMemberTable(n);

      //^ assert this.memberTable != null;

      MemberList result = (MemberList)this.memberTable[name.UniqueIdKey];

      if (result == null){

        lock(this){

          result = (MemberList)this.memberTable[name.UniqueIdKey];

          if (result != null) return result;

          this.memberTable[name.UniqueIdKey] = (result = new MemberList());

        }

      }

      return result;

    }

    /// <summary>

    /// Returns the first event declared by this type with the specified name.

    /// Returns null if this type has no such event.

    /// </summary>

    public virtual Event GetEvent(Identifier name){

      MemberList members = this.GetMembersNamed(name);

      for (int i = 0, n = members.Count; i < n; i++){

        Event ev = members[i] as Event;

        if (ev != null) return ev;

      }

      return null;

    }

    /// <summary>

    /// Returns the first field declared by this type with the specified name. Returns null if this type has no such field.

    /// </summary>

    public virtual Field GetField(Identifier name){

      MemberList members = this.GetMembersNamed(name);

      for (int i = 0, n = members.Count; i < n; i++){

        Field field = members[i] as Field;

        if (field != null) return field;

      }

      return null;

    }

    /// <summary>

    /// Returns the first method declared by this type with the specified name and parameter types. Returns null if this type has no such method.

    /// </summary>

    /// <returns></returns>

    public virtual Method GetMethod(Identifier name, params TypeNode[] types){

      return GetFirstMethod(this.GetMembersNamed(name), types);

    }

    private static Method GetFirstMethod(MemberList members, params TypeNode[] types){

      if (members == null) return null;

      int m = types == null ? 0 : types.Length;

      TypeNodeList typeNodes = m == 0 ? null : new TypeNodeList(types);

      for (int i = 0, n = members.Count; i < n; i++){

        Method meth = members[i] as Method;

        if (meth == null) continue;

        if (meth.ParameterTypesMatchStructurally(typeNodes)) return meth;

      }

      return null;

    }

    public virtual MethodList GetMethods(Identifier name, params TypeNode[] types) {

      return GetMethods(this.GetMembersNamed(name), types);

    }

    private static MethodList GetMethods(MemberList members, params TypeNode[] types) {

      if (members == null) return null;

      int m = types == null ? 0 : types.Length;

      MethodList result = new MethodList();

      TypeNodeList typeNodes = m == 0 ? null : new TypeNodeList(types);

      for (int i = 0, n = members.Count; i < n; i++) {

        Method meth = members[i] as Method;

        if (meth == null) continue;

        if (meth.ParameterTypesMatchStructurally(typeNodes)) result.Add(meth);

      }

      return result;

    }

    public Method GetMatchingMethod(Method method) {

      if (method == null || method.Name == null) return null;

      MemberList members = this.GetMembersNamed(method.Name);

      for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){

        Method m = members[i] as Method;

        if (m == null) continue;

        if (m.ParametersMatchStructurally(method.Parameters)) return m;

      }

      return null;

    }

    /// <summary>

    /// Returns the first nested type declared by this type with the specified name. Returns null if this type has no such nested type.

    /// </summary>

    public virtual TypeNode GetNestedType(Identifier name){

      if (name == null) return null;

      if (this.members != null){

        MemberList members = this.GetMembersNamed(name);

        for (int i = 0, n = members.Count; i < n; i++){

          TypeNode type = members[i] as TypeNode;

          if (type != null) return type;

        }

        return null;

      }

      TypeNodeList nestedTypes = this.NestedTypes;

      for (int i = 0, n = nestedTypes == null ? 0 : nestedTypes.Count; i < n; i++) {

        TypeNode type = nestedTypes[i];

        if (type != null && type.Name.UniqueIdKey == name.UniqueIdKey) return type;

      }

      return null;

    }

    protected internal TypeNodeList nestedTypes;

    public virtual TypeNodeList NestedTypes{

      get{

        if (this.nestedTypes != null && (this.members == null || this.members.Count == this.memberCount))

          return this.nestedTypes;

        if (this.ProvideNestedTypes != null && this.ProviderHandle != null){

          lock (Module.GlobalLock){

            this.ProvideNestedTypes(this, this.ProviderHandle);

          }

        }else{

          MemberList members = this.Members;

          TypeNodeList nestedTypes = new TypeNodeList();

          for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){

            TypeNode nt = members[i] as TypeNode;

            if (nt == null) continue;

            nestedTypes.Add(nt);

          }

          this.nestedTypes = nestedTypes;

        }

        return this.nestedTypes;

      }

      set{

        this.nestedTypes = value;

      }

    }

    /// <summary>

    /// Returns the first property declared by this type with the specified name and parameter types. Returns null if this type has no such property.

    /// </summary>

    public virtual Property GetProperty(Identifier name, params TypeNode[] types){

      return GetProperty(this.GetMembersNamed(name), types);

    }

    private static Property GetProperty(MemberList members, params TypeNode[] types){

      if (members == null) return null;

      int m = types == null ? 0 : types.Length;

      TypeNodeList typeNodes = m == 0 ? null : new TypeNodeList(types);

      for (int i = 0, n = members.Count; i < n; i++){

        Property prop = members[i] as Property;

        if (prop == null) continue;

        if (prop.ParameterTypesMatch(typeNodes)) return prop;

      }

      return null;

    }

#if !MinimalReader

    protected internal MemberList explicitCoercionMethods;

    public virtual MemberList ExplicitCoercionMethods{

      get{

        if (this.Members.Count != this.memberCount) this.explicitCoercionMethods = null;

        if (this.explicitCoercionMethods != null) return this.explicitCoercionMethods;

        lock(this){

          if (this.explicitCoercionMethods != null) return this.explicitCoercionMethods;

          return this.explicitCoercionMethods = TypeNode.WeedOutNonSpecialMethods(this.GetMembersNamed(StandardIds.opExplicit), MethodFlags.SpecialName);

        }

      }

    }

    protected internal MemberList implicitCoercionMethods;

    public virtual MemberList ImplicitCoercionMethods{

      get{

        if (this.Members.Count != this.memberCount) this.implicitCoercionMethods = null;

        if (this.implicitCoercionMethods != null) return this.implicitCoercionMethods;

        lock(this){

          if (this.implicitCoercionMethods != null) return this.implicitCoercionMethods;

          return this.implicitCoercionMethods = TypeNode.WeedOutNonSpecialMethods(this.GetMembersNamed(StandardIds.opImplicit), MethodFlags.SpecialName);

        }

      }

    }

    protected readonly static Method MethodDoesNotExist = new Method();

    protected internal TrivialHashtable explicitCoercionFromTable;

    public virtual Method GetExplicitCoercionFromMethod(TypeNode sourceType){

      if (sourceType == null) return null;

      Method result = null;

      if (this.explicitCoercionFromTable != null)

        result = (Method)this.explicitCoercionFromTable[sourceType.UniqueKey];

      if (result == TypeNode.MethodDoesNotExist) return null; 

      if (result != null) return result;

      lock(this){

        if (this.explicitCoercionFromTable != null)

          result = (Method)this.explicitCoercionFromTable[sourceType.UniqueKey];

        if (result == TypeNode.MethodDoesNotExist) return null; 

        if (result != null) return result;

        MemberList coercions = this.ExplicitCoercionMethods;

        for (int i = 0, n = coercions.Count; i < n; i++){

          Method m = (Method)coercions[i];

          if (sourceType == m.Parameters[0].Type){result = m; break;}

        }

        if (this.explicitCoercionFromTable == null)

          this.explicitCoercionFromTable = new TrivialHashtable();

        if (result == null)

          this.explicitCoercionFromTable[sourceType.UniqueKey] = TypeNode.MethodDoesNotExist;

        else

          this.explicitCoercionFromTable[sourceType.UniqueKey] = result;

        return result;

      }

    }

    protected internal TrivialHashtable explicitCoercionToTable;

    public virtual Method GetExplicitCoercionToMethod(TypeNode targetType){

      if (targetType == null) return null;

      Method result = null;

      if (this.explicitCoercionToTable != null)

        result = (Method)this.explicitCoercionToTable[targetType.UniqueKey];

      if (result == TypeNode.MethodDoesNotExist) return null; 

      if (result != null) return result;

      lock(this){

        if (this.explicitCoercionToTable != null)

          result = (Method)this.explicitCoercionToTable[targetType.UniqueKey];

        if (result == TypeNode.MethodDoesNotExist) return null; 

        if (result != null) return result;

        MemberList coercions = this.ExplicitCoercionMethods;

        for (int i = 0, n = coercions.Count; i < n; i++){

          Method m = (Method)coercions[i];

          if (m.ReturnType == targetType){result = m; break;}

        }

        if (this.explicitCoercionToTable == null)

          this.explicitCoercionToTable = new TrivialHashtable();

        if (result == null)

          this.explicitCoercionToTable[targetType.UniqueKey] = TypeNode.MethodDoesNotExist;

        else

          this.explicitCoercionToTable[targetType.UniqueKey] = result;

      }

      return result;

    }

    protected internal TrivialHashtable implicitCoercionFromTable;

    public virtual Method GetImplicitCoercionFromMethod(TypeNode sourceType){

      if (sourceType == null) return null;

      Method result = null;

      if (this.implicitCoercionFromTable != null)

        result = (Method)this.implicitCoercionFromTable[sourceType.UniqueKey];

      if (result == TypeNode.MethodDoesNotExist) return null; 

      if (result != null) return result;

      lock(this){

        if (this.implicitCoercionFromTable != null)

          result = (Method)this.implicitCoercionFromTable[sourceType.UniqueKey];

        if (result == TypeNode.MethodDoesNotExist) return null; 

        if (result != null) return result;

        MemberList coercions = this.ImplicitCoercionMethods;

        for (int i = 0, n = coercions.Count; i < n; i++){

          Method m = (Method)coercions[i];

          if (sourceType.IsStructurallyEquivalentTo(TypeNode.StripModifiers(m.Parameters[0].Type))){result = m; break;}

        }

        if (this.implicitCoercionFromTable == null)

          this.implicitCoercionFromTable = new TrivialHashtable();

        if (result == null)

          this.implicitCoercionFromTable[sourceType.UniqueKey] = TypeNode.MethodDoesNotExist;

        else

          this.implicitCoercionFromTable[sourceType.UniqueKey] = result;

        return result;

      }

    }

    protected internal TrivialHashtable implicitCoercionToTable;

    public virtual Method GetImplicitCoercionToMethod(TypeNode targetType){

      if (targetType == null) return null;

      Method result = null;

      if (this.implicitCoercionToTable != null)

        result = (Method)this.implicitCoercionToTable[targetType.UniqueKey];

      if (result == TypeNode.MethodDoesNotExist) return null; 

      if (result != null) return result;

      lock(this){

        if (this.implicitCoercionToTable != null)

          result = (Method)this.implicitCoercionToTable[targetType.UniqueKey];

        if (result == TypeNode.MethodDoesNotExist) return null; 

        if (result != null) return result;

        MemberList coercions = this.ImplicitCoercionMethods;

        for (int i = 0, n = coercions.Count; i < n; i++){

          Method m = (Method)coercions[i];

          if (m.ReturnType == targetType){result = m; break;}

        }

        if (this.implicitCoercionToTable == null)

          this.implicitCoercionToTable = new TrivialHashtable();

        if (result == null)

          this.implicitCoercionToTable[targetType.UniqueKey] = TypeNode.MethodDoesNotExist;

        else

          this.implicitCoercionToTable[targetType.UniqueKey] = result;

        return result;

      }

    }

    protected Method opFalse;

    public virtual Method GetOpFalse(){

      Method result = this.opFalse;

      if (result == TypeNode.MethodDoesNotExist) return null;

      if (result != null) return result;

      MemberList members = this.Members; //evaluate for side effect

      if (members != null) members = null;

      lock(this){

        result = this.opFalse;

        if (result == TypeNode.MethodDoesNotExist) return null;

        if (result != null) return result;

        TypeNode t = this;

        while (t != null){

          MemberList opFalses = t.GetMembersNamed(StandardIds.opFalse);

          if (opFalses != null)

            for (int i = 0, n = opFalses.Count; i < n; i++){

              Method opFalse = opFalses[i] as Method;

              if (opFalse == null) continue;

              if (!opFalse.IsSpecialName || !opFalse.IsStatic || !opFalse.IsPublic || opFalse.ReturnType != CoreSystemTypes.Boolean ||

                opFalse.Parameters == null || opFalse.Parameters.Count != 1) continue;

              return this.opFalse = opFalse;

            }

          t = t.BaseType;

        }

        this.opFalse = TypeNode.MethodDoesNotExist;

        return null;

      }

    }

    protected Method opTrue;

    public virtual Method GetOpTrue(){

      Method result = this.opTrue;

      if (result == TypeNode.MethodDoesNotExist) return null;

      if (result != null) return result;

      MemberList members = this.Members; //evaluate for side effect

      if (members != null) members = null;

      lock(this){

        result = this.opTrue;

        if (result == TypeNode.MethodDoesNotExist) return null;

        if (result != null) return result;

        TypeNode t = this;

        while (t != null){

          MemberList opTrues = t.GetMembersNamed(StandardIds.opTrue);

          if (opTrues != null)

            for (int i = 0, n = opTrues.Count; i < n; i++){

              Method opTrue = opTrues[i] as Method;

              if (opTrue == null) continue;

              if (!opTrue.IsSpecialName || !opTrue.IsStatic || !opTrue.IsPublic || opTrue.ReturnType != CoreSystemTypes.Boolean ||

                opTrue.Parameters == null || opTrue.Parameters.Count != 1) continue;

              return this.opTrue = opTrue;

            }

          t = t.BaseType;

        }

        this.opTrue = TypeNode.MethodDoesNotExist;

        return null;

      }

    }

#endif

#if !NoReflection

    private static Hashtable typeMap; //contains weak references

    /// <summary>

    /// Gets a TypeNode instance corresponding to the given System.Type instance.

    /// </summary>

    /// <param name="type">A runtime type.</param>

    /// <returns>A TypeNode instance.</returns>

    public static TypeNode GetTypeNode(System.Type type){

      if (type == null) return null;

      Hashtable typeMap = TypeNode.typeMap;

      if (typeMap == null) TypeNode.typeMap = typeMap = Hashtable.Synchronized(new Hashtable());

      TypeNode result = null;

      WeakReference wr = (WeakReference)typeMap[type];

      if (wr != null){

        result = wr.Target as TypeNode;

        if (result == Class.DoesNotExist) return null;

        if (result != null) return result;

      }

#if WHIDBEY

      if (type.IsGenericType && !type.IsGenericTypeDefinition){

        try{

          TypeNode template = TypeNode.GetTypeNode(type.GetGenericTypeDefinition());

          if (template == null) return null;

          TypeNodeList templateArguments = new TypeNodeList();

          foreach (Type arg in type.GetGenericArguments())

            templateArguments.Add(TypeNode.GetTypeNode(arg));

          return template.GetGenericTemplateInstance(template.DeclaringModule, templateArguments);

        }catch{

          //TODO: log error

          return null;

        }

      }

      if (type.IsGenericParameter){

        try{

          int parIndx = type.GenericParameterPosition;

          System.Reflection.MethodInfo mi = type.DeclaringMethod as System.Reflection.MethodInfo;

          if (mi != null){

            Method m = Method.GetMethod(mi);

            if (m == null) return null;

            if (m.TemplateParameters != null && m.TemplateParameters.Count > parIndx)

              return m.TemplateParameters[parIndx];

          }else{

            System.Type ti = type.DeclaringType;

            TypeNode t = TypeNode.GetTypeNode(ti);

            if (t == null) return null;

            if (t.TemplateParameters != null && t.TemplateParameters.Count > parIndx)

              return t.TemplateParameters[parIndx];

          }

          return null;

        }catch{

          //TODO: log error

          return null;

        }

      }

#endif

      if (type.HasElementType){

        TypeNode elemType = TypeNode.GetTypeNode(type.GetElementType());

        if (elemType == null) return null;

        if (type.IsArray)

          result = elemType.GetArrayType(type.GetArrayRank());

        else if (type.IsByRef)

          result = elemType.GetReferenceType();

        else if (type.IsPointer)

          result = elemType.GetPointerType();

        else{

          Debug.Assert(false);

          result = null;

        }

      }else if (type.DeclaringType != null){

        TypeNode dType = TypeNode.GetTypeNode(type.DeclaringType);

        if (dType == null) return null;

        result = dType.GetNestedType(Identifier.For(type.Name));

      }else{

        AssemblyNode assem = AssemblyNode.GetAssembly(type.Assembly);

        if (assem != null){

            result = assem.GetType(Identifier.For(type.Namespace), Identifier.For(type.Name));

        }

      }

      if (result == null)

        typeMap[type] = new WeakReference(Class.DoesNotExist);

      else

        typeMap[type] = new WeakReference(result);

      return result;

    }

    protected internal Type runtimeType;

    /// <summary>

    /// Gets a System.Type instance corresponding to this type. The assembly containin this type must be normalized

    /// and must have a location on disk or must have been loaded via AssemblyNode.GetRuntimeAssembly.

    /// </summary>

    /// <returns>A System.Type instance. (A runtime type.)</returns>

    public virtual Type GetRuntimeType(){

      if (this.runtimeType == null){

        lock(this){

          if (this.runtimeType != null) return this.runtimeType;

#if WHIDBEY

          if (this.IsGeneric && this.Template != null){

            try {

              TypeNode rootTemplate = this.Template;

              while (rootTemplate.Template != null)

                rootTemplate = rootTemplate.Template;

              Type genType = rootTemplate.GetRuntimeType();

              if (genType == null) return null;

              TypeNodeList args = this.ConsolidatedTemplateArguments;

              Type[] arguments = new Type[args.Count];

              for (int i = 0; i < args.Count; i++) arguments[i] = args[i].GetRuntimeType();

              return genType.MakeGenericType(arguments);

            }catch{

              //TODO: add error to metadata import errors if type is imported

              return null;

            }

          }

#endif

          if (this.DeclaringType != null){

            Type dt = this.DeclaringType.GetRuntimeType();

            if (dt != null){

              System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.DeclaredOnly;

              if (this.IsPublic) flags |= System.Reflection.BindingFlags.Public; else flags |= System.Reflection.BindingFlags.NonPublic;

              this.runtimeType = dt.GetNestedType(this.Name.ToString(), flags);

            }

          }else if (this.DeclaringModule != null && this.DeclaringModule.IsNormalized && this.DeclaringModule.ContainingAssembly != null){        

            System.Reflection.Assembly runtimeAssembly = this.DeclaringModule.ContainingAssembly.GetRuntimeAssembly();

            if (runtimeAssembly != null)

              this.runtimeType = runtimeAssembly.GetType(this.FullName, false);

          }

        }

      }

      return this.runtimeType;

    }

#endif

    public static TypeFlags GetVisibilityIntersection(TypeFlags vis1, TypeFlags vis2){

      switch (vis2){

        case TypeFlags.Public:

        case TypeFlags.NestedPublic:

          return vis1;

        case TypeFlags.NotPublic:

        case TypeFlags.NestedAssembly:

        switch (vis1){

          case TypeFlags.Public:

            return vis2;

          case TypeFlags.NestedPublic:

          case TypeFlags.NestedFamORAssem:

            return TypeFlags.NestedAssembly;

          case TypeFlags.NestedFamily:

            return TypeFlags.NestedFamANDAssem;

          default:

            return vis1;

        }

        case TypeFlags.NestedFamANDAssem:

        switch (vis1){

          case TypeFlags.Public:

          case TypeFlags.NestedPublic:

          case TypeFlags.NestedFamORAssem:

          case TypeFlags.NestedFamily:

            return TypeFlags.NestedFamANDAssem;

          default:

            return vis1;

        }

        case TypeFlags.NestedFamORAssem:

        switch (vis1){

          case TypeFlags.Public:

          case TypeFlags.NestedPublic:

            return TypeFlags.NestedFamORAssem;

          default:

            return vis1;

        }

        case TypeFlags.NestedFamily:

        switch (vis1){

          case TypeFlags.Public:

          case TypeFlags.NestedPublic:

          case TypeFlags.NestedFamORAssem:

            return TypeFlags.NestedFamily;

          case TypeFlags.NestedAssembly:

            return TypeFlags.NestedFamANDAssem;

          default:

            return vis1;

        }

        default:

          return TypeFlags.NestedPrivate;

      }

    }

    private TrivialHashtable explicitInterfaceImplementations;

    public bool ImplementsExplicitly(Method method){

      if (method == null) return false;

      TrivialHashtable explicitInterfaceImplementations = this.explicitInterfaceImplementations;

      if (explicitInterfaceImplementations == null){

        MemberList members = this.Members;

        lock(this){

          if ((explicitInterfaceImplementations = this.explicitInterfaceImplementations) == null){

            explicitInterfaceImplementations = this.explicitInterfaceImplementations = new TrivialHashtable();

            for (int i = 0, n = members.Count; i < n; i++){

              Method m = members[i] as Method;

              if (m == null) continue;

              MethodList implementedInterfaceMethods = m.ImplementedInterfaceMethods;

              if (implementedInterfaceMethods != null)

                for (int j = 0, k = implementedInterfaceMethods.Count; j < k; j++){

                  Method im = implementedInterfaceMethods[j];

                  if (im == null) continue;

                  explicitInterfaceImplementations[im.UniqueKey] = m;

                }

            }

          }

        }

      }

      return explicitInterfaceImplementations[method.UniqueKey] != null;

    }



    public Method ExplicitImplementation(Method method)

    {

      if (ImplementsExplicitly(method)) return (Method)explicitInterfaceImplementations[method.UniqueKey];

      return null;

    }



#if !MinimalReader

    internal bool ImplementsMethod(Method meth, bool checkPublic){

      return this.GetImplementingMethod(meth, checkPublic) != null;

    }

    public Method GetImplementingMethod(Method meth, bool checkPublic){

      if (meth == null) return null;

      MemberList mems = this.GetMembersNamed(meth.Name);

      for (int j = 0, m = mems == null ? 0 : mems.Count; j < m; j++){

        Method locM = mems[j] as Method;

        if (locM == null || !locM.IsVirtual || (checkPublic && !locM.IsPublic)) continue;

        if ((locM.ReturnType != meth.ReturnType && !(locM.ReturnType != null && locM.ReturnType.IsStructurallyEquivalentTo(meth.ReturnType))) ||

          !locM.ParametersMatchStructurally(meth.Parameters)) continue;

        return locM;

      }

      if (checkPublic && this.BaseType != null) 

        return this.BaseType.GetImplementingMethod(meth, true);

      return null;

    }

#endif

    /// <summary>

    /// Returns true if the CLR CTS allows a value of this type may be assigned to a variable of the target type (possibly after boxing),

    /// either because the target type is the same or a base type, or because the target type is an interface implemented by this type or the implementor of this type,

    /// or because this type and the target type are zero based single dimensional arrays with assignment compatible reference element types

    /// </summary>

    public virtual bool IsAssignableTo(TypeNode targetType){

      if (this == CoreSystemTypes.Void) return false;

      if (targetType == this) return true;

      if (this == CoreSystemTypes.Object) return false;

      if (targetType == CoreSystemTypes.Object || this.IsStructurallyEquivalentTo(targetType) ||

        this.BaseType != null && (this.BaseType.IsAssignableTo(targetType))) 

        return true;

      if (this.BaseType != null && this.ConsolidatedTemplateParameters != null && this.BaseType.Template != null && this.BaseType.Template.IsAssignableTo(targetType))

        return true; //When seeing if one template is assignable to another, be sure to strip off template instances along the inheritance chain

      InterfaceList interfaces = this.Interfaces;

      if (interfaces == null) return false;

      for (int i = 0, n = interfaces.Count; i < n; i++){

        Interface iface = interfaces[i];

        if (iface == null) continue;

        if (iface.IsAssignableTo(targetType)) return true;

        if (iface.Template != null && this.ConsolidatedTemplateParameters != null && iface.Template.IsAssignableTo(targetType))

          return true; //When seeing if one template is assignable to another, be sure to strip off template instances along the inheritance chain

      }

      return false;

    }

    /// <summary>

    /// Returns true if this type is assignable to some instance of the given template.

    /// </summary>

    public virtual bool IsAssignableToInstanceOf(TypeNode targetTemplate){

      if (this == CoreSystemTypes.Void || targetTemplate == null) return false;

      if (targetTemplate.IsStructurallyEquivalentTo(this.Template == null ? this : this.Template) || 

        this.BaseType != null && (this.BaseType.IsAssignableToInstanceOf(targetTemplate) ||

        this.BaseType.Template != null && this.BaseType.Template.IsAssignableToInstanceOf(targetTemplate))) return true;

      InterfaceList interfaces = this.Interfaces;

      if (interfaces == null) return false;

      for (int i = 0, n = interfaces.Count; i < n; i++) {

        Interface iface = interfaces[i];

        if (iface == null) continue;

        if (iface.IsAssignableToInstanceOf(targetTemplate)) return true;

      }

      return false;

    }

    /// <summary>

    /// Returns true if this type is assignable to some instance of the given template.

    /// </summary>

    public virtual bool IsAssignableToInstanceOf(TypeNode targetTemplate, out TypeNodeList templateArguments){

      templateArguments = null;

      if (this == CoreSystemTypes.Void || targetTemplate == null) return false;

      if (targetTemplate == this.Template){

        templateArguments = this.TemplateArguments;

        return true;

      }

      if (this != CoreSystemTypes.Object && this.BaseType != null && this.BaseType.IsAssignableToInstanceOf(targetTemplate, out templateArguments)) return true;

      InterfaceList interfaces = this.Interfaces;

      if (interfaces == null) return false;

      for (int i = 0, n = interfaces.Count; i < n; i++) {

        Interface iface = interfaces[i];

        if (iface == null) continue;

        if (iface.IsAssignableToInstanceOf(targetTemplate, out templateArguments)) return true;

      }

      return false;

    }

    /// <summary>

    /// Returns true if otherType is the base class of this type or if the base class of this type is derived from otherType.

    /// </summary>

    public virtual bool IsDerivedFrom(TypeNode otherType){

      if (otherType == null) return false;

      TypeNode baseType = this.BaseType;

      while (baseType != null){

        if (baseType == otherType) return true;

        baseType = baseType.BaseType;

      }

      return false;

    }

#if !MinimalReader

    //  Not thread safe code...

    bool isCheckingInheritedFrom = false;

    public virtual bool IsInheritedFrom(TypeNode otherType) {

      if (otherType == null) return false;

      if (this == otherType) return true;

      bool result = false;

      if (this.isCheckingInheritedFrom)

        goto done;

      this.isCheckingInheritedFrom = true;

      if (this.Template != null) {

        result = this.Template.IsInheritedFrom(otherType);

        goto done;

      }

      if (otherType.Template != null) {

        otherType = otherType.Template;

      }

      TypeNode baseType = this.BaseType;

      if (baseType != null && baseType.IsInheritedFrom(otherType)) {

        result = true;

        goto done;

      }

      InterfaceList interfaces = this.Interfaces;

      if (interfaces == null) goto done;

      for (int i = 0, n = interfaces.Count; i < n; i++) {

        Interface iface = interfaces[i];

        if (iface == null) continue;

        if (iface.IsInheritedFrom(otherType)) {

          result = true;

          goto done;

        }

      }

    done:

      this.isCheckingInheritedFrom = false;

      return result;

    }

#endif

    public virtual bool IsStructurallyEquivalentTo(TypeNode type){

      if (null == (object)type) return false;

      if (this == type) return true;

      if (this.Template == (object)null || type.Template == (object)null) {

        if (((object)this) == (object)type.Template || ((object)this.Template) == (object)type) return true;

        Identifier thisName = this.Template == null ? this.Name : this.Template.Name;

        Identifier typeName = type.Template == null ? type.Name : type.Template.Name;

        if (thisName == null || typeName == null || thisName.UniqueIdKey != typeName.UniqueIdKey) return false;

        if (this.NodeType != type.NodeType) return false;

        if (this.DeclaringType == null || type.DeclaringType == null) return false;

      }

      if (this.TemplateArguments == null || type.TemplateArguments == null){

        if (this.DeclaringType != null && (this.TemplateArguments == null || this.TemplateArguments.Count == 0) &&

          (type.TemplateArguments == null || type.TemplateArguments.Count == 0))

          return this.DeclaringType.IsStructurallyEquivalentTo(type.DeclaringType);

        return false;

      }

      int n = this.TemplateArguments.Count; if (n != type.TemplateArguments.Count) return false;

      if (this.Template != type.Template && !this.Template.IsStructurallyEquivalentTo(type.Template)) return false;

      for (int i = 0; i < n; i++){

        TypeNode ta1 = this.TemplateArguments[i];

        TypeNode ta2 = type.TemplateArguments[i];

        if (null == (object)ta1 || null == (object)ta2) return false;

        if (ta1 == ta2) continue;

        if (!ta1.IsStructurallyEquivalentTo(ta2)) return false;

      }

      if (this.DeclaringType != null) 

        return this.DeclaringType.IsStructurallyEquivalentTo(type.DeclaringType);

      return true;

    }

    public virtual bool IsStructurallyEquivalentList(TypeNodeList list1, TypeNodeList list2){

      if (list1 == null) return list2 == null;

      if (list2 == null) return false;

      int n = list1.Count; if (list2.Count != n) return false;

      for (int i = 0; i < n; i++){

        TypeNode t1 = list1[i];

        TypeNode t2 = list2[i];

        if (null == (object)t1 || null == (object)t2) return false;

        if (t1 == t2) continue;

        if (!t1.IsStructurallyEquivalentTo(t2)) return false;

      }

      return true;

    }

    public static TypeNode StripModifiers(TypeNode type) 

      //^ ensures t != null ==> result != null;

    {

      for (TypeModifier tmod = type as TypeModifier; tmod != null; tmod = type as TypeModifier)

        type = tmod.ModifiedType;

      // Don't strip under pointers or refs. We only strip top-level modifiers.

      return type;

    }

#if !MinimalReader

    public static TypeNode DeepStripModifiers(TypeNode type)

      //^ ensures type != null ==> result != null;

    {

      // strip off any outer type modifiers

      for (TypeModifier tmod = type as TypeModifier; tmod != null; tmod = type as TypeModifier)

        type = tmod.ModifiedType;

      // For arrays and references, strip the inner type and then reconstruct the array or reference

      ArrayType ar = type as ArrayType;

      if (ar != null) {

        TypeNode t = TypeNode.DeepStripModifiers(ar.ElementType);

        return t.GetArrayType(1);

      }

      Reference rt = type as Reference;

      if (rt != null) {

        TypeNode t = TypeNode.DeepStripModifiers(rt.ElementType);

        return t.GetReferenceType();

      }

      return type;

    }

    /// <summary>

    /// Strip the given modifier from the type, modulo substructures that are instantiated with respect

    /// to the given template type. In other words, travers type and templateType in parallel, stripping common

    /// non-null modifiers, but stop when reaching a type variable in the template type.

    /// <param name="type">Type to be stripped</param>

    /// <param name="modifiers">Modifiers to strip off</param>

    /// <param name="templateType">Template bounding the stripping of type. Passing null for the templateType performs a full DeepStrip</param>

    /// </summary>

    public static TypeNode DeepStripModifiers(TypeNode type, TypeNode templateType, params TypeNode[] modifiers) {

      if (templateType == null) return DeepStripModifiers(type, modifiers);

      if (templateType is ITypeParameter) return type;

      // strip off inner modifiers then outer type modifier if it matches

      OptionalModifier optmod = type as OptionalModifier;

      if (optmod != null) {

        OptionalModifier optmodtemplate = (OptionalModifier)templateType; // must be in sync

        TypeNode t = TypeNode.DeepStripModifiers(optmod.ModifiedType, optmodtemplate.ModifiedType, modifiers);

        for (int i = 0; i < modifiers.Length; ++i) {

          if (optmod.Modifier == modifiers[i]) {

            // strip it

            return t;

          }

        }

        return OptionalModifier.For(optmod.Modifier, t);

      }

      RequiredModifier reqmod = type as RequiredModifier;

      if (reqmod != null) {

        RequiredModifier reqmodtemplate = (RequiredModifier)templateType; // must be in sync

        TypeNode t = TypeNode.DeepStripModifiers(reqmod.ModifiedType, reqmodtemplate.ModifiedType, modifiers);

        for (int i = 0; i < modifiers.Length; ++i) {

          if (reqmod.Modifier == modifiers[i]) {

            // strip it

            return t;

          }

        }

        return RequiredModifier.For(reqmod.Modifier, t);

      }

      // For arrays and references, strip the inner type and then reconstruct the array or reference

      ArrayType ar = type as ArrayType;

      if (ar != null) {

        ArrayType artemplate = (ArrayType)templateType;

        TypeNode t = TypeNode.DeepStripModifiers(ar.ElementType, artemplate.ElementType, modifiers);

        return t.GetArrayType(1);

      }

      Reference rt = type as Reference;

      if (rt != null) {

        Reference rttemplate = (Reference)templateType;

        TypeNode t = TypeNode.DeepStripModifiers(rt.ElementType, rttemplate.ElementType, modifiers);

        return t.GetReferenceType();

      }

      // strip template arguments

      if (type.Template != null && type.TemplateArguments != null && type.TemplateArguments.Count > 0) {

        TypeNodeList strippedArgs = new TypeNodeList(type.TemplateArguments.Count);

        for (int i = 0; i < type.TemplateArguments.Count; i++) {

          //FIX: bug introduced by checkin 16494 

          //templateType may have type parameters in either the TemplateArguments position or the templateParameters position.

          //This may indicate an inconsistency in the template instantiation representation elsewhere.

          TypeNodeList templateTypeArgs = templateType.TemplateArguments != null ? templateType.TemplateArguments : templateType.TemplateParameters;

          strippedArgs.Add(DeepStripModifiers(type.TemplateArguments[i], templateTypeArgs[i], modifiers));

        }

        return type.Template.GetTemplateInstance(type, strippedArgs);

      }

      return type;

    }



    public static TypeNode DeepStripModifiers(TypeNode type, params TypeNode[] modifiers) {

      // strip off inner modifiers then outer type modifier if it matches

      OptionalModifier optmod = type as OptionalModifier;

      if (optmod != null) {

        TypeNode t = TypeNode.DeepStripModifiers(optmod.ModifiedType, modifiers);

        for (int i = 0; i < modifiers.Length; ++i) {

          if (optmod.Modifier == modifiers[i]) {

            // strip it

            return t;

          }

        }

        return OptionalModifier.For(optmod.Modifier, t);

      }

      RequiredModifier reqmod = type as RequiredModifier;

      if (reqmod != null) {

        TypeNode t = TypeNode.DeepStripModifiers(reqmod.ModifiedType, modifiers);

        for (int i = 0; i < modifiers.Length; ++i) {

          if (reqmod.Modifier == modifiers[i]) {

            // strip it

            return t;

          }

        }

        return RequiredModifier.For(reqmod.Modifier, t);

      }

      // For arrays and references, strip the inner type and then reconstruct the array or reference

      ArrayType ar = type as ArrayType;

      if (ar != null) {

        TypeNode t = TypeNode.DeepStripModifiers(ar.ElementType, modifiers);

        return t.GetArrayType(1);

      }

      Reference rt = type as Reference;

      if (rt != null) {

        TypeNode t = TypeNode.DeepStripModifiers(rt.ElementType, modifiers);

        return t.GetReferenceType();

      }

      // strip template arguments

      if (type.Template != null && type.TemplateArguments != null && type.TemplateArguments.Count > 0) {

        TypeNodeList strippedArgs = new TypeNodeList(type.TemplateArguments.Count);

        for (int i = 0; i < type.TemplateArguments.Count; i++) {

          strippedArgs.Add(DeepStripModifiers(type.TemplateArguments[i], modifiers));

        }

        return type.Template.GetTemplateInstance(type, strippedArgs);

      }

      return type;

    }

#endif

    public static bool HasModifier(TypeNode type, TypeNode modifier) {

      // Don't look under pointers or refs.

      TypeModifier tmod = type as TypeModifier;

      if (tmod != null) {

        if (tmod.Modifier == modifier) return true;

        return TypeNode.HasModifier(tmod.ModifiedType, modifier);

      }

      return false;

    }

    public static TypeNode StripModifier(TypeNode type, TypeNode modifier) {

      // Don't strip under pointers or refs. We only strip top-level modifiers

      TypeModifier tmod = type as TypeModifier;

      if (tmod != null){

        TypeNode et = TypeNode.StripModifier(tmod.ModifiedType, modifier);

        //^ assert et != null;

        if (tmod.Modifier == modifier) return et;

        if (et == tmod.ModifiedType) return tmod;

        if (tmod is OptionalModifier) return OptionalModifier.For(tmod.Modifier, et);

        return RequiredModifier.For(tmod.Modifier, et);

      }

      return type;

    }

    /// <summary>

    /// Needed whenever we change the id of an existing member

    /// </summary>

#if !MinimalReader

    public

#else

    internal

#endif

    virtual void ClearMemberTable() {

      lock(this) {

        this.memberTable = null;

        this.memberCount = 0;

      }

    }

    protected virtual void UpdateMemberTable(int range)

      //^ ensures this.memberTable != null;

    {

      MemberList thisMembers = this.Members;

      lock(this){

        if (this.memberTable == null) this.memberTable = new TrivialHashtable(32);

        for (int i = this.memberCount; i < range; i++){

          Member mem = thisMembers[i];

          if (mem == null || mem.Name == null) continue;

          MemberList members = (MemberList)this.memberTable[mem.Name.UniqueIdKey];

          if (members == null) this.memberTable[mem.Name.UniqueIdKey] = members = new MemberList();

          members.Add(mem);

        }

        this.memberCount = range;

        this.constructors = null;

      }

    }

    protected static MemberList WeedOutNonSpecialMethods(MemberList members, MethodFlags mask){

      if (members == null) return null;

      bool membersOK = true;

      for (int i = 0, n = members.Count; i < n; i++){

        Method m = members[i] as Method;

        if (m == null || (m.Flags & mask) == 0){

          membersOK = false; break;

        }

      }

      if (membersOK) return members;

      MemberList newMembers = new MemberList();

      for (int i = 0, n = members.Count; i < n; i++){

        Method m = members[i] as Method;

        if (m == null || (m.Flags & mask) == 0) continue;

        newMembers.Add(m);

      }

      return newMembers;

    }

#if !NoXml

    public override void WriteDocumentation(XmlTextWriter xwriter){

      base.WriteDocumentation(xwriter);

      MemberList members = this.Members;

      for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){

        Member mem = members[i];

        if (mem == null) continue;

        mem.WriteDocumentation(xwriter);

      }

    }

#endif

#if ExtendedRuntime

    public TypeNode StripOptionalModifiers(out bool nonNull){

      TypeNode t = this;

      nonNull = false;

      for(;;){

        OptionalModifier m = t as OptionalModifier;

        if (m == null)

          break;

        if (m.Modifier == SystemTypes.NonNullType)

          nonNull = true;

        t = m.ModifiedType;

      }

      return t;

    }

    public bool IsObjectReferenceType{

      get{

        bool nonNull;

        TypeNode t = this.StripOptionalModifiers(out nonNull);

        return t is Class || t is Interface || t is ArrayType || t is DelegateNode;

      }

    }

#endif

    public override string ToString() {

#if !FxCop

      return this.GetFullUnmangledNameWithTypeParameters();

#else

      return base.ToString() + ":" + this.GetFullUnmangledNameWithTypeParameters();

#endif

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      GetName(options.Type, name);

    }

    internal virtual void GetName(TypeFormat options, StringBuilder name)

    {

      if (options.TypeName != TypeNameFormat.None)

      {

        if (this.DeclaringType != null && options.TypeName != TypeNameFormat.InnermostNested)

        {

          this.DeclaringType.GetName(options, name);

          name.Append('+');

        }

        else if (options.TypeName == TypeNameFormat.FullyQualified && this.Namespace.Name.Length > 0)

        {

          name.Append(this.Namespace.Name);

          name.Append('.');

        }

        string shortName = this.Name.Name;

        int mangleChar = shortName.IndexOf(TargetPlatform.GenericTypeNamesMangleChar);

        if (mangleChar != -1)

          shortName = shortName.Substring(0, mangleChar);

        name.Append(shortName);

      }

      TypeNodeList templateParameters = this.TemplateParameters;

      if (this.Template != null) templateParameters = this.TemplateArguments;

      if (templateParameters != null)

      {

        if (options.ShowGenericTypeArity)

        {

          name.Append(TargetPlatform.GenericTypeNamesMangleChar);

          int parametersCount = templateParameters.Count;

          name.Append(Convert.ToString(parametersCount, CultureInfo.InvariantCulture));

        }

        if (options.ShowGenericTypeParameterNames)

        {

          name.Append('<');

          int parametersCount = templateParameters.Count;

          for (int i = 0; i < parametersCount; ++i)

          {

            if (i > 0)

            {

              name.Append(',');

              if (options.InsertSpacesBetweenTypeParameters) name.Append(' ');

            }

            templateParameters[i].GetName(options, name);

          }

          name.Append('>');

        }

      }

    }

#endif

  }

#if FxCop

  public class ClassNode : TypeNode{

#else

  public class Class : TypeNode{

#endif

    internal readonly static Class DoesNotExist = new Class();

    internal readonly static Class Dummy = new Class();

    internal Class baseClass;

#if !MinimalReader

    public Class BaseClassExpression;

    public bool IsAbstractSealedContainerForStatics;

#endif

#if FxCop

    public ClassNode()

      : base(NodeType.Class){

    }

    public ClassNode(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.Class, provideNestedTypes, provideAttributes, provideMembers, handle){

    }

#else

    public Class()

      : base(NodeType.Class){

    }

    public Class(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.Class, provideNestedTypes, provideAttributes, provideMembers, handle){

    }

#endif

#if !MinimalReader    

    public Class(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags flags,

      Identifier Namespace, Identifier name, Class baseClass, InterfaceList interfaces, MemberList members)

      : base(declaringModule, declaringType, attributes, flags, Namespace, name, interfaces, members, NodeType.Class){

      this.baseClass = baseClass;

    }

#endif

    /// <summary>

    /// The class from which this class has been derived. Null if this class is System.Object.

    /// </summary>

    public virtual Class BaseClass{

      get{

        return baseClass;

      }

      set{

        baseClass = value;

      }

    }

#if !MinimalReader

    public override void GetAbstractMethods(MethodList/*!*/ result) {

      if (!this.IsAbstract) return;

      MethodList candidates = new MethodList();

      if (this.BaseClass != null){

        this.BaseClass.GetAbstractMethods(candidates);

        for (int i = 0, n = candidates.Count; i < n; i++){

          Method meth = candidates[i];

          if (!this.ImplementsMethod(meth, false)) result.Add(meth);

        }

      }

      //Add any abstract methods declared inside this class

      MemberList members = this.Members;

      for (int i = 0, n = members.Count; i < n; i++){

        Method meth = members[i] as Method;

        if (meth == null) continue;

        if (meth.IsAbstract) result.Add(meth);

      }

      //For each interface, get abstract methods and keep those that are not implemented by this class or a base class

      InterfaceList interfaces = this.Interfaces;

      if (interfaces != null)

        for (int i = 0, n = interfaces.Count; i < n; i++){

          Interface iface = interfaces[i];

          if (iface == null) continue;

          MemberList imembers = iface.Members;

          if (imembers == null) continue;

          for (int j = 0, m = imembers.Count; j < m; j++){

            Method meth = imembers[j] as Method;

            if (meth == null) continue;

            if (this.ImplementsExplicitly(meth)) continue;

            if (this.ImplementsMethod(meth,true)) continue;

            if (this.AlreadyInList(result, meth)) continue;

            result.Add(meth);

          }

        }

    }

    protected bool AlreadyInList(MethodList list, Method method){

      if (list == null) return false;

      for (int i = 0, n = list.Count; i < n; i++){

        if (list[i] == method) return true;

      }

      return false;

  }

#endif

#if ExtendedRuntime

    public bool IsGuarded{

      get{

        Field f = this.GetField(Identifier.For("SpecSharp::frameGuard"));

        return f != null;

      }

    }

#endif

}

#if !MinimalReader

  public class ClosureClass : Class{

    public ClosureClass(){

    }    

  } 

  /// <summary>

  /// Does not model a real type, but leverages the symbol table methods of Class. In other words, this is implementation inheritance, not an ISA relationship.

  /// </summary>

  //TODO: use delegation rather than inheritance to achieve this

  public class Scope : Class{

    public Scope(){

    }

    public Scope(Scope outerScope){

      this.OuterScope = outerScope;

    }

    protected Scope outerScope;

    public SourceContext LexicalSourceExtent;

    public Scope OuterScope{

      get{

        if (this.outerScope == null)

          this.outerScope = (Scope)this.baseClass;

        return this.outerScope;

      }

      set{

        this.baseClass = this.outerScope = value;

      }

    }

    public virtual TypeNode GetType(Identifier typeName){

      return this.GetNestedType(typeName);

    }

  }

  public class TypeScope : Scope{

    public TypeNode Type;

    public TypeScope(){}

    public TypeScope(Scope parentScope, TypeNode/*!*/ type) {

      this.baseClass = parentScope;

      this.DeclaringModule = type.DeclaringModule;

      this.Type = type;

      if (type != null && type.PartiallyDefines != null) this.Type = type.PartiallyDefines;

      this.templateParameters = type.TemplateParameters;

      if (type != null)

        this.LexicalSourceExtent = type.SourceContext;

    }

    public override MemberList/*!*/ GetMembersNamed(Identifier name) {

      TypeNode t = this.Type;

      MemberList result = null;

      while (t != null){

        result = t.GetMembersNamed(name);

        if (result.Count > 0) return result;

        t = t.BaseType;

      }

      if (result != null) return result;

      return new MemberList(0);

    }

    public override MemberList Members{

      get{

        return this.Type.Members;

      }

      set{

        base.Members = value;

      }

    }

  }

  public class MethodScope : Scope{

    protected Class closureClass;

    public virtual Class ClosureClass{

      get{

        //if (this.DeclaringMethod == null) return null;

        Class c = this.closureClass;

        if (c == null){

          c = this.closureClass = new ClosureClass();

          c.Name = Identifier.For("closure:"+this.UniqueKey);

          c.BaseClass = CoreSystemTypes.Object;

          Class bclass = this.BaseClass;

          c.DeclaringModule = bclass.DeclaringModule;

          TypeScope tscope = bclass as TypeScope;

          if (tscope != null)

            c.DeclaringType = tscope.Type;

          else{

            MethodScope mscope = bclass as MethodScope;

            if (mscope != null)

              c.DeclaringType = mscope.ClosureClass;

            else

              c.DeclaringType = ((BlockScope)bclass).ClosureClass;

          }

          c.IsGeneric = c.DeclaringType.IsGeneric || this.DeclaringMethod.IsGeneric;

          c.TemplateParameters = this.CopyMethodTemplateParameters(c.DeclaringModule, c.DeclaringType);

          c.Flags = TypeFlags.NestedPrivate|TypeFlags.SpecialName|TypeFlags.Sealed;

          c.Interfaces = new InterfaceList(0);

          if (this.ThisType != null){

            Field f = new Field(c, null, FieldFlags.CompilerControlled | FieldFlags.SpecialName, StandardIds.ThisValue, this.ThisType, null);

            this.ThisField = f;

            c.Members.Add(f);

          }

        }

        return c;

      }

    }

    private TypeNodeList CopyMethodTemplateParameters(Module/*!*/ module, TypeNode/*!*/ type) 

      //^ requires this.DeclaringMethod != null;

    {

      TypeNodeList methTemplParams = this.DeclaringMethod.TemplateParameters;

      if (methTemplParams == null || methTemplParams.Count == 0) return null;

      this.tpDup = new TemplateParameterDuplicator(module, type);

      return this.tpDup.VisitTypeParameterList(methTemplParams);

    }

    private TemplateParameterDuplicator tpDup;

    private class TemplateParameterDuplicator : Duplicator{

      public TemplateParameterDuplicator(Module/*!*/ module, TypeNode/*!*/ type)

        : base(module, type){

      }



      public override TypeNode VisitTypeParameter(TypeNode typeParameter){

        if (typeParameter == null) return null;

        TypeNode result = (TypeNode)this.DuplicateFor[typeParameter.UniqueKey];

        if (result != null) return result;

        MethodTypeParameter mtp = typeParameter as MethodTypeParameter;

        if (mtp != null){

          TypeParameter tp = new TypeParameter();

          this.DuplicateFor[typeParameter.UniqueKey] = tp;

          tp.Name = mtp.Name;

          tp.Interfaces = this.VisitInterfaceReferenceList(mtp.Interfaces);

          tp.TypeParameterFlags = mtp.TypeParameterFlags;

          tp.DeclaringModule = mtp.DeclaringModule;

          tp.DeclaringMember = this.TargetType;

          result = tp;

        }else{

          MethodClassParameter mcp = typeParameter as MethodClassParameter;

          if (mcp != null){

            ClassParameter cp = new ClassParameter();

            this.DuplicateFor[typeParameter.UniqueKey] = cp;

            cp.Name = mcp.Name;

            cp.BaseClass = (Class)this.VisitTypeReference(mcp.BaseClass);

            cp.Interfaces = this.VisitInterfaceReferenceList(mcp.Interfaces);

            cp.TypeParameterFlags = mcp.TypeParameterFlags;

            cp.DeclaringModule = mcp.DeclaringModule;

            cp.DeclaringMember = this.TargetType;

            result = cp;

          }

        }

        if (result == null) return typeParameter;

        return result;

      }

      public override TypeNode VisitTypeReference(TypeNode type){

        TypeNode result = base.VisitTypeReference(type);

        if (result == type && (type is MethodClassParameter || type is MethodTypeParameter))

          return this.VisitTypeParameter(type);

        return result;

      }

    }

    public virtual Class ClosureClassTemplateInstance {

      get{

        if (this.closureClassTemplateInstance == null) {

          if (this.DeclaringMethod == null || !this.DeclaringMethod.IsGeneric)

            this.closureClassTemplateInstance = this.ClosureClass;

          else

            this.closureClassTemplateInstance = (Class)this.ClosureClass.GetTemplateInstance(this.DeclaringMethod.DeclaringType, this.DeclaringMethod.TemplateParameters);

        }

        return this.closureClassTemplateInstance;

      }

    }

    Class closureClassTemplateInstance;

    public TypeNode FixTypeReference(TypeNode type) {

      if (this.tpDup == null) return type;

      return this.tpDup.VisitTypeReference(type);

    }



    public virtual Boolean CapturedForClosure{

      get{

        return this.closureClass != null;

      }

    }

    public UsedNamespaceList UsedNamespaces;

    public Field ThisField;

    public TypeNode ThisType;

    public TypeNode ThisTypeInstance;

    public Method DeclaringMethod;

    public MethodScope(){}

    public MethodScope(Class/*!*/ parentScope, UsedNamespaceList usedNamespaces)

      : this(parentScope, usedNamespaces, null){

    }

    public MethodScope(Class/*!*/ parentScope, UsedNamespaceList usedNamespaces, Method method) {

      this.baseClass = parentScope;

      this.UsedNamespaces = usedNamespaces;

      this.DeclaringModule = parentScope.DeclaringModule;

      this.DeclaringMethod = method;

      if (method != null && (method.Flags & MethodFlags.Static) == 0)

        this.ThisType = this.ThisTypeInstance = method.DeclaringType;

      if (method != null)

        this.LexicalSourceExtent = method.SourceContext;

    }

  }

  public class BlockScope : Scope{

    public Block AssociatedBlock;

    public bool MembersArePinned;

    public virtual Class ClosureClass{

      get{

        BlockScope bscope = this.BaseClass as BlockScope;

        if (bscope != null) return bscope.ClosureClass;

        MethodScope mscope = this.BaseClass as MethodScope;

        if (mscope != null) return mscope.ClosureClass;

        return ((TypeScope)this.BaseClass).Type as Class;

      }

    }

    public virtual Boolean CapturedForClosure{

      get{

        BlockScope bscope = this.BaseClass as BlockScope;

        if (bscope != null) return bscope.CapturedForClosure;

        MethodScope mscope = this.BaseClass as MethodScope;

        if (mscope != null) return mscope.CapturedForClosure;

        return false;

      }

    }

    public BlockScope(){

    }

    public BlockScope(Scope/*!*/ parentScope, Block associatedBlock) {

      this.AssociatedBlock = associatedBlock;

      if (associatedBlock != null){

        associatedBlock.HasLocals = true; //TODO: set only if there really are locals

        associatedBlock.Scope = this;

      }

      this.baseClass = parentScope;

      this.DeclaringModule = parentScope.DeclaringModule;

      if (associatedBlock != null)

        this.LexicalSourceExtent = associatedBlock.SourceContext;

    }

  }

  public class AttributeScope : Scope{

    public AttributeNode AssociatedAttribute;

    public AttributeScope(Scope parentScope, AttributeNode associatedAttribute){

      this.AssociatedAttribute = associatedAttribute;

      this.baseClass = parentScope;

      if (associatedAttribute != null)

        this.LexicalSourceExtent = associatedAttribute.SourceContext;

    }

  }

  public class NamespaceScope : Scope{

    public Namespace AssociatedNamespace;

    public Module AssociatedModule;

    public TrivialHashtable AliasedType;

    public TrivialHashtable AliasedNamespace;

    protected TrivialHashtable/*!*/ aliasFor = new TrivialHashtable();

    protected TrivialHashtable/*!*/ typeFor = new TrivialHashtable();

    protected TrivialHashtable/*!*/ namespaceFor = new TrivialHashtable();

    protected TrivialHashtable/*!*/ nestedNamespaceFullName = new TrivialHashtable();

    protected readonly static AliasDefinition/*!*/ noSuchAlias = new AliasDefinition();



    public NamespaceScope(){

    }

    public NamespaceScope(Scope outerScope, Namespace associatedNamespace, Module associatedModule)

      : base(outerScope){

      //^ base;

      this.AssociatedNamespace = associatedNamespace;

      this.AssociatedModule = associatedModule;

      this.DeclaringModule = associatedModule; //TODO: make this go away

      if (associatedNamespace != null)

        this.LexicalSourceExtent = associatedNamespace.SourceContext;

    }

    public virtual AliasDefinition GetAliasFor(Identifier name){

      if (name == null || this.AssociatedNamespace == null || this.AssociatedModule == null || this.aliasFor == null){

        Debug.Assert(false); return null;

      }

      AliasDefinition alias = (AliasDefinition)this.aliasFor[name.UniqueIdKey];

      if (alias == noSuchAlias) return null;

      if (alias != null) return alias;

      //Check if there is an alias with this uri

      Scope scope = this;

      while (scope != null){

        NamespaceScope nsScope = scope as NamespaceScope;

        if (nsScope != null && nsScope.AssociatedNamespace != null){

          AliasDefinitionList aliases = nsScope.AssociatedNamespace.AliasDefinitions;

          if (aliases != null)

            for (int i = 0, n = aliases.Count; i < n; i++){

              AliasDefinition aliasDef = aliases[i];

              if (aliasDef == null || aliasDef.Alias == null) continue;

              if (aliasDef.Alias.UniqueIdKey == name.UniqueIdKey){alias = aliasDef; goto done;}

            }

        }

        scope = scope.OuterScope;

      }

      done:

        if (alias != null)

          this.aliasFor[name.UniqueIdKey] = alias;

        else

          this.aliasFor[name.UniqueIdKey] = noSuchAlias;

      return alias;

    }

    public virtual AliasDefinition GetConflictingAlias(Identifier name){

      if (name == null || this.typeFor == null || this.AssociatedNamespace == null || this.AssociatedModule == null){

        Debug.Assert(false); return null;

      }

      TypeNode type = this.AssociatedModule.GetType(this.AssociatedNamespace.FullNameId, name);

      if (type != null) {

        AliasDefinitionList aliases = this.AssociatedNamespace.AliasDefinitions;

        for (int i = 0, n = aliases == null ? 0 : aliases.Count; i < n; i++){

          //^ assert aliases != null;

          AliasDefinition aliasDef = aliases[i];

          if (aliasDef == null || aliasDef.Alias == null) continue;

          if (aliasDef.Alias.UniqueIdKey == name.UniqueIdKey) return aliasDef;

        }

      }

      Scope scope = this;

      while (scope != null) {

        NamespaceScope outerScope = scope.OuterScope as NamespaceScope;

        if (outerScope != null) return outerScope.GetConflictingAlias(name);

        scope = scope.OuterScope;

      }

      return null;

    }

    public virtual Identifier GetUriFor(Identifier name) {

      AliasDefinition aliasDef = this.GetAliasFor(name);

      if (aliasDef == null) return null;

      return aliasDef.AliasedUri;

    }

    public virtual Identifier GetNamespaceFullNameFor(Identifier name){

      if (name == null || this.AssociatedNamespace == null || this.AssociatedModule == null || this.nestedNamespaceFullName == null){

        Debug.Assert(false); return null;

      }

      Identifier fullName = (Identifier)this.nestedNamespaceFullName[name.UniqueIdKey];

      if (fullName == Identifier.Empty) return null;

      if (fullName != null) return fullName;

      //Check if there is an alias with this namespace

      AliasDefinition aliasDef = this.GetAliasFor(name);

      if (aliasDef != null && aliasDef.AliasedUri == null && aliasDef.AliasedType == null)

        return aliasDef.AliasedExpression as Identifier;

      //Check if module has a type with namespace equal to this namespace + name

      fullName = name;

      if (this.AssociatedNamespace.Name != null && this.AssociatedNamespace.Name.UniqueIdKey != Identifier.Empty.UniqueIdKey)

        fullName = Identifier.For(this.AssociatedNamespace.FullName+"."+name);

      if (this.AssociatedModule.IsValidNamespace(fullName)){

        this.namespaceFor[fullName.UniqueIdKey] = new TrivialHashtable();

        goto returnFullName;

      }

      // If an inner type shadows an outer namespace, don't return the namespace

      if (this.AssociatedModule.IsValidTypeName(this.AssociatedNamespace.Name, name)) { return null; }

      AssemblyReferenceList arefs = this.AssociatedModule.AssemblyReferences;

      for (int i = 0, n = arefs == null ? 0 : arefs.Count; i < n; i++){

        AssemblyReference ar = arefs[i];

        if (ar == null || ar.Assembly == null) continue;

        if (ar.Assembly.IsValidNamespace(fullName)) goto returnFullName;

        // If an inner type shadows an outer namespace, don't return the namespace

        if (ar.Assembly.IsValidTypeName(this.AssociatedNamespace.Name, name)) { return null; }

      }

      ModuleReferenceList mrefs = this.AssociatedModule.ModuleReferences;

      if (mrefs != null)

        for (int i = 0, n = mrefs.Count; i < n; i++){

          ModuleReference mr = mrefs[i];

          if (mr == null || mr.Module == null) continue;

          if (mr.Module.IsValidNamespace(fullName)) goto returnFullName;

          // If an inner type shadows an outer namespace, don't return the namespace

          if (mr.Module.IsValidTypeName(this.AssociatedNamespace.Name, name)) { return null; }

        }

      Scope scope = this.OuterScope;

      while (scope != null && !(scope is NamespaceScope)) scope = scope.OuterScope;

      if (scope != null) return ((NamespaceScope)scope).GetNamespaceFullNameFor(name);

      return null;

    returnFullName:

      this.nestedNamespaceFullName[name.UniqueIdKey] = fullName;

      return fullName;

    }

    /// <summary>

    /// Search this namespace for a type with this name nested in the given namespace. Also considers used name spaces.

    /// If more than one type is found, a list is returned in duplicates.

    /// </summary>

    public virtual TypeNode GetType(Identifier Namespace, Identifier name, out TypeNodeList duplicates){

      duplicates = null;

      if (Namespace == null || name == null || this.AssociatedNamespace == null || this.AssociatedModule == null){

        Debug.Assert(false); return null;

      }

      if (this.namespaceFor == null){

        Debug.Assert(false);

        this.namespaceFor = new TrivialHashtable();

      }

      TrivialHashtable typeFor = (TrivialHashtable)this.namespaceFor[Namespace.UniqueIdKey];

      if (typeFor == null) this.namespaceFor[Namespace.UniqueIdKey] = typeFor = new TrivialHashtable();

      TypeNode result = (TypeNode)typeFor[name.UniqueIdKey];

      if (result == Class.DoesNotExist) return null;

      if (result != null) return result;

      //If the associated module declares a type with the given name in a nested namespace, it wins

      Scope scope = this;

      while (scope != null){

        NamespaceScope nsScope = scope as NamespaceScope;

        if (nsScope != null && nsScope.AssociatedNamespace != null){

          Identifier nestedNamespace = Namespace;

          if (nsScope.AssociatedNamespace.FullNameId != null && nsScope.AssociatedNamespace.FullNameId.UniqueIdKey != Identifier.Empty.UniqueIdKey)

            nestedNamespace = Identifier.For(nsScope.AssociatedNamespace.FullName+"."+Namespace);

          result = this.AssociatedModule.GetType(nestedNamespace, name);

          if (result != null) break;

        }

        scope = scope.OuterScope;

      }

      if (result == null){

        //Now get into situations where there might be duplicates.

        duplicates = new TypeNodeList();

        //Check the used namespaces of this and outer namespace scopes

        TrivialHashtable alreadyUsed = new TrivialHashtable();

        scope = this;

        while (scope != null){

          NamespaceScope nsScope = scope as NamespaceScope;

          if (nsScope != null && nsScope.AssociatedNamespace != null){

            UsedNamespaceList usedNamespaces = nsScope.AssociatedNamespace.UsedNamespaces;

            int n = usedNamespaces == null ? 0 : usedNamespaces.Count;

            if (usedNamespaces != null)

              for (int i = 0; i < n; i++){

                UsedNamespace usedNs = usedNamespaces[i];

                if (usedNs == null || usedNs.Namespace == null) continue;

                int key = usedNs.Namespace.UniqueIdKey;

                if (alreadyUsed[key] != null) continue;

                alreadyUsed[key] = usedNs.Namespace;

                Identifier usedNestedNamespace = Identifier.For(usedNs.Namespace+"."+Namespace);

                result = this.AssociatedModule.GetType(usedNestedNamespace, name);

                if (result != null) duplicates.Add(result);

              }

          }

          scope = scope.OuterScope;

        }

        if (duplicates.Count > 0) result = duplicates[0];

      }

      if (result == null){

        //The associated module does not have a type by this name, so check its referenced modules and assemblies

        int numDups = 0;

        //Check this namespace and outer namespaces

        scope = this;

        while (scope != null && result == null){

          NamespaceScope nsScope = scope as NamespaceScope;

          if (nsScope != null && nsScope.AssociatedNamespace != null){

            Identifier nestedNamespace = Namespace;

            if (nsScope.AssociatedNamespace.FullNameId != null && nsScope.AssociatedNamespace.FullNameId.UniqueIdKey != Identifier.Empty.UniqueIdKey)

              nestedNamespace = Identifier.For(nsScope.AssociatedNamespace.FullName+"."+Namespace);

            nsScope.GetReferencedTypes(nestedNamespace, name, duplicates);

            numDups = duplicates.Count;

            for (int i = numDups-1; i >= 0; i--){

              TypeNode dup = duplicates[i];

              if (dup == null || !dup.IsPublic) numDups--;

              result = dup;

            }

          }

          scope = scope.OuterScope;

        }

        if (numDups == 0){

          if (duplicates.Count > 0) duplicates = new TypeNodeList();

          //Check the used namespaces of this and outer namespace scopes

          TrivialHashtable alreadyUsed = new TrivialHashtable();

          scope = this;

          while (scope != null){

            NamespaceScope nsScope = scope as NamespaceScope;

            if (nsScope != null && nsScope.AssociatedNamespace != null){

              UsedNamespaceList usedNamespaces = this.AssociatedNamespace.UsedNamespaces;

              int n = usedNamespaces == null ? 0 : usedNamespaces.Count;

              if (usedNamespaces != null)

                for (int i = 0; i < n; i++){

                  UsedNamespace usedNs = usedNamespaces[i];

                  if (usedNs == null) continue;

                  int key = usedNs.Namespace.UniqueIdKey;

                  if (alreadyUsed[key] != null) continue;

                  alreadyUsed[key] = usedNs.Namespace;

                  Identifier usedNestedNamespace = Identifier.For(usedNs.Namespace+"."+Namespace);

                  this.GetReferencedTypes(usedNestedNamespace, name, duplicates);

                }

            }

            scope = scope.OuterScope;

          }

          numDups = duplicates.Count;

          for (int i = numDups-1; i >= 0; i--){

            TypeNode dup = duplicates[i];

            if (dup == null || !dup.IsPublic) numDups--;

            result = dup;

          }

        }

        if (numDups <= 1) duplicates = null;

      }

      if (result == null)

        typeFor[name.UniqueIdKey] = Class.DoesNotExist;

      else

        typeFor[name.UniqueIdKey] = result;

      return result; 

    }

    /// <summary>

    /// Searches this namespace for a type with this name. Also considers aliases and used name spaces, including those of outer namespaces.

    /// If more than one type is found, a list is returned in duplicates. Types defined in the associated

    /// module mask types defined in referenced modules and assemblies. Results are cached and duplicates are returned only when

    /// there is a cache miss.

    /// </summary>

    public virtual TypeNode GetType(Identifier name, out TypeNodeList duplicates){

      return this.GetType(name, out duplicates, false);

    }

    public virtual TypeNode GetType(Identifier name, out TypeNodeList duplicates, bool returnNullIfHiddenByNestedNamespace){

      duplicates = null;

      if (name == null || this.typeFor == null || this.AssociatedNamespace == null || this.AssociatedModule == null){

        Debug.Assert(false); return null;

      }

      AssemblyNode associatedAssembly = this.AssociatedModule as AssemblyNode;

      TypeNode result = (TypeNode)this.typeFor[name.UniqueIdKey];

      if (result == Class.DoesNotExist) return null;

      if (result != null) return result;

      //If the associated module declares a type with the given name in this namespace, it wins

      result = this.AssociatedModule.GetType(this.AssociatedNamespace.FullNameId, name);

      if (result == null && returnNullIfHiddenByNestedNamespace){

        //Do not proceed to outer namespaces or look at aliases. The nested namespace hides these.

        Identifier fullName = name;

        if (this.AssociatedNamespace.FullName != null && this.AssociatedNamespace.Name.UniqueIdKey != Identifier.Empty.UniqueIdKey)

          fullName = Identifier.For(this.AssociatedNamespace.FullName+"."+name);

        if (this.AssociatedModule.IsValidNamespace(fullName))

          result = Class.DoesNotExist;

      }

      if (result == null){

        //If the namespace (or an outer namespace) has an alias definition with this name it wins. (Expected to be mutually exclusive with above.)        

        Scope scope = this;

        while (scope != null && result == null){

          NamespaceScope nsScope = scope as NamespaceScope;

          if (nsScope != null && nsScope.AliasedType != null)

            result = (TypeNode)nsScope.AliasedType[name.UniqueIdKey];

          if (result == null && returnNullIfHiddenByNestedNamespace && nsScope != null && 

          nsScope.AliasedNamespace != null && nsScope.AliasedNamespace[name.UniqueIdKey] != null)

            result = Class.DoesNotExist;

          scope = scope.OuterScope;

        }

      }

      if (result == null){

        //Now get into situations where there might be duplicates.

        duplicates = new TypeNodeList();

        //Check the used namespaces of this and outer namespace scopes

        TrivialHashtable alreadyUsed = new TrivialHashtable();

        Scope scope = this;

        while (scope != null) {

          NamespaceScope nsScope = scope as NamespaceScope;

          if (nsScope != null && nsScope.AssociatedNamespace != null && nsScope.AssociatedModule != null) {

            UsedNamespaceList usedNamespaces = nsScope.AssociatedNamespace.UsedNamespaces;

            int n = usedNamespaces == null ? 0 : usedNamespaces.Count;

            if (usedNamespaces != null)

              for (int i = 0; i < n; i++) {

                UsedNamespace usedNs = usedNamespaces[i];

                if (usedNs == null || usedNs.Namespace == null) continue;

                int key = usedNs.Namespace.UniqueIdKey;

                if (alreadyUsed[key] != null) continue;

                alreadyUsed[key] = usedNs.Namespace;

                result = this.AssociatedModule.GetType(usedNs.Namespace, name);

                //^ assert duplicates != null;

                if (result != null) duplicates.Add(result);

              }

          }

          if (returnNullIfHiddenByNestedNamespace) break; 

          scope = scope.OuterScope;

        }

        if (duplicates.Count > 0) result = duplicates[0];

      }

      if (result == null)

        //First see if the the current module has a class by this name in the empty namespace

        result = this.AssociatedModule.GetType(Identifier.Empty, name);

      if (result == null){

        //The associated module does not have a type by this name, so check its referenced modules and assemblies

        //First check this namespace

        this.GetReferencedTypes(this.AssociatedNamespace.FullNameId, name, duplicates);

        int numDups = duplicates.Count;

        if (numDups == 1){

          result = duplicates[0];

          if (this.IsNotAccessible(associatedAssembly, result)) { numDups--; result = null; }

        }else{

          for (int i = numDups-1; i >= 0; i--){

            TypeNode dup = duplicates[i];

            if (this.IsNotAccessible(associatedAssembly, dup)) { numDups--; continue; }

            result = dup;

          }

          if (numDups == 0 && duplicates.Count > 0){

            result = duplicates[0];

            numDups = duplicates.Count;

          }

        }

        if (numDups == 0){

          if (duplicates.Count > 0) duplicates = new TypeNodeList();

          //Check the used namespaces of this and outer namespace scopes

          TrivialHashtable alreadyUsed = new TrivialHashtable();

          Scope scope = this;

          while (scope != null) {

            NamespaceScope nsScope = scope as NamespaceScope;

            if (nsScope != null) {

              UsedNamespaceList usedNamespaces = nsScope.AssociatedNamespace.UsedNamespaces;

              int n = usedNamespaces == null ? 0 : usedNamespaces.Count;

              if (usedNamespaces != null)

                for (int i = 0; i < n; i++) {

                  UsedNamespace usedNs = usedNamespaces[i];

                  if (usedNs == null || usedNs.Namespace == null) continue;

                  int key = usedNs.Namespace.UniqueIdKey;

                  if (alreadyUsed[key] != null) continue;

                  alreadyUsed[key] = usedNs.Namespace;

                  this.GetReferencedTypes(usedNs.Namespace, name, duplicates);

                }

            }

            scope = scope.OuterScope;

            if (returnNullIfHiddenByNestedNamespace) break;

          }

          numDups = duplicates.Count;

          for (int i = numDups-1; i >= 0; i--){

            TypeNode dup = duplicates[i];

            if (this.IsNotAccessible(associatedAssembly, dup)) { 

              numDups--; continue;

            }

            result = dup;

          }

        }

        if (numDups == 0){

          if (duplicates.Count > 0) duplicates = new TypeNodeList();

          this.GetReferencedTypes(Identifier.Empty, name, duplicates);

          numDups = duplicates.Count;

          for (int i = numDups-1; i >= 0; i--){

            TypeNode dup = duplicates[i];

            if (this.IsNotAccessible(associatedAssembly, dup)) { 

              numDups--; continue;

            }

            result = dup;

          }

        }

        if (numDups <= 1) duplicates = null;

      }

      if (result == null)

        this.typeFor[name.UniqueIdKey] = Class.DoesNotExist;

      else

        this.typeFor[name.UniqueIdKey] = result;

      if (result == Class.DoesNotExist) return null;

      if (duplicates != null && duplicates.Count > 1 && this.AssociatedNamespace != null && this.AssociatedNamespace.Name != null && this.AssociatedNamespace.Name.Name != null) {

        result = null;

        for (int i = 0, n = duplicates.Count; i < n; i++) {

          TypeNode t = duplicates[i];

          if (t == null || t.Namespace == null) continue;

          if (this.AssociatedNamespace.Name.Name.StartsWith(t.Namespace.Name)) {

            if (result != null) {

              result = null;

              break;

            }

            result = t;

          }

        }

        if (result != null)

          duplicates = null;

        else

          result = duplicates[0];

      }

      return result; 

    }

    private bool IsNotAccessible(AssemblyNode associatedAssembly, TypeNode dup) {

      if (dup == null) return false;

      return !dup.IsPublic && (associatedAssembly == null || 

              !associatedAssembly.MayAccessInternalTypesOf(dup.DeclaringModule as AssemblyNode)) && !this.AssociatedModule.ContainsModule(dup.DeclaringModule);

    }

    /// <summary>

    /// Searches the module and assembly references of the associated module to find types

    /// </summary>

    public virtual void GetReferencedTypes(Identifier Namespace, Identifier name, TypeNodeList types){

      if (Namespace == null || name == null || types == null || this.AssociatedModule == null) {Debug.Assert(false); return;}

      AssemblyReferenceList arefs = this.AssociatedModule.AssemblyReferences;

      for (int i = 0, n = arefs == null ? 0 : arefs.Count; i < n; i++){

        AssemblyReference ar = arefs[i];

        if (ar == null || ar.Assembly == null) continue;

        TypeNode t = ar.Assembly.GetType(Namespace, name);

        if (t == null) continue;

        //TODO: deal with type forwarding

        types.Add(t);

      }

      ModuleReferenceList mrefs = this.AssociatedModule.ModuleReferences;

      if (mrefs != null)

        for (int i = 0, n = mrefs.Count; i < n; i++){

          ModuleReference mr = mrefs[i];

          if (mr == null || mr.Module == null) continue;

          TypeNode t = mr.Module.GetType(Namespace, name);

          if (t == null) continue;

          types.Add(t);

        }

    }

  }

#endif

  public class DelegateNode : TypeNode{

    internal static readonly DelegateNode/*!*/ Dummy = new DelegateNode();

    protected ParameterList parameters;

    public virtual ParameterList Parameters{

      get{

        ParameterList pList = this.parameters;

        if (pList == null){

          MemberList members = this.Members; //Evaluate for side effect

          if (members != null) members = null;

          lock(this){

            if (this.parameters != null) return this.parameters;

            MemberList invokers = this.GetMembersNamed(StandardIds.Invoke);

            for (int i = 0, n = invokers.Count; i < n; i++){

              Method m = invokers[i] as Method;

              if (m == null) continue;

              this.parameters = pList = m.Parameters;

              this.returnType = m.ReturnType;

              break;

            }

          }

        }

        return pList;

      }

      set{

        this.parameters = value;

      }

    }

    protected TypeNode returnType;

    public virtual TypeNode ReturnType{

      get{

        TypeNode rt = this.returnType;

        if (rt == null){

          ParameterList pars = this.Parameters; //Evaluate for side effect

          if (pars != null) pars = null;

          rt = this.returnType;

        }

        return rt;

      }

      set{

        this.returnType = value;

      }

    }

#if !MinimalReader

    public TypeNode ReturnTypeExpression;

#endif

    public DelegateNode()

      : base(NodeType.DelegateNode){

    }

    public DelegateNode(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.DelegateNode, provideNestedTypes, provideAttributes, provideMembers, handle){

    }

#if !MinimalReader

    public DelegateNode(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags flags,

      Identifier Namespace, Identifier name, TypeNode returnType, ParameterList parameters)

      : base(declaringModule, declaringType, attributes, flags, Namespace, name, null, null, NodeType.DelegateNode){

      this.parameters = parameters;

      this.returnType = returnType;

    }

    private bool membersAlreadyProvided;

    public virtual void ProvideMembers(){

      if (this.membersAlreadyProvided) return;

      this.membersAlreadyProvided = true;

      this.memberCount = 0;

      MemberList members = this.members = new MemberList();

      //ctor

      ParameterList parameters = new ParameterList(2);

      parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Object, CoreSystemTypes.Object, null, null));

      parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Method, CoreSystemTypes.IntPtr, null, null));

      InstanceInitializer ctor = new InstanceInitializer(this, null, parameters, null);

      ctor.Flags |= MethodFlags.Public|MethodFlags.HideBySig;

      ctor.CallingConvention = CallingConventionFlags.HasThis;

      ctor.ImplFlags = MethodImplFlags.Runtime;

      members.Add(ctor);

      //Invoke

      Method invoke = new Method(this, null, StandardIds.Invoke, this.Parameters, this.ReturnType, null);

      invoke.Flags = MethodFlags.Public|MethodFlags.HideBySig|MethodFlags.Virtual|MethodFlags.NewSlot;

      invoke.CallingConvention = CallingConventionFlags.HasThis;

      invoke.ImplFlags = MethodImplFlags.Runtime;

      members.Add(invoke);

      // Skip adding async methods if AsyncCallback is a dummy.

      if (SystemTypes.AsyncCallback.ReturnType != null)

      {

        //BeginInvoke

        ParameterList dparams = this.parameters;

        int n = dparams == null ? 0 : dparams.Count;

        parameters = new ParameterList(n + 2);

        for (int i = 0; i < n; i++)

        {

          //^ assert dparams != null;

          Parameter p = dparams[i];

          if (p == null) continue;

          parameters.Add((Parameter)p.Clone());

        }

        parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.callback, SystemTypes.AsyncCallback, null, null));

        parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Object, CoreSystemTypes.Object, null, null));

        Method beginInvoke = new Method(this, null, StandardIds.BeginInvoke, parameters, SystemTypes.IASyncResult, null);

        beginInvoke.Flags = MethodFlags.Public | MethodFlags.HideBySig | MethodFlags.NewSlot | MethodFlags.Virtual;

        beginInvoke.CallingConvention = CallingConventionFlags.HasThis;

        beginInvoke.ImplFlags = MethodImplFlags.Runtime;

        members.Add(beginInvoke);

        //EndInvoke

        parameters = new ParameterList(1);

        for (int i = 0; i < n; i++)

        {

          Parameter p = dparams[i];

          if (p == null || p.Type == null || !(p.Type is Reference)) continue;

          parameters.Add((Parameter)p.Clone());

        }

        parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.result, SystemTypes.IASyncResult, null, null));

        Method endInvoke = new Method(this, null, StandardIds.EndInvoke, parameters, this.ReturnType, null);

        endInvoke.Flags = MethodFlags.Public | MethodFlags.HideBySig | MethodFlags.NewSlot | MethodFlags.Virtual;

        endInvoke.CallingConvention = CallingConventionFlags.HasThis;

        endInvoke.ImplFlags = MethodImplFlags.Runtime;

        members.Add(endInvoke);

      }

      if (!this.IsGeneric){

        TypeNodeList templPars = this.TemplateParameters;

        for (int i = 0, m = templPars == null ? 0 : templPars.Count; i < m; i++){

          //^ assert templPars != null;

          TypeNode tpar = templPars[i];

          if (tpar == null) continue;

          members.Add(tpar);

        }

      }

    }

#endif

  }

#if !MinimalReader

  public class FunctionType : DelegateNode{

    private FunctionType(Identifier name, TypeNode returnType, ParameterList parameters){

      this.Flags = TypeFlags.Public|TypeFlags.Sealed;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = name;

      this.returnType = returnType;

      this.parameters = parameters;

    }

    public static FunctionType For(TypeNode returnType, ParameterList parameters, TypeNode referringType){

      if (returnType == null || referringType == null) return null;

      Module module = referringType.DeclaringModule;

      if (module == null) return null;

      TypeFlags visibility = returnType.Flags & TypeFlags.VisibilityMask;

      StringBuilder name = new StringBuilder();

      name.Append("Function_");

      name.Append(returnType.Name.ToString());

      int n = parameters == null ? 0 : parameters.Count;

      if (parameters != null)

        for (int i = 0; i < n; i++){

          Parameter p = parameters[i];

          if (p == null || p.Type == null) continue;

          visibility = TypeNode.GetVisibilityIntersection(visibility, p.Type.Flags & TypeFlags.VisibilityMask);

          name.Append('_');

          name.Append(p.Type.Name.ToString());

        }

      FunctionType func = null;

      int count = 0;

      string fNameString = name.ToString();

      Identifier fName = Identifier.For(fNameString);

      TypeNode result = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, fName);

      while (result != null){

        //Mangled name is the same. But mangling is not unique (types are not qualified with assemblies), so check for equality.

        func = result as FunctionType;

        bool goodMatch = func != null && func.ReturnType == returnType;

        if (goodMatch){

          //^ assert func != null;

          ParameterList fpars = func.Parameters;

          int m = fpars == null ? 0 : fpars.Count;

          goodMatch = n == m;

          if (parameters != null && fpars != null)

            for (int i = 0; i < n && goodMatch; i++){

              Parameter p = parameters[i];

              Parameter q = fpars[i];

              goodMatch = p != null && q != null && p.Type == q.Type;

            }

        }

        if (goodMatch) return func;

        //Mangle some more

        fName = Identifier.For(fNameString+(++count).ToString());

        result = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, fName);

      }

      if (parameters != null){

        ParameterList clonedParams = new ParameterList(n);

        for (int i = 0; i < n; i++){

          Parameter p = parameters[i];

          if (p != null) p = (Parameter)p.Clone();

          clonedParams.Add(p);

        }

        parameters = clonedParams;

      }

      func = new FunctionType(fName, returnType, parameters);

      func.DeclaringModule = module;

      switch (visibility){

        case TypeFlags.NestedFamANDAssem:

        case TypeFlags.NestedFamily:

        case TypeFlags.NestedPrivate:

          referringType.Members.Add(func);

          func.DeclaringType = referringType;

          func.Flags &= ~TypeFlags.VisibilityMask;

          func.Flags |= TypeFlags.NestedPrivate;

          break;

        default:

          module.Types.Add(func);

          break;

      }

      module.StructurallyEquivalentType[func.Name.UniqueIdKey] = func;

      func.ProvideMembers();

      return func;

    }

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList();

        result.Add(this.ReturnType);

        ParameterList pars = this.Parameters;

        for (int i = 0, n = pars == null ? 0 : pars.Count; i < n; i++){

          Parameter par = pars[i]; 

          if (par == null || par.Type == null) continue;

          result.Add(par.Type);

        }

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      FunctionType t = type as FunctionType;

      if (t == null) return false;

      if (this.Template != null) return base.IsStructurallyEquivalentTo(t);

      if (this.Flags != t.Flags) return false;

      if (this.ReturnType == null || t.ReturnType == null) return false;

      if (this.ReturnType != t.ReturnType && !this.ReturnType.IsStructurallyEquivalentTo(t.ReturnType)) return false;

      if (this.Parameters == null) return t.Parameters == null;

      if (t.Parameters == null) return false;

      int n = this.Parameters.Count; if (n != t.Parameters.Count) return false;

      for (int i = 0; i < n; i++){

        Parameter p1 = this.Parameters[i];

        Parameter p2 = t.Parameters[i];

        if (p1 == null || p2 == null) return false;

        if (p1.Type == null || p2.Type == null) return false;

        if (p1.Type != p2.Type && !p1.Type.IsStructurallyEquivalentTo(p2.Type)) return false;

      }

      return true;

    }

  }

#endif

  public class EnumNode : TypeNode{

    internal readonly static EnumNode/*!*/ Dummy = new EnumNode();



    public EnumNode()

      : base(NodeType.EnumNode){

      this.typeCode = ElementType.ValueType;

      this.Flags |= TypeFlags.Sealed;

    }

    public EnumNode(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.EnumNode, provideNestedTypes, provideAttributes, provideMembers, handle){

      this.typeCode = ElementType.ValueType;

      this.Flags |= TypeFlags.Sealed;

    }

#if !MinimalReader

    public EnumNode(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags typeAttributes,

      Identifier Namespace, Identifier name, InterfaceList interfaces, MemberList members)

      : base(declaringModule, declaringType, attributes, typeAttributes, Namespace, name, interfaces, members, NodeType.EnumNode){

      this.typeCode = ElementType.ValueType;

      this.Flags |= TypeFlags.Sealed;

    }

#endif

    public override bool IsUnmanaged{

      get{

        return true;

      }

    }

    protected internal TypeNode underlyingType;

    /// <summary>

    /// The underlying integer type used to store values of this enumeration.

    /// </summary>

    public virtual TypeNode UnderlyingType{

      get{

        if (this.underlyingType == null){

          if (this.template is EnumNode)

            return this.underlyingType = ((EnumNode)this.template).UnderlyingType;

          this.underlyingType = CoreSystemTypes.Int32;

          MemberList members = this.Members;

          for (int i = 0, n = members.Count; i < n; i++){

            Member mem = members[i];

            Field f = mem as Field;

            if (f != null && (f.Flags & FieldFlags.Static) == 0) 

              return this.underlyingType = f.Type;

          }

        }

        return this.underlyingType;

      }

      set{

        this.underlyingType = value;

        MemberList members = this.Members;

        for (int i = 0, n = members.Count; i < n; i++){

          Member mem = members[i];

          Field f = mem as Field;

          if (f != null && (f.Flags & FieldFlags.Static) == 0){

            f.Type = value;

            return;

          }

        }

        this.Members.Add(new Field(this, null, FieldFlags.Public|FieldFlags.SpecialName|FieldFlags.RTSpecialName, StandardIds.Value__, value, null));

      }

    }

#if ExtendedRuntime

    public override bool IsPointerFree

    {

      get

      {

        return true;

      }

    }

#endif

#if !MinimalReader

    public TypeNode UnderlyingTypeExpression;

#endif

  }

#if FxCop

  public class InterfaceNode : TypeNode{

#else

  public class Interface : TypeNode{

#endif

    protected TrivialHashtable jointMemberTable;

    protected MemberList jointDefaultMembers;



    internal static readonly Interface/*!*/ Dummy = new Interface();



#if FxCop

    public InterfaceNode()

      : base(NodeType.Interface){

      this.Flags = TypeFlags.Interface|TypeFlags.Abstract;

    }

    public InterfaceNode(InterfaceList baseInterfaces)

      : base(NodeType.Interface){

      this.Interfaces = baseInterfaces;

      this.Flags = TypeFlags.Interface|TypeFlags.Abstract;

    }

    public InterfaceNode(InterfaceList baseInterfaces, NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.Interface, provideNestedTypes, provideAttributes, provideMembers, handle){

      this.Interfaces = baseInterfaces;

    }

#else

    public Interface()

      : base(NodeType.Interface){

      this.Flags = TypeFlags.Interface|TypeFlags.Abstract;

    }

    public Interface(InterfaceList baseInterfaces)

      : base(NodeType.Interface){

      this.Interfaces = baseInterfaces;

      this.Flags = TypeFlags.Interface|TypeFlags.Abstract;

    }

    public Interface(InterfaceList baseInterfaces, NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.Interface, provideNestedTypes, provideAttributes, provideMembers, handle){

      this.Interfaces = baseInterfaces;

    }

#endif

#if !MinimalReader

    public Interface(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags flags,

      Identifier Namespace, Identifier name, InterfaceList baseInterfaces, MemberList members)

      : base(declaringModule, declaringType, attributes, flags, Namespace, name, baseInterfaces, members, NodeType.Interface){

      this.Flags |= TypeFlags.Interface|TypeFlags.Abstract;

    }

    public override void GetAbstractMethods(MethodList/*!*/ result) {

      MemberList members = this.Members;

      if (members == null) return;

      for (int i = 0, n = members.Count; i < n; i++){

        Method m = members[i] as Method;

        if (m != null) result.Add(m);

      }

    }

    public virtual MemberList GetAllDefaultMembers() {

      if (this.jointDefaultMembers == null) {

        this.jointDefaultMembers = new MemberList();

        MemberList defs = this.DefaultMembers;

        for (int i = 0, n = defs == null ? 0 : defs.Count; i < n; i++)

          this.jointDefaultMembers.Add(defs[i]);

        InterfaceList interfaces = this.Interfaces;

        if (interfaces != null)

          for (int j = 0, m = interfaces.Count; j < m; j++) {

            Interface iface = interfaces[j];

            if (iface == null) continue;

            defs = iface.GetAllDefaultMembers();

            if (defs == null) continue;

            for (int i = 0, n = defs.Count; i < n; i++)

              this.jointDefaultMembers.Add(defs[i]);

        }

      }

      return this.jointDefaultMembers;

    }

    public virtual MemberList GetAllMembersNamed(Identifier/*!*/ name) {

      lock (this){

        TrivialHashtable memberTable = this.jointMemberTable;

        if (memberTable == null) this.jointMemberTable = memberTable = new TrivialHashtable();

        MemberList result = (MemberList)memberTable[name.UniqueIdKey];

        if (result != null) return result;

        memberTable[name.UniqueIdKey] = result = new MemberList();

        MemberList members = this.GetMembersNamed(name);

        for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++)

          result.Add(members[i]);

        InterfaceList interfaces = this.Interfaces;

        for (int j = 0, m = interfaces == null ? 0 : interfaces.Count; j < m; j++){

          Interface iface = interfaces[j];

          if (iface == null) continue;

          members = iface.GetAllMembersNamed(name);

          if (members != null)

            for (int i = 0, n = members.Count; i < n; i++)

              result.Add(members[i]);

        }

        members = CoreSystemTypes.Object.GetMembersNamed(name);

        for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++)

          result.Add(members[i]);

        return result;

      }

    }

#endif

  }

  public class Struct : TypeNode{

    internal static readonly Struct/*!*/ Dummy = new Struct();



    public Struct()

      : base(NodeType.Struct){

      this.typeCode = ElementType.ValueType;

      this.Flags = TypeFlags.Sealed;

    }

    public Struct(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(NodeType.Struct, provideNestedTypes, provideAttributes, provideMembers, handle){

      this.typeCode = ElementType.ValueType;

    }

#if !MinimalReader

    public Struct(Module declaringModule, TypeNode declaringType, AttributeList attributes, TypeFlags flags,

      Identifier Namespace, Identifier name, InterfaceList interfaces, MemberList members)

      : base(declaringModule, declaringType, attributes, flags, Namespace, name, interfaces, members, NodeType.Struct){

      this.Interfaces = interfaces;

      this.typeCode = ElementType.ValueType;

      this.Flags |= TypeFlags.Sealed;

    }

    protected bool cachedUnmanaged;

    protected bool cachedUnmanagedIsValid;

    /// <summary>True if the type is a value type containing only fields of unmanaged types.</summary>

    public override bool IsUnmanaged{

      get{

        if (this.cachedUnmanagedIsValid) return this.cachedUnmanaged;

        this.cachedUnmanagedIsValid = true; //protect against cycles

        this.cachedUnmanaged = true; //Self references should not influence the answer

        if (this.IsPrimitive) return this.cachedUnmanaged = true;

        MemberList members = this.Members;

        bool isUnmanaged = true;

        for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){

          Field f = members[i] as Field;

          if (f == null || f.Type == null || f.IsStatic) continue;

          if (!f.Type.IsUnmanaged){isUnmanaged = false; break;}

        }

#if ExtendedRuntime

        this.cachedUnmanaged = isUnmanaged || IsPointerFree;

#else

        this.cachedUnmanaged = isUnmanaged;

#endif

        return this.cachedUnmanaged;

      }

    }

#endif

#if ExtendedRuntime

    protected bool cachedPointerFree;

    protected bool cachedPointerFreeIsValid;

    /// <summary>True if the type is a value type containing no managed or unmanaged pointers.</summary>

    public override bool IsPointerFree

    {

      get

      {

        if (this.cachedPointerFreeIsValid) return this.cachedPointerFree;

        // Note: not threadsafe

        this.cachedPointerFreeIsValid = true; //protect against cycles

        this.cachedPointerFree = true; //Self references should not influence the answer

        if (this.IsPrimitive) return this.cachedPointerFree = true;

        MemberList members = this.Members;

        bool isPointerFree = true;

        for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++)

        {

          Field f = members[i] as Field;

          if (f == null || f.Type == null || f.IsStatic) continue;

          if (!f.Type.IsPointerFree) { isPointerFree = false; break; }

        }

        return this.cachedPointerFree = isPointerFree;

      }

    }

#endif

  }

  public interface ITypeParameter{

    Member DeclaringMember{get;set;}

    /// <summary>

    /// Zero based index into a parameter list containing this parameter.

    /// </summary>

    int ParameterListIndex{get;set;}

    TypeParameterFlags TypeParameterFlags{get;set;}

    bool IsUnmanaged { get; }

#if ExtendedRuntime

    bool IsPointerFree { get; }

#endif

#if !MinimalReader

    Identifier Name { get; }

    Module DeclaringModule { get; }

    TypeNode DeclaringType { get; }

    SourceContext SourceContext { get; }

    int UniqueKey { get; }

    TypeFlags Flags { get; }

#endif

  }

  public class TypeParameter : Interface, ITypeParameter{

    

    public TypeParameter()

      : base(){

      this.NodeType = NodeType.TypeParameter;

      this.Flags = TypeFlags.Interface|TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }

    public TypeParameter(InterfaceList baseInterfaces, NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(baseInterfaces, provideNestedTypes, provideAttributes, provideMembers, handle){

      this.NodeType = NodeType.TypeParameter;

      this.Flags = TypeFlags.Interface|TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }



    public Member DeclaringMember{

      get{return this.declaringMember;}

      set{this.declaringMember = value;}

    }

    private Member declaringMember;

#if !NoReflection && WHIDBEY

    public override Type GetRuntimeType() {

      TypeNode t = this.DeclaringMember as TypeNode;

      if (t == null) return null;

      Type rt = t.GetRuntimeType();

      if (rt == null) return null;

      System.Type[] typeParameters = rt.GetGenericArguments();

      if (this.ParameterListIndex >= typeParameters.Length) return null;

      return typeParameters[this.ParameterListIndex];

    }

#endif

    /// <summary>

    /// Zero based index into a parameter list containing this parameter.

    /// </summary>

    public int ParameterListIndex{

      get{return this.parameterListIndex;}

      set{this.parameterListIndex = value;}

    }

    private int parameterListIndex;

#if ExtendedRuntime

    private bool typeParameterFlagsIsValid = false;

#endif

    public TypeParameterFlags TypeParameterFlags{

      get{

#if ExtendedRuntime

        if (!typeParameterFlagsIsValid) {

          // check if we have the corresponding attribute

          for (int i=0; i < (this.Attributes == null?0:this.Attributes.Count); i++) {

            if (this.Attributes[i].Type == SystemTypes.TemplateParameterFlagsAttribute) {

              Literal lit = this.Attributes[i].Expressions[0] as Literal;

              if (lit != null && lit.Value is int) {

                this.typeParameterFlags = (TypeParameterFlags)((int)lit.Value);

              }

              break;

            }

          }

          this.typeParameterFlagsIsValid = true;

        }

#endif

        return this.typeParameterFlags;

      }

      set{

        this.typeParameterFlags = value;

#if ExtendedRuntime

        this.typeParameterFlagsIsValid = true;

#endif

    }

    }

    private TypeParameterFlags typeParameterFlags;

    public override bool IsStructural{

      get{return true;}

    }

    /// <summary>True if the type serves as a parameter to a type template.</summary>

    public override bool IsTemplateParameter{

      get{

        return true;

      }

    }

    public override bool IsValueType {

      get {

        return ((this.TypeParameterFlags & TypeParameterFlags.ValueTypeConstraint) == TypeParameterFlags.ValueTypeConstraint);

      }

    }

#if ExtendedRuntime

    public override bool IsReferenceType {

      get {

        return ((this.TypeParameterFlags & TypeParameterFlags.ReferenceTypeConstraint) == TypeParameterFlags.ReferenceTypeConstraint);

      }

    }

    private bool isUnmanagedIsValid = false;

    private bool isUnmanaged = false;

    public override bool IsUnmanaged{

      get{

        if (!isUnmanagedIsValid && SystemTypes.UnmanagedStructTemplateParameterAttribute != null){

          // check if we have the corresponding attribute

          for (int i=0; i < (this.Attributes == null?0:this.Attributes.Count); i++){

            AttributeNode attr = this.Attributes[i];

            if (attr == null) continue;

            if (attr.Type == SystemTypes.UnmanagedStructTemplateParameterAttribute){

              isUnmanaged = true;

              break;

            }

#if ExtendedRuntime

            if (!isUnmanaged) { isUnmanaged = IsPointerFree; }

#endif

          }

          isUnmanagedIsValid = true;

        }

        return isUnmanaged;

      }

    }

    public void SetIsUnmanaged(){

      this.isUnmanaged = true;

      this.isUnmanagedIsValid = true;

    }

    private bool isPointerFreeIsValid = false;

    private bool isPointerFree = false;

    public override bool IsPointerFree

    {

      get

      {

        if (!isPointerFreeIsValid && SystemTypes.PointerFreeStructTemplateParameterAttribute != null)

        {

          // check if we have the corresponding attribute

          for (int i = 0; i < (this.Attributes == null ? 0 : this.Attributes.Count); i++)

          {

            AttributeNode attr = this.Attributes[i];

            if (attr == null) continue;

            if (attr.Type == SystemTypes.PointerFreeStructTemplateParameterAttribute)

            {

              isPointerFree = true;

              break;

            }

          }

          isPointerFreeIsValid = true;

        }

        return isPointerFree;

      }

    }

    public void SetIsPointerFree()

    {

      this.isPointerFree = true;

      this.isPointerFreeIsValid = true;

      // implies unmanaged

      SetIsUnmanaged();

    }

#endif

#if !NoXml

  public override XmlNode Documentation{

      get{

        if (this.documentation == null && this.declaringMember != null && this.Name != null){

          XmlNode parentDoc = this.declaringMember.Documentation;

          if (parentDoc != null && parentDoc.HasChildNodes){

            string myName = this.Name.Name;

            foreach (XmlNode child in parentDoc.ChildNodes){

              if (child.Name == "typeparam" && child.Attributes != null){

                foreach (XmlAttribute attr in child.Attributes){

                  if (attr != null && attr.Name == "name" && attr.Value == myName)

                    return this.documentation = child;

                }

              }

            }

          }

        }

        return this.documentation;

      }

      set{

        this.documentation = value;

      }

    }

    public override string HelpText{

      get{

        if (this.helpText == null){

          XmlNode doc = this.Documentation;

          if (doc != null) this.helpText = doc.InnerText;

        }

        return this.helpText;

      }

      set{

        this.helpText = value;

      }

    }

#endif

    protected internal TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList();

        if (this.BaseType != null) result.Add(this.BaseType);

        InterfaceList interfaces = this.Interfaces;

        for (int i = 0, n = interfaces == null ? 0 : interfaces.Count; i < n; i++){

          Interface iface = interfaces[i]; 

          if (iface == null) continue;

          result.Add(iface);

        }

        return result;

      }

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (TargetPlatform.GenericTypeNamesMangleChar != 0) {

        int n = methodTypeParameters == null ? 0 : methodTypeParameters.Count;

        for (int i = 0; i < n; i++){

          //^ assert methodTypeParameters != null;

          TypeNode mpar = methodTypeParameters[i];

          if (mpar != this) continue;

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(i);

          return;

        }

        n = typeParameters == null ? 0 : typeParameters.Count;

        for (int i = 0; i < n; i++){

          TypeNode tpar = typeParameters[i];

          if (tpar != this) continue;

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(i);

          return;

        }

        sb.Append("not found:");

      }

      sb.Append(this.FullName);

    }

#endif

    public override string GetFullUnmangledNameWithoutTypeParameters(){

      return this.GetUnmangledNameWithoutTypeParameters();

    }

    public override string GetFullUnmangledNameWithTypeParameters(){

      return this.GetUnmangledNameWithTypeParameters();

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (null == (object)type) return false;

      if (this == type) return true;

      ITypeParameter itype = type as ITypeParameter;

      if (null == (object)itype) return false;

      if (this.Name != null && type.Name != null && this.Name.UniqueIdKey != type.Name.UniqueIdKey) {

        if (this.DeclaringMember == itype.DeclaringMember) return false;

      }

      TypeNode bType = this.BaseType;

      TypeNode tbType = type.BaseType;

      if (null == (object)bType) bType = CoreSystemTypes.Object;

      if (null == (object)tbType) tbType = CoreSystemTypes.Object;

      if (bType != tbType /*&& !bType.IsStructurallyEquivalentTo(tbType)*/) return false;

      if (this.Interfaces == null) return type.Interfaces == null || type.Interfaces.Count == 0;

      if (type.Interfaces == null) return this.Interfaces.Count == 0;

      int n = this.Interfaces.Count; if (n != type.Interfaces.Count) return false;

      for (int i = 0; i < n; i++){

        Interface i1 = this.Interfaces[i];

        Interface i2 = type.Interfaces[i];

        if (null == (object)i1 || null == (object)i2) return false;

        if (i1 != i2 /*&& !i1.IsStructurallyEquivalentTo(i2)*/) return false;

      }

      return true;

    }

#if !MinimalReader

    Module ITypeParameter.DeclaringModule { get { return this.DeclaringModule; } }

    TypeFlags ITypeParameter.Flags { get { return this.Flags; } }

    SourceContext ITypeParameter.SourceContext { get { return this.SourceContext; } }

#endif

#if FxCop

    internal override void GetName(TypeFormat options, StringBuilder name)

    {

      if (options.TypeName == TypeNameFormat.FullyQualified)

      {

        TypeFormat typeFormat = options.Clone();

        typeFormat.TypeName = TypeNameFormat.Short;

        base.GetName(typeFormat, name);

        return;

      }

      base.GetName(options, name);

    }

#endif

  }

  public class MethodTypeParameter : TypeParameter{

    public MethodTypeParameter()

      : base(){

      this.NodeType = NodeType.TypeParameter;

      this.Flags = TypeFlags.Interface|TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }

#if !MinimalReader

    public MethodTypeParameter(InterfaceList baseInterfaces, NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(baseInterfaces, provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.NodeType = NodeType.TypeParameter;

      this.Flags = TypeFlags.Interface|TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }

#endif

#if !NoReflection

#if WHIDBEY

    public override Type GetRuntimeType() {

      Method m = this.DeclaringMember as Method;

      if (m == null) return null;

      System.Reflection.MethodInfo mi = m.GetMethodInfo();

      if (mi == null) return null;

      System.Type[] typeParameters = mi.GetGenericArguments();

      if (this.ParameterListIndex >= typeParameters.Length) return null;

      return typeParameters[this.ParameterListIndex];

    }

#endif

#endif

    public override bool IsStructurallyEquivalentTo(TypeNode type) {

      if (object.ReferenceEquals(this, type)) return true;

      ITypeParameter tp = type as ITypeParameter;

      if (tp == null) return false;

      if (this.ParameterListIndex == tp.ParameterListIndex && this.DeclaringMember == tp.DeclaringMember) return true;

      return base.IsStructurallyEquivalentTo(type as MethodTypeParameter);

    }

  }

  public class ClassParameter : Class, ITypeParameter{

    protected TrivialHashtable jointMemberTable;



    public ClassParameter()

      : base(){

      this.NodeType = NodeType.ClassParameter;

      this.baseClass = CoreSystemTypes.Object;

      this.Flags = TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }

    public ClassParameter(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle){

      this.NodeType = NodeType.ClassParameter;

      this.baseClass = CoreSystemTypes.Object;

      this.Flags = TypeFlags.NestedPrivate|TypeFlags.Abstract|TypeFlags.SpecialName;

      this.Namespace = StandardIds.TypeParameter;

    }



    public Member DeclaringMember{

      get{return this.declaringMember;}

      set{this.declaringMember = value;}

    }

    private Member declaringMember;

#if !MinimalReader

    public virtual MemberList GetAllMembersNamed(Identifier/*!*/ name) {

      lock (this) {

        TrivialHashtable memberTable = this.jointMemberTable;

        if (memberTable == null) this.jointMemberTable = memberTable = new TrivialHashtable();

        MemberList result = (MemberList)memberTable[name.UniqueIdKey];

        if (result != null) return result;

        memberTable[name.UniqueIdKey] = result = new MemberList();

        TypeNode t = this;

        while (t != null) {

          MemberList members = t.GetMembersNamed(name);

          if (members != null)

            for (int i = 0, n = members.Count; i < n; i++)

              result.Add(members[i]);

          t = t.BaseType;

        }

        InterfaceList interfaces = this.Interfaces;

        if (interfaces != null)

          for (int j = 0, m = interfaces.Count; j < m; j++) {

            Interface iface = interfaces[j];

            if (iface == null) continue;

            members = iface.GetAllMembersNamed(name);

            if (members != null)

            for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++)

              result.Add(members[i]);

          }

        members = CoreSystemTypes.Object.GetMembersNamed(name);

        if (members != null)

          for (int i = 0, n = members.Count; i < n; i++)

            result.Add(members[i]);

        return result;

      }

    }

#endif



#if !NoReflection && WHIDBEY

    public override Type GetRuntimeType() {

      TypeNode t = this.DeclaringMember as TypeNode;

      if (t == null) return null;

      Type rt = t.GetRuntimeType();

      if (rt == null) return null;

      System.Type[] typeParameters = rt.GetGenericArguments();

      if (this.ParameterListIndex >= typeParameters.Length) return null;

      return typeParameters[this.ParameterListIndex];

    }

#endif



    /// <summary>

    /// Zero based index into a parameter list containing this parameter.

    /// </summary>

    public int ParameterListIndex{

      get{return this.parameterListIndex;}

      set{this.parameterListIndex = value;}

    }

    private int parameterListIndex;

    public TypeParameterFlags TypeParameterFlags{

      get{return this.typeParameterFlags;}

      set{this.typeParameterFlags = value;}

    }

    private TypeParameterFlags typeParameterFlags;

    public override bool IsValueType {

      get {

        return ((this.typeParameterFlags & TypeParameterFlags.ValueTypeConstraint) == TypeParameterFlags.ValueTypeConstraint);

      }

    }

    public override bool IsStructural {

      get{return true;}

    }

    /// <summary>True if the type serves as a parameter to a type template.</summary>

    public override bool IsTemplateParameter{

      get{

        return true;

      }

  }

#if ExtendedRuntime

    public override bool IsReferenceType {

      get {

        return ((this.TypeParameterFlags & TypeParameterFlags.ReferenceTypeConstraint) == TypeParameterFlags.ReferenceTypeConstraint)

               || (this.baseClass != null && this.baseClass.IsReferenceType);

      }

    }

    private bool isUnmanagedIsValid = false;

    private bool isUnmanaged = false;

    public override bool IsUnmanaged{

      get{

        if (!isUnmanagedIsValid && SystemTypes.UnmanagedStructTemplateParameterAttribute != null){

          // check if we have the corresponding attribute

          for (int i=0; i < (this.Attributes == null?0:this.Attributes.Count); i++){

            if (this.Attributes[i].Type == SystemTypes.UnmanagedStructTemplateParameterAttribute){

              isUnmanaged = true;

              break;

            }

          }

#if ExtendedRuntime

          if (!isUnmanaged) { isUnmanaged = IsPointerFree; }

#endif

          isUnmanagedIsValid = true;

        }

        return isUnmanaged;

      }

    }

    public void SetIsUnmanaged(){

      this.isUnmanaged = true;

      this.isUnmanagedIsValid = true;

    }

    private bool isPointerFreeIsValid = false;

    private bool isPointerFree = false;

    public override bool IsPointerFree

    {

      get

      {

        if (!isPointerFreeIsValid && SystemTypes.PointerFreeStructTemplateParameterAttribute != null)

        {

          // check if we have the corresponding attribute

          for (int i = 0; i < (this.Attributes == null ? 0 : this.Attributes.Count); i++)

          {

            if (this.Attributes[i].Type == SystemTypes.PointerFreeStructTemplateParameterAttribute)

            {

              isPointerFree = true;

              break;

            }

          }

          isPointerFreeIsValid = true;

        }

        return isPointerFree;

      }

    }

    public void SetIsPointerFree()

    {

      this.isPointerFree = true;

      this.isPointerFreeIsValid = true;

      // pointerfree implies Unmanaged

      SetIsUnmanaged();

    }

#endif

#if !NoXml

  public override XmlNode Documentation{

      get{

        if (this.documentation == null && this.declaringMember != null && this.Name != null){

          XmlNode parentDoc = this.declaringMember.Documentation;

          if (parentDoc != null && parentDoc.HasChildNodes){

            string myName = this.Name.Name;

            foreach (XmlNode child in parentDoc.ChildNodes){

              if (child.Name == "typeparam" && child.Attributes != null){

                foreach (XmlAttribute attr in child.Attributes){

                  if (attr != null && attr.Name == "name" && attr.Value == myName)

                    return this.documentation = child;

                }

              }

            }

          }

        }

        return this.documentation;

      }

      set{

        this.documentation = value;

      }

    }

    public override string HelpText{

      get{

        if (this.helpText == null){

          XmlNode doc = this.Documentation;

          if (doc != null) this.helpText = doc.InnerText;

        }

        return this.helpText;

      }

      set{

        this.helpText = value;

      }

    }

#endif

    protected internal TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList();

        if (this.BaseType != null) result.Add(this.BaseType);

        InterfaceList interfaces = this.Interfaces;

        for (int i = 0, n = interfaces == null ? 0 : interfaces.Count; i < n; i++){

          Interface iface = interfaces[i]; 

          if (iface == null) continue;

          result.Add(iface);

        }

        return result;

      }

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (TargetPlatform.GenericTypeNamesMangleChar != 0) {

        int n = methodTypeParameters == null ? 0 : methodTypeParameters.Count;

        for (int i = 0; i < n; i++){

          //^ assert methodTypeParameters != null;

          TypeNode mpar = methodTypeParameters[i];

          if (mpar != this) continue;

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(i);

          return;

        }

        n = typeParameters == null ? 0 : typeParameters.Count;

        for (int i = 0; i < n; i++){

          TypeNode tpar = typeParameters[i];

          if (tpar != this) continue;

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(i);

          return;

        }

        sb.Append("not found:");

      }

      sb.Append(this.FullName);

    }

#endif

    public override string GetFullUnmangledNameWithoutTypeParameters(){

      return this.GetUnmangledNameWithoutTypeParameters();

    }

    public override string GetFullUnmangledNameWithTypeParameters(){

      return this.GetUnmangledNameWithTypeParameters();

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (null == (object)type) return false;

      if (this == type) return true;

      ITypeParameter itype = type as ITypeParameter;

      if (null == (object)itype) return false;

      if (this.Name != null && type.Name != null && this.Name.UniqueIdKey != type.Name.UniqueIdKey){

        if (this.DeclaringMember == itype.DeclaringMember) return false;

      }

      TypeNode bType = this.BaseType;

      TypeNode tbType = type.BaseType;

      if (null == (object)bType) bType = CoreSystemTypes.Object;

      if (null == (object)tbType) tbType = CoreSystemTypes.Object;

      if (bType != tbType /*&& !bType.IsStructurallyEquivalentTo(tbType)*/) return false;

      if (this.Interfaces == null) return type.Interfaces == null || type.Interfaces.Count == 0;

      if (type.Interfaces == null) return this.Interfaces.Count == 0;

      int n = this.Interfaces.Count; if (n != type.Interfaces.Count) return false;

      for (int i = 0; i < n; i++){

        Interface i1 = this.Interfaces[i];

        Interface i2 = type.Interfaces[i];

        if (null == (object)i1 || null == (object)i2) return false;

        if (i1 != i2 /*&& !i1.IsStructurallyEquivalentTo(i2)*/) return false;

      }

      return true;

    }

#if !MinimalReader

    SourceContext ITypeParameter.SourceContext { get { return this.SourceContext; } }

    Module ITypeParameter.DeclaringModule { get { return this.DeclaringModule; } }

    TypeFlags ITypeParameter.Flags { get { return this.Flags; } }

#endif

#if FxCop

    internal override void GetName(TypeFormat options, StringBuilder name)

    {

      if (options.TypeName == TypeNameFormat.FullyQualified)

      {

        TypeFormat typeFormat = options.Clone();

        typeFormat.TypeName = TypeNameFormat.Short;

        base.GetName(typeFormat, name);

        return;

      }

      base.GetName(options, name); 

    }

#endif

  }

  public class MethodClassParameter : ClassParameter{

    public MethodClassParameter()

      : base(){

      this.NodeType = NodeType.ClassParameter;

      this.baseClass = CoreSystemTypes.Object;

      this.Flags = TypeFlags.NestedPublic|TypeFlags.Abstract;

      this.Namespace = StandardIds.TypeParameter;

    }

#if !NoReflection && WHIDBEY

    public override Type GetRuntimeType() {

      Method m = this.DeclaringMember as Method;

      if (m == null) return null;

      System.Reflection.MethodInfo mi = m.GetMethodInfo();

      if (mi == null) return null;

      System.Type[] typeParameters = mi.GetGenericArguments();

      if (this.ParameterListIndex >= typeParameters.Length) return null;

      return typeParameters[this.ParameterListIndex];

    }

#endif

#if !MinimalReader

    public override bool IsStructurallyEquivalentTo(TypeNode type) {

      if (object.ReferenceEquals(this, type)) return true;

      ITypeParameter tp = type as ITypeParameter;

      if (tp == null) return false;

      if (this.ParameterListIndex == tp.ParameterListIndex /* && this.DeclaringMember == tp.DeclaringMember*/) return true;

      return base.IsStructurallyEquivalentTo(type as MethodClassParameter);

    }

#endif

  }

  public class ArrayType : TypeNode{

    private TypeNode/*!*/ elementType;

    private int rank;

    private int[] lowerBounds;

    private int[] sizes;    

    internal ArrayType()

      : base(NodeType.ArrayType){

    }

    internal ArrayType(TypeNode/*!*/ elementType, int rank)

      : this(elementType, rank, new int[0], new int[0]){

      if (rank == 1)

        this.typeCode = Metadata.ElementType.SzArray;

      else

        this.typeCode = Metadata.ElementType.Array;

    }

    internal ArrayType(TypeNode/*!*/ elementType, int rank, int[] sizes)

      : this(elementType, rank, sizes, new int[0]){

    }

    internal ArrayType(TypeNode/*!*/ elementType, int rank, int[] sizes, int[] lowerBounds)

      : base(null, null, null, elementType.Flags, null, null, null, null, NodeType.ArrayType){

      Debug.Assert(elementType != null);

      this.rank = rank;

      this.elementType = elementType;

      this.DeclaringModule = elementType.DeclaringModule;

      this.lowerBounds = lowerBounds;

      this.sizes = sizes;

      if (rank == 1)

        this.typeCode = Metadata.ElementType.SzArray;

      else

        this.typeCode = Metadata.ElementType.Array;

      if (elementType == null || elementType.Name == null) return;

      StringBuilder name = new StringBuilder(this.ElementType.Name.ToString());

#if FxCop

      GetNameSuffix(name, false);

#else

      name.Append('[');

      int k = this.Sizes == null ? 0 : this.Sizes.Length;

      int m = this.LowerBounds == null ? 0 : this.LowerBounds.Length;

      for (int i = 0, n = this.Rank; i < n; i++){

        if (i < k && this.Sizes[i] != 0){

          if (i < m && this.LowerBounds[i] != 0){

            name.Append(this.LowerBounds[i]);

            name.Append(':');

          }

          name.Append(this.Sizes[i]);

        }

        if (i < n-1)

          name.Append(',');

      }

      name.Append(']');

#endif

      this.Name = Identifier.For(name.ToString());

      this.Namespace = elementType.Namespace;

    }

    public TypeNode/*!*/ ElementType {

      get{return this.elementType;}

      set{this.elementType = value;}

    }

    /// <summary>The interfaces implemented by this class or struct, or the extended by this interface.</summary>

    public override InterfaceList Interfaces {

      get {

        if (this.interfaces == null) {

          InterfaceList interfaces = new InterfaceList(SystemTypes.ICloneable, SystemTypes.IList, SystemTypes.ICollection, SystemTypes.IEnumerable);

          if (this.Rank == 1) {

            if (SystemTypes.GenericIEnumerable != null && SystemTypes.GenericIEnumerable.DeclaringModule == CoreSystemTypes.SystemAssembly) {

              interfaces.Add((Interface)SystemTypes.GenericIEnumerable.GetTemplateInstance(this, elementType));

              if (SystemTypes.GenericICollection != null)

                interfaces.Add((Interface)SystemTypes.GenericICollection.GetTemplateInstance(this, elementType));

              if (SystemTypes.GenericIList != null)

                interfaces.Add((Interface)SystemTypes.GenericIList.GetTemplateInstance(this, elementType));

            }

          }

          this.interfaces = interfaces;

        }

        return this.interfaces;

      }

      set { this.interfaces = value; }

    }

    public int Rank {

      get{return this.rank;}

      set{this.rank = value;}

    }

    public int[] LowerBounds{

      get{return this.lowerBounds;}

      set{this.lowerBounds = value;}

    }

    public int[] Sizes{

      get{return this.sizes;}

      set{this.sizes = value;}

    }

    public bool IsSzArray(){

      return this.typeCode == Metadata.ElementType.SzArray;

    }

    private MemberList ctorList = null;

    private MemberList getterList = null;

    private MemberList setterList = null;

    private MemberList addressList = null;

    public override MemberList Members{

      get{

        if (this.members == null || this.membersBeingPopulated){

          lock(this){

            if (this.members == null){

              this.membersBeingPopulated = true;

              MemberList members = this.members = new MemberList(5);

              members.Add(this.Constructor);

              //^ assume this.ctorList != null && this.ctorList.Length > 1;

              members.Add(this.ctorList[1]);

              members.Add(this.Getter);

              members.Add(this.Setter);

              members.Add(this.Address);

              this.membersBeingPopulated = false;

            }

          }

        }

        return this.members;

      }

      set{

        this.members = value;

      }

    }

    public override string/*!*/ FullName {

      get{

        if (this.ElementType != null && this.ElementType.DeclaringType != null)

          return this.ElementType.DeclaringType.FullName+"+"+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

          return this.Namespace.ToString() + "."+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Name != null)

          return this.Name.ToString();

        else

          return "";

      }

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (this.ElementType == null) return;

      this.ElementType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

      sb.Append('[');

      int k = this.Sizes == null ? 0 : this.Sizes.Length;

      int m = this.LowerBounds == null ? 0 : this.LowerBounds.Length;

      for (int i = 0, n = this.Rank; i < n; i++){

        if (i < k && this.Sizes[i] != 0){

          if (i < m && this.LowerBounds[i] != 0){

            sb.Append(this.LowerBounds[i]);

            sb.Append(':');

          }

          sb.Append(this.Sizes[i]);

        }

        if (i < n-1)

          sb.Append(',');

      }

      sb.Append(']');

    }

#endif

    public virtual void SetLowerBoundToUnknown(){

      Debug.Assert(this.Rank == 1);

      this.typeCode = Metadata.ElementType.Array;

    }

    public virtual int GetLowerBound(int dimension){

      if (this.LowerBounds == null || this.LowerBounds.Length <= dimension) return 0;

      return this.LowerBounds[dimension];

    }

    public virtual int GetSize(int dimension){

      if (this.Sizes == null || this.Sizes.Length <= dimension) return 0;

      return this.Sizes[dimension];

    }

    public override MemberList/*!*/ GetMembersNamed(Identifier name) {

      if (name == null) return new MemberList(0);

      if (name.UniqueIdKey == StandardIds.Get.UniqueIdKey){

        if (this.getterList == null){

          Method getter = this.Getter;

          if (getter != null) getter = null;

          //^ assume this.getterList != null;

        }

        return this.getterList;

      }else if (name.UniqueIdKey == StandardIds.Set.UniqueIdKey){

        if (this.setterList == null){

          Method setter = this.Setter;

          if (setter != null) setter = null;

          //^ assume this.setterList != null;

        }

        return this.setterList;

      }else if (name.UniqueIdKey == StandardIds.Ctor.UniqueIdKey){

        if (this.ctorList == null){

          Method ctor = this.Constructor;

          if (ctor != null) ctor = null;

          //^ assume this.ctorList != null;

        }

        return this.ctorList;      

      }else if (name.UniqueIdKey == StandardIds.Address.UniqueIdKey){

        if (this.addressList == null){

          Method addr = this.Address;

          if (addr != null) addr = null;

          //^ assume this.addressList != null;

        }

        return this.addressList;

      }else

        return new MemberList(0);

    }

#if !NoReflection

    public override Type GetRuntimeType(){

      if (this.runtimeType == null){

        if (this.ElementType == null) return null;

        Type eType = this.ElementType.GetRuntimeType();

        if (eType == null) return null;

#if WHIDBEY

        if (this.IsSzArray())

          this.runtimeType = eType.MakeArrayType();

        else

          this.runtimeType = eType.MakeArrayType(this.Rank);

#else

        StringBuilder sb = new StringBuilder(eType.FullName);

        sb.Append('[');

        for (int i = 1, n = this.Rank; i < n; i++) sb.Append(',');

        sb.Append(']');

        if (eType.Assembly != null)

          this.runtimeType = eType.Assembly.GetType(sb.ToString(), false);

        else if (eType.Module != null)

          this.runtimeType = eType.Module.GetType(sb.ToString(), false);

#endif

      }

      return this.runtimeType;

    }

#endif

    public Method Constructor{

      get{

        if (this.ctorList == null){

          lock(this){

            if (this.ctorList == null){

              InstanceInitializer ctor = new InstanceInitializer();

              ctor.DeclaringType = this;

              ctor.Flags |= MethodFlags.Public;

              int n = this.Rank;

              ctor.Parameters = new ParameterList(n);

              for (int i = 0; i < n; i++){

                Parameter par = new Parameter();

                par.DeclaringMethod = ctor;

                par.Type = CoreSystemTypes.Int32;

                ctor.Parameters.Add(par);

              }

              this.ctorList = new MemberList(2);

              this.ctorList.Add(ctor);

              ctor = new InstanceInitializer();

              ctor.DeclaringType = this;

              ctor.Flags |= MethodFlags.Public;

              ctor.Parameters = new ParameterList(n=n*2);

              for (int i = 0; i < n; i++){

                Parameter par = new Parameter();

                par.Type = CoreSystemTypes.Int32;

                par.DeclaringMethod = ctor;

                ctor.Parameters.Add(par);

              }

              this.ctorList.Add(ctor);

            }

          }

        }

        return (Method)this.ctorList[0];

      }

    }

    public Method Getter{

      get{

        if (this.getterList == null){

          lock(this){

            if (this.getterList == null){

              Method getter = new Method();

              getter.Name = StandardIds.Get;

              getter.DeclaringType = this;

              getter.CallingConvention = CallingConventionFlags.HasThis;

              getter.Flags = MethodFlags.Public;

              getter.Parameters = new ParameterList();

              for (int i = 0, n = this.Rank; i < n; i++){

                Parameter par = new Parameter();

                par.Type = CoreSystemTypes.Int32;

                par.DeclaringMethod = getter;

                getter.Parameters.Add(par);

              }

              getter.ReturnType = this.ElementType;

              this.getterList = new MemberList();

              this.getterList.Add(getter);

            }

          }

        }

        return (Method)this.getterList[0];

      }

    }

    public Method Setter{

      get{

        if (this.setterList == null){

          lock(this){

            if (this.setterList == null){

              Method setter = new Method();

              setter.Name = StandardIds.Set;

              setter.DeclaringType = this;

              setter.CallingConvention = CallingConventionFlags.HasThis;

              setter.Flags = MethodFlags.Public;

              setter.Parameters = new ParameterList();

              Parameter par;

              for (int i = 0, n = this.Rank; i < n; i++){

                par = new Parameter();

                par.Type = CoreSystemTypes.Int32;

                par.DeclaringMethod = setter;

                setter.Parameters.Add(par);

              }

              par = new Parameter();

              par.Type = this.ElementType;

              par.DeclaringMethod = setter;

              setter.Parameters.Add(par);

              setter.ReturnType = CoreSystemTypes.Void;

              this.setterList = new MemberList();

              this.setterList.Add(setter);

            }

          }

        }

        return (Method)this.setterList[0];

      }

    }

    public Method Address{

      get{

        if (this.addressList == null){

          lock(this){

            if (this.addressList == null){

              Method address = new Method();

              address.Name = StandardIds.Address;

              address.DeclaringType = this;

              address.CallingConvention = CallingConventionFlags.HasThis;

              address.Flags = MethodFlags.Public;

              address.Parameters = new ParameterList();

              for (int i = 0, n = this.Rank; i < n; i++){

                Parameter par = new Parameter();

                par.Type = CoreSystemTypes.Int32;

                par.DeclaringMethod = address;

                address.Parameters.Add(par);

              }

              address.ReturnType = this.ElementType.GetReferenceType();

              this.addressList = new MemberList();

              this.addressList.Add(address);

            }

          }

        }

        return (Method)this.addressList[0];

      }

    }

    public override bool IsAssignableTo(TypeNode targetType){

      if (targetType == null) return false;

      if (targetType == this || targetType == CoreSystemTypes.Object || targetType == CoreSystemTypes.Array || targetType == SystemTypes.ICloneable) return true;

      if (CoreSystemTypes.Array.IsAssignableTo(targetType)) return true;

      if (targetType.Template != null && SystemTypes.GenericIEnumerable != null && SystemTypes.GenericIEnumerable.DeclaringModule == CoreSystemTypes.SystemAssembly) {

        if (targetType.Template == SystemTypes.GenericIEnumerable || targetType.Template == SystemTypes.GenericICollection ||

          targetType.Template == SystemTypes.GenericIList) {

          if (targetType.TemplateArguments == null || targetType.TemplateArguments.Count != 1) {

            Debug.Assert(false); return false;

          }

          TypeNode ienumElementType = targetType.TemplateArguments[0];

          if (this.ElementType == ienumElementType) return true;

          if (this.ElementType.IsValueType) return false;

          return this.ElementType.IsAssignableTo(ienumElementType);

        }

      }

      ArrayType targetArrayType = targetType as ArrayType;

      if (targetArrayType == null) return false;

      if (this.Rank != 1 || targetArrayType.Rank != 1) return false;

      TypeNode thisElementType = this.ElementType;

      if (thisElementType == null) return false;

#if ExtendedRuntime

      thisElementType = TypeNode.StripModifier(thisElementType, ExtendedRuntimeTypes.NonNullType);

      // DelayedAttribute is used as a modifier on some array allocation types to mark it as 

      // an explictly delayed allocation.

      thisElementType = TypeNode.StripModifier(thisElementType, ExtendedRuntimeTypes.DelayedAttribute);

#endif

      if (thisElementType == targetArrayType.ElementType) return true;

      if (thisElementType.IsValueType) return false;

      return thisElementType.IsAssignableTo(targetArrayType.ElementType);

    }

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        result.Add(this.ElementType);

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      ArrayType t = type as ArrayType;

      if (t == null) return false;

      if (this.Rank != t.Rank) return false;

      if (this.ElementType == null || t.ElementType == null) return false;

      if (this.ElementType != t.ElementType && !this.ElementType.IsStructurallyEquivalentTo(t.ElementType)) return false;

      if (this.Sizes == null) return t.Sizes == null;

      if (t.Sizes == null) return false;

      int n = this.Sizes.Length; if (n != t.Sizes.Length) return false;

      for (int i = 0; i < n; i++){

        if (this.Sizes[i] != t.Sizes[i]) return false;

      }

      if (this.LowerBounds == null) return t.LowerBounds == null;

      if (t.LowerBounds == null) return false;

      n = this.LowerBounds.Length; if (n != t.LowerBounds.Length) return false;

      for (int i = 0; i < n; i++){

        if (this.LowerBounds[i] != t.LowerBounds[i]) return false;

      }

      return true;

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      this.ElementType.GetName(options, name);

      GetNameSuffix(name, options.InsertSpacesBetweenMethodTypeParameters);

    }

    private void GetNameSuffix(StringBuilder name, bool insertSpacesBetweenParameters)

    {

      name.Append('[');

      int k = this.Sizes == null ? 0 : this.Sizes.Length;

      int m = this.LowerBounds == null ? 0 : this.LowerBounds.Length;

      for (int i = 0, n = this.Rank; i < n; i++)

      {

        if (i < k && this.Sizes[i] != 0)

        {

          if (i < m && this.LowerBounds[i] != 0)

          {

            name.Append(this.LowerBounds[i].ToString("0", CultureInfo.InvariantCulture));

            name.Append(':');

          }

          name.Append(this.Sizes[i].ToString("0", CultureInfo.InvariantCulture));

        }

        if (i < n - 1)

        {

          name.Append(',');

          if (insertSpacesBetweenParameters)

            name.Append(' ');

        }

      }

      name.Append(']');

    }

#endif

  }

  public class Pointer : TypeNode{

    internal Pointer(TypeNode/*!*/ elementType)

      : base(NodeType.Pointer){

      this.elementType = elementType;

      this.typeCode = Metadata.ElementType.Pointer;

      this.Name = Identifier.For(elementType.Name+"*");

      this.Namespace = elementType.Namespace;

    }

    private TypeNode/*!*/ elementType;

    public TypeNode/*!*/ ElementType {

      get{return this.elementType;}

      set{this.elementType = value;}

    }

    public override string/*!*/ FullName {

      get{

        if (this.ElementType != null && this.ElementType.DeclaringType != null)

          return this.ElementType.DeclaringType.FullName+"+"+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

          return this.Namespace.ToString()+"."+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Name != null)

          return this.Name.ToString();

        else

          return "";

      }

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (this.elementType == null) return;

      this.elementType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

      sb.Append('*');

    }

#endif

#if !NoReflection

    public override Type GetRuntimeType(){

      if (this.runtimeType == null){

        if (this.ElementType == null) return null;

        Type eType = this.ElementType.GetRuntimeType();

        if (eType == null) return null;

#if WHIDBEY

        this.runtimeType = eType.MakePointerType();

#else

        if (eType.Assembly != null)

          this.runtimeType = eType.Assembly.GetType(eType.FullName+"*", false);

        else

          this.runtimeType = eType.Module.GetType(eType.FullName+"*", false);

#endif

      }

      return this.runtimeType;

    }

#endif

    public override bool IsAssignableTo(TypeNode targetType){

      return targetType == this || (targetType is Pointer && ((Pointer)targetType).ElementType == CoreSystemTypes.Void);

    }

    public override bool IsUnmanaged{

      get{

        return true;

      }

    }

    public override bool IsStructural{

      get{return true;}

    }

    public override bool IsPointerType {

      get {

        return true;

      }

    }



    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        result.Add(this.ElementType);

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      Pointer t = type as Pointer;

      if (t == null) return false;

      if (this.ElementType == null || t.ElementType == null) return false;

      return this.ElementType == t.ElementType || this.ElementType.IsStructurallyEquivalentTo(t.ElementType);

    }

#if FxCop

    internal override void GetName(TypeFormat options, StringBuilder name)

    {

      this.ElementType.GetName(options, name);

      name.Append('*');

    }

#endif

  }

  public class Reference : TypeNode{

    internal Reference(TypeNode/*!*/ elementType)

      : base(NodeType.Reference){

      this.elementType = elementType;

      this.typeCode = Metadata.ElementType.Reference;

      this.Name = Identifier.For(elementType.Name+"@");

      this.Namespace = elementType.Namespace;

    }

    private TypeNode/*!*/ elementType;

    public TypeNode/*!*/ ElementType {

      get{return this.elementType;}

      set{this.elementType = value;}

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      if (this.elementType == null) return;

      this.elementType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

      sb.Append('@');

    }

#endif

    public override bool IsAssignableTo(TypeNode targetType){

      return targetType == this || 

        (targetType is Pointer && (((Pointer)targetType).ElementType == this.ElementType ||

                                   ((Pointer)targetType).ElementType == CoreSystemTypes.Void));

    }



    public override string/*!*/ FullName {

      get{

        if (this.ElementType != null && this.ElementType.DeclaringType != null)

          return this.ElementType.DeclaringType.FullName+"+"+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Namespace != null && this.Namespace.UniqueIdKey != Identifier.Empty.UniqueIdKey)

          return this.Namespace.ToString()+"."+(this.Name == null ? "" : this.Name.ToString());

        else if (this.Name != null)

          return this.Name.ToString();

        else

          return "";

      }

    }

#if !NoReflection

    public override Type GetRuntimeType(){

      if (this.runtimeType == null){

        if (this.ElementType == null) return null;

        Type eType = this.ElementType.GetRuntimeType();

        if (eType == null) return null;

#if WHIDBEY

        this.runtimeType = eType.MakeByRefType();

#else

        if (eType.Assembly != null)

          this.runtimeType = eType.Assembly.GetType(eType.FullName+"&", false);

        else

          this.runtimeType = eType.Module.GetType(eType.FullName+"&", false);

#endif

      }

      return this.runtimeType;

    }

#endif

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        result.Add(this.ElementType);

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      Reference t = type as Reference;

      if (t == null) return false;

      if (this.ElementType == null || t.ElementType == null) return false;

      return this.ElementType == t.ElementType || this.ElementType.IsStructurallyEquivalentTo(t.ElementType);

    }

#if FxCop

    internal override void GetName(TypeFormat options, StringBuilder name)

    {

      this.ElementType.GetName(options, name);

      name.Append('&');

    }

#endif

  }

#if ExtendedRuntime

  public class TupleType : Struct{

    private TupleType(FieldList domains, Identifier/*!*/ name, TypeNode/*!*/ referringType, TypeFlags visibility) {

      referringType.DeclaringModule.StructurallyEquivalentType[name.UniqueIdKey] = this;

      this.DeclaringModule = referringType.DeclaringModule;

      this.NodeType = NodeType.TupleType;

      this.Flags = TypeFlags.Sealed;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = name;

      this.isNormalized = true;

      switch (visibility){

        case TypeFlags.NestedFamANDAssem:

        case TypeFlags.NestedFamily:

        case TypeFlags.NestedPrivate:

          referringType.Members.Add(this);

          this.DeclaringType = referringType;

          this.Flags |= TypeFlags.NestedPrivate;

          break;

        default:

          referringType.DeclaringModule.Types.Add(this);

          this.Flags |= TypeFlags.Public;

          break;

      }

      int n = domains == null ? 0 : domains.Count;

      MemberList members = this.members = new MemberList(n);

      TypeNodeList types = new TypeNodeList(n);

      for (int i = 0; i < n; i++){

        //^ assert domains != null;

        Field f = domains[i];

        if (f == null) continue;

        f = (Field)f.Clone();

        f.DeclaringType = this;

        members.Add(f);

        if (f.Type != null)

          types.Add(f.Type);       

      }

      TypeNode elemType = null;

      if (n == 1)

        elemType = types[0]; //TODO: get element type of stream?

      else{

        TypeUnion tu = TypeUnion.For(types, referringType);

        //^ assume tu != null;

        elemType = tu;

        if (tu.Types.Count == 1) elemType = tu.Types[0];

      }

      if (elemType == null) elemType = CoreSystemTypes.Object;

      Interface ienumerable = (Interface)SystemTypes.GenericIEnumerable.GetTemplateInstance(referringType, elemType);

      Interface ienumerator = (Interface)SystemTypes.GenericIEnumerator.GetTemplateInstance(referringType, elemType);

      this.Interfaces = new InterfaceList(SystemTypes.TupleType, ienumerable, SystemTypes.IEnumerable);



      This ThisParameter = new This(this.GetReferenceType());

      StatementList statements = new StatementList(1);

      TypeNode tEnumerator = TupleEnumerator.For(this, n, elemType, ienumerator, referringType);

      InstanceInitializer cons = tEnumerator.GetConstructor(this);

      if (cons == null) { Debug.Fail(""); return; }

      ExpressionList args = new ExpressionList(new AddressDereference(ThisParameter, this));

      statements.Add(new Return(new Construct(new MemberBinding(null, cons), args)));

      Block body = new Block(statements);

      Method getEnumerator = new Method(this, null, StandardIds.GetEnumerator, null, ienumerator, body);

      getEnumerator.Flags = MethodFlags.Public|MethodFlags.Virtual;

      getEnumerator.CallingConvention = CallingConventionFlags.HasThis;

      getEnumerator.ThisParameter = ThisParameter;

      this.members.Add(getEnumerator);



      //IEnumerable.GetEnumerator

      ThisParameter = new This(this.GetReferenceType());

      statements = new StatementList(1);

      MethodCall mcall = new MethodCall(new MemberBinding(ThisParameter, getEnumerator), new ExpressionList(0), NodeType.Call, SystemTypes.IEnumerator);

      statements.Add(new Return(mcall));

      getEnumerator = new Method(this, null, StandardIds.IEnumerableGetEnumerator, null, SystemTypes.IEnumerator, new Block(statements));

      getEnumerator.ThisParameter = ThisParameter;

      getEnumerator.ImplementedInterfaceMethods = new MethodList(SystemTypes.IEnumerable.GetMethod(StandardIds.GetEnumerator));

      getEnumerator.CallingConvention = CallingConventionFlags.HasThis;

      getEnumerator.Flags = MethodFlags.Private | MethodFlags.Virtual | MethodFlags.SpecialName;

      this.members.Add(getEnumerator);

    }

    internal TupleType(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.NodeType = NodeType.TupleType;

      this.typeCode = ElementType.ValueType;

    }

    public static TupleType For(FieldList domains, TypeNode referringType){

      if (referringType == null) return null;

      Module module = referringType.DeclaringModule;

      if (module == null) return null;

      TypeFlags visibility = TypeFlags.Public;

      StringBuilder name = new StringBuilder();

      name.Append("Tuple");

      int n = domains == null ? 0 : domains.Count;

      for (int i = 0; i < n; i++) {

        //^ assert domains != null;

        Field f = domains[i];

        if (f == null || f.Type == null || f.Type.Name == null) continue;

        visibility = TypeNode.GetVisibilityIntersection(visibility, f.Type.Flags & TypeFlags.VisibilityMask);

        name.Append('_');

        name.Append(f.Type.Name.ToString());

        if (f.Name != null && !f.IsSpecialName) {

          name.Append('_');

          name.Append(f.Name.ToString());

        }

      }

      TupleType tup = null;

      int tCount = 0;

      string tNameString = name.ToString();

      Identifier tName = Identifier.For(tNameString);

      TypeNode result = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      while (result != null) {

        //Mangled name is the same. But mangling is not unique (types are not qualified with assemblies), so check for equality.

        tup = result as TupleType;

        bool goodMatch = tup != null;

        if (goodMatch) {

          //^ assert tup != null;

          MemberList tMembers = tup.Members;

          int m = tMembers == null ? 0 : tMembers.Count;

          goodMatch = n == m-2;

          if (goodMatch) {

            //^ assert domains != null;

            //^ assert tMembers != null;

            for (int i = 0; goodMatch && i < n; i++) {

              Field f1 = domains[i];

              Field f2 = tMembers[i] as Field;

              goodMatch = f1 != null && f2 != null && f1.Type == f2.Type && 

              f1.Name != null && f2.Name != null && f1.Name.UniqueIdKey == f2.Name.UniqueIdKey;

            }

          }

        }

        if (goodMatch) return tup;

        //Mangle some more

        tName = Identifier.For(tNameString+(++tCount).ToString());

        result = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      }

      tup = new TupleType(domains, tName, referringType, visibility);

      return tup;

    }

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        MemberList members = this.Members;

        for (int i = 0, n = members == null ? 0 : members.Count; i < n; i++){

          Field f = members[i] as Field;

          if (f == null || f.Type == null) continue;

          result.Add(f.Type);

        }

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      TupleType t = type as TupleType;

      if (t == null) return false;

      if (this.Members == null) return t.Members == null;

      if (t.Members == null) return false;

      int n = this.Members.Count; if (n != t.Members.Count) return false;

      for (int i = 0; i < n; i++){

        Member m1 = this.Members[i];

        Member m2 = t.Members[i];

        if (m1 == null || m2 == null) return false;

        Field f1 = m1 as Field;

        Field f2 = m2 as Field;

        if (f1 == null && f2 == null) continue;

        if (f1 == null || f2 == null) return false;

        if (f1.Name == null || f2.Name == null) return false;

        if (f1.Type == null || f2.Type == null) return false;

        if (f1.Name.UniqueIdKey != f2.Name.UniqueIdKey) return false;

        if (f1.Type != f2.Type && !f1.Type.IsStructurallyEquivalentTo(f2.Type)) return false;

      }

      return true;

    }

  }

  internal sealed class TupleEnumerator{

    private TupleEnumerator(){}

    internal static TypeNode/*!*/ For(TupleType/*!*/ tuple, int numDomains, TypeNode/*!*/ elementType, Interface/*!*/ targetIEnumerator, TypeNode/*!*/ referringType) {

      Identifier id = Identifier.For("Enumerator"+tuple.Name);

      InterfaceList interfaces = new InterfaceList(targetIEnumerator, SystemTypes.IDisposable, SystemTypes.IEnumerator);

      MemberList members = new MemberList(5);

      Class enumerator = new Class(referringType.DeclaringModule, null, null, TypeFlags.Sealed, targetIEnumerator.Namespace, id, CoreSystemTypes.Object, interfaces, members);

      enumerator.IsNormalized = true;

      if ((tuple.Flags & TypeFlags.VisibilityMask) == TypeFlags.Public){

        enumerator.Flags |= TypeFlags.Public;

        referringType.DeclaringModule.Types.Add(enumerator);

      }else{

        enumerator.Flags |= TypeFlags.NestedPrivate;

        referringType.Members.Add(enumerator);

        enumerator.DeclaringType = referringType;

      }

      //Field to hold tuple

      Field tField = new Field(enumerator, null, FieldFlags.Private, StandardIds.Value, tuple, null);

      members.Add(tField);

      //Field to hold current position

      Field pField = new Field(enumerator, null, FieldFlags.Private, StandardIds.Position, CoreSystemTypes.Int32, null);

      members.Add(pField);

      //Constructor

      Parameter par = new Parameter(null, ParameterFlags.None, StandardIds.Value, tuple, null, null);

      StatementList statements = new StatementList(4);

      InstanceInitializer constr = CoreSystemTypes.Object.GetConstructor();

      if (constr == null) { Debug.Fail(""); return enumerator; }

      This thisParameter = new This(enumerator);

      MethodCall mcall = new MethodCall(new MemberBinding(thisParameter, constr), new ExpressionList(0), NodeType.Call, CoreSystemTypes.Void);

      statements.Add(new ExpressionStatement(mcall));

      statements.Add(new AssignmentStatement(new MemberBinding(thisParameter, tField), par));

      statements.Add(new AssignmentStatement(new MemberBinding(thisParameter, pField), Literal.Int32MinusOne));

      statements.Add(new Return());

      InstanceInitializer econs = new InstanceInitializer(enumerator, null, new ParameterList(par), new Block(statements));

      econs.ThisParameter = thisParameter;

      econs.Flags |= MethodFlags.Public;

      members.Add(econs);

      //get_Current

      thisParameter = new This(enumerator);

      statements = new StatementList(numDomains+1);

      BlockList blocks = new BlockList(numDomains);

      statements.Add(new SwitchInstruction(new MemberBinding(thisParameter, pField), blocks));

      constr = SystemTypes.InvalidOperationException.GetConstructor();

      if (constr == null) { Debug.Fail(""); return enumerator; }

      statements.Add(new Throw(new Construct(new MemberBinding(null, constr), null)));

      for (int i = 0; i < numDomains; i++){

        Field f = (Field)tuple.members[i];

        MemberBinding mb = new MemberBinding(new UnaryExpression(new MemberBinding(thisParameter, tField), NodeType.AddressOf), f);

        Block b = new Block();

        statements.Add(b);

        blocks.Add(b);

        if (f.Type == elementType || f.Type == null)

          b.Statements = new StatementList(new Return(mb));

        else{

          TypeUnion tUnion = elementType as TypeUnion;

          Debug.Assert(tUnion != null);

          if (tUnion != null){

            Method m = tUnion.GetImplicitCoercionFromMethod(f.Type);

            if (m != null){

              MethodCall mCall = new MethodCall(new MemberBinding(null, m), new ExpressionList(mb));

              b.Statements = new StatementList(new Return(mCall));

            }else{

              TypeUnion eUnion = f.Type as TypeUnion;

              if (eUnion != null){

                Method getTagAsType = eUnion.GetMethod(StandardIds.GetTagAsType);

                Method getValue = eUnion.GetMethod(StandardIds.GetValue);

                Method fromObject = tUnion.GetMethod(StandardIds.FromObject, CoreSystemTypes.Object, CoreSystemTypes.Type);

                if (getTagAsType == null || getValue == null || fromObject == null) {

                  Debug.Fail(""); return enumerator;

                }

                Local temp = new Local(Identifier.Empty, eUnion);

                Expression tempAddr = new UnaryExpression(temp, NodeType.AddressOf);

                StatementList stats = new StatementList(2);

                stats.Add(new AssignmentStatement(temp, mb));

                ExpressionList arguments = new ExpressionList(2);

                arguments.Add(new MethodCall(new MemberBinding(tempAddr, getValue), null));

                arguments.Add(new MethodCall(new MemberBinding(tempAddr, getTagAsType), null));

                stats.Add(new Return(new MethodCall(new MemberBinding(null, fromObject), arguments)));

                b.Statements = stats;

              }else{

                Debug.Assert(false);

              }

            }

          }

        }

      }

      Method getCurrent = new Method(enumerator, null, StandardIds.getCurrent, null, elementType, new Block(statements));

      getCurrent.Flags = MethodFlags.Public|MethodFlags.Virtual|MethodFlags.NewSlot|MethodFlags.HideBySig|MethodFlags.SpecialName;

      getCurrent.CallingConvention = CallingConventionFlags.HasThis;

      getCurrent.ThisParameter = thisParameter;

      members.Add(getCurrent);



      //IEnumerator.GetCurrent

      statements = new StatementList(1);

      This ThisParameter = new This(enumerator);

      MethodCall callGetCurrent = new MethodCall(new MemberBinding(ThisParameter, getCurrent), new ExpressionList(0), NodeType.Call, elementType); 

      MemberBinding etExpr = new MemberBinding(null, elementType);

      statements.Add(new Return(new BinaryExpression(callGetCurrent, etExpr, NodeType.Box, CoreSystemTypes.Object)));

      Method ieGetCurrent = new Method(enumerator, null, StandardIds.IEnumeratorGetCurrent, null, CoreSystemTypes.Object, new Block(statements));

      ieGetCurrent.ThisParameter = ThisParameter;

      ieGetCurrent.ImplementedInterfaceMethods = new MethodList(SystemTypes.IEnumerator.GetMethod(StandardIds.getCurrent));

      ieGetCurrent.CallingConvention = CallingConventionFlags.HasThis;

      ieGetCurrent.Flags = MethodFlags.Private|MethodFlags.Virtual|MethodFlags.SpecialName;

      members.Add(ieGetCurrent);



      //IEnumerator.Reset

      statements = new StatementList(2);

      ThisParameter = new This(enumerator);

      statements.Add(new AssignmentStatement(new MemberBinding(ThisParameter, pField), Literal.Int32Zero));

      statements.Add(new Return());

      Method reset = new Method(enumerator, null, StandardIds.IEnumeratorReset, null, CoreSystemTypes.Void, new Block(statements));

      reset.ThisParameter = ThisParameter;

      reset.ImplementedInterfaceMethods = new MethodList(SystemTypes.IEnumerator.GetMethod(StandardIds.Reset));

      reset.CallingConvention = CallingConventionFlags.HasThis;

      reset.Flags = MethodFlags.Private|MethodFlags.Virtual|MethodFlags.SpecialName;

      members.Add(reset);



      //MoveNext

      ThisParameter = new This(enumerator);

      statements = new StatementList(5);

      MemberBinding pos = new MemberBinding(ThisParameter, pField);

      Expression comparison = new BinaryExpression(pos, new Literal(numDomains, CoreSystemTypes.Int32), NodeType.Lt);

      Block returnTrue = new Block();

      statements.Add(new AssignmentStatement(pos, new BinaryExpression(pos, Literal.Int32One, NodeType.Add)));

      statements.Add(new Branch(comparison, returnTrue));

      statements.Add(new Return(Literal.False));

      statements.Add(returnTrue);

      statements.Add(new Return(Literal.True));

      Method moveNext = new Method(enumerator, null, StandardIds.MoveNext, null, CoreSystemTypes.Boolean, new Block(statements));

      moveNext.Flags = MethodFlags.Public|MethodFlags.Virtual|MethodFlags.NewSlot|MethodFlags.HideBySig;

      moveNext.CallingConvention = CallingConventionFlags.HasThis;

      moveNext.ThisParameter = ThisParameter;

      members.Add(moveNext);

      //IDispose.Dispose

      statements = new StatementList(1);

      statements.Add(new Return());

      Method dispose = new Method(enumerator, null, StandardIds.Dispose, null, CoreSystemTypes.Void, new Block(statements));

      dispose.CallingConvention = CallingConventionFlags.HasThis;

      dispose.Flags = MethodFlags.Public|MethodFlags.Virtual;

      enumerator.Members.Add(dispose);

      return enumerator;

    }

  }

  public class TypeAlias : Struct{

    protected TypeNode aliasedType;

    public TypeNode AliasedTypeExpression;

    public bool RequireExplicitCoercionFromUnderlyingType;

    public TypeAlias()

      : this(null, null){

    }

    internal TypeAlias(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle, bool requireExplicitCoercionFromUnderlyingType)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.RequireExplicitCoercionFromUnderlyingType = requireExplicitCoercionFromUnderlyingType;

    }

    public TypeAlias(TypeNode aliasedType, Identifier name)

      : base(){

      this.NodeType = NodeType.TypeAlias;

      this.AliasedType = aliasedType;

      this.Name = name;

    }

    public TypeNode AliasedType{

      get{

        if (this.aliasedType == null){

          Field f = this.GetField(StandardIds.Value);

          if (f != null)

            this.aliasedType = f.Type;

        }

        return this.aliasedType;

      }

      set{

        this.aliasedType = value;

      }

    }

    public virtual void ProvideMembers(){

      if (this.AliasedType == null) return;

      this.Interfaces = new InterfaceList(1);

      if (this.RequireExplicitCoercionFromUnderlyingType)

        this.Interfaces.Add(SystemTypes.TypeDefinition);

      else

        this.Interfaces.Add(SystemTypes.TypeAlias);

      MemberList members = this.members;

      if (members == null) members = this.members = new MemberList();

      //Value field

      Field valueField = new Field(this, null, FieldFlags.Private, StandardIds.Value, this.AliasedType, null);

      members.Add(valueField);

      //Implicit conversion from this type to underlying type

      ParameterList parameters = new ParameterList(1);

      Parameter valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, this, null, null);

      parameters.Add(valuePar);

      Method toAliasedType = new Method(this, null, StandardIds.opImplicit, parameters, this.AliasedType, null); 

      toAliasedType.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

      members.Add(toAliasedType);

      StatementList statements = new StatementList(1);

      statements.Add(new Return(new MemberBinding(new UnaryExpression(valuePar, NodeType.AddressOf), valueField)));

      toAliasedType.Body = new Block(statements);

      //Implicit or explicit conversion from underlying type to this type

      Identifier opId = this.RequireExplicitCoercionFromUnderlyingType ? StandardIds.opExplicit : StandardIds.opImplicit;

      parameters = new ParameterList(1);

      parameters.Add(valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, this.AliasedType, null, null));

      Method fromAliasedType = new Method(this, null, opId, parameters, this, null); 

      fromAliasedType.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

      members.Add(fromAliasedType);

      statements = new StatementList(2);

      Local loc = new Local(this);

      statements.Add(new AssignmentStatement(new MemberBinding(new UnaryExpression(loc, NodeType.AddressOf), valueField), valuePar));

      statements.Add(new Return(loc));

      fromAliasedType.Body = new Block(statements);

      this.AddCoercionWrappers(this.AliasedType.ExplicitCoercionMethods, StandardIds.opExplicit, fromAliasedType, toAliasedType);

      this.AddCoercionWrappers(this.AliasedType.ImplicitCoercionMethods, StandardIds.opImplicit, fromAliasedType, toAliasedType);

    }

    private void AddCoercionWrappers(MemberList coercions, Identifier id, Method/*!*/ fromAliasedType, Method/*!*/ toAliasedType) 

      //^ requires this.members != null;

    {

      if (coercions == null) return;

      MemberList members = this.members;

      for (int i = 0, n = coercions.Count; i < n; i++){

        Method coercion = coercions[i] as Method;

        if (coercion == null || coercion.Parameters == null || coercion.Parameters.Count != 1) continue;

        ParameterList parameters = new ParameterList(1);

        Parameter valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, null, null, null);

        parameters.Add(valuePar);

        Method m = new Method(this, null, id, parameters, null, null);

        m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

        Expression arg = valuePar;

        MethodCall call = new MethodCall(new MemberBinding(null, coercion), new ExpressionList(arg));

        if (coercion.ReturnType == this.AliasedType){

          m.ReturnType = this;

          if (this.RequireExplicitCoercionFromUnderlyingType) m.Name = StandardIds.opExplicit;

          valuePar.Type = coercion.Parameters[0].Type;

          call = new MethodCall(new MemberBinding(null, fromAliasedType), new ExpressionList(call));

        }else{

          m.ReturnType = coercion.ReturnType;

          valuePar.Type = this;

          //^ assume call.Operands != null;

          call.Operands[0] = new MethodCall(new MemberBinding(null, toAliasedType), new ExpressionList(arg));

        }

        m.Body = new Block(new StatementList(new Return(call)));

        members.Add(m);

      }

    }

    public override bool IsStructural{

      get{return this.RequireExplicitCoercionFromUnderlyingType;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        result.Add(this.AliasedType);

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      if (this.RequireExplicitCoercionFromUnderlyingType) return false;

      TypeAlias t = type as TypeAlias;

      if (t == null) return false;

      if (t.RequireExplicitCoercionFromUnderlyingType) return false;

      if (this.AliasedType == null || t.AliasedType == null) return false;

      return this.AliasedType == t.AliasedType || this.AliasedType.IsStructurallyEquivalentTo(t.AliasedType);

    }

  }

  public class TypeIntersection : Struct{

    private TypeNodeList types; //sorted by UniqueKey

    public TypeNodeList Types{

      get{

        if (this.types != null) return this.types;

        if (this.ProvideTypeMembers != null) { MemberList mems = this.Members; if (mems != null) mems = null; }

        return this.types;          

      }

      set{

        this.types = value;

      }

    }



    private TypeIntersection(TypeNodeList types, Identifier name) {

      this.NodeType = NodeType.TypeIntersection;

      this.Flags = TypeFlags.Public|TypeFlags.Sealed;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = name;

      this.Types = types;

      int n = types == null ? 0 : types.Count;

      InterfaceList ifaces = this.Interfaces = new InterfaceList(n+1);

      ifaces.Add(SystemTypes.TypeIntersection);

      if (types != null)

        for (int i = 0; i < n; i++){

          Interface iface = types[i] as Interface;

          if (iface == null) continue;

          ifaces.Add(iface);

        }

      this.isNormalized = true;

    }

    internal TypeIntersection(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.NodeType = NodeType.TypeIntersection;

      this.typeCode = ElementType.ValueType;

    }

    public static TypeIntersection For(TypeNodeList types, Module module) {

      if (module == null) return null;   

      if (types != null && !TypeUnion.AreNormalized(types))   

        types = TypeUnion.Normalize(types);

      TypeFlags visibility = TypeFlags.Public;

      string name = TypeUnion.BuildName(types, "And", ref visibility);

      Identifier tName = Identifier.For(name);

      int tCount = 0;

      TypeIntersection result = null;

      TypeNode t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      while (t != null){

        //Mangled name is the same. But mangling is not unique, so check for equality.

        TypeIntersection ti = t as TypeIntersection;

        if (ti != null){

          TypeNodeList ts = ti.Types;

          int n = types == null ? 0 : types.Count;

          bool goodMatch = ts != null && ts.Count == n;

          for (int i = 0; goodMatch && i < n; i++) {

            //^ assert types != null && ts != null;

            goodMatch = types[i] == ts[i];

          }

          if (goodMatch) return ti;

        }

        //Mangle some more

        tName = Identifier.For(name+(++tCount).ToString());

        t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      }

      result = new TypeIntersection(types, tName);

      result.DeclaringModule = module;

      module.Types.Add(result);

      module.StructurallyEquivalentType[tName.UniqueIdKey] = result;

      return result;

    }

    public static TypeIntersection For(TypeNodeList types, TypeNode referringType) {

      if (referringType == null) return null;

      Module module = referringType.DeclaringModule;

      if (module == null) return null;   

      if (types != null && !TypeUnion.AreNormalized(types))   

        types = TypeUnion.Normalize(types);

      TypeFlags visibility = TypeFlags.Public;

      string name = TypeUnion.BuildName(types, "And", ref visibility);

      Identifier tName = Identifier.For(name);

      int tCount = 0;

      TypeIntersection result = null;

      TypeNode t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      while (t != null){

        //Mangled name is the same. But mangling is not unique, so check for equality.

        TypeIntersection ti = t as TypeIntersection;

        if (ti != null){

          TypeNodeList ts = ti.Types;

          int n = types == null ? 0 : types.Count;

          bool goodMatch = ts != null && ts.Count == n;

          for (int i = 0; goodMatch && i < n; i++) {

            //^ assert ts != null && types != null;

            goodMatch = types[i] == ts[i];

          }

          if (goodMatch) return ti;

        }

        //Mangle some more

        tName = Identifier.For(name+(++tCount).ToString());

        t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      }

      result = new TypeIntersection(types, tName);

      result.DeclaringModule = module;

      switch (visibility){

        case TypeFlags.NestedFamANDAssem:

        case TypeFlags.NestedFamily:

        case TypeFlags.NestedPrivate:

          referringType.Members.Add(result);

          result.DeclaringType = referringType;

          result.Flags &= ~TypeFlags.VisibilityMask;

          result.Flags |= TypeFlags.NestedPrivate;

          break;

        default:

          module.Types.Add(result);

          break;

      }

      module.StructurallyEquivalentType[tName.UniqueIdKey] = result;

      return result;

    }   

    public override bool IsAssignableTo(TypeNode targetType){

      return targetType == this || targetType == CoreSystemTypes.Object;

    } 

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        TypeNodeList types = this.Types;

        for (int i = 0, n = types == null ? 0 : types.Count; i < n; i++){

          TypeNode t = types[i]; 

          if (t == null) continue;

          result.Add(t);

        }

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      TypeIntersection t = type as TypeIntersection;

      if (t == null) return false;

      return this.IsStructurallyEquivalentList(this.Types, t.Types);

    }

    private TrivialHashtable/*!*/ interfaceMethodFor = new TrivialHashtable();

    public override MemberList Members{

      get{

        MemberList members = this.members;

        if (members == null || this.membersBeingPopulated){

          if (this.ProvideTypeMembers != null){

            lock(this){

              if (this.members != null) return this.members;

              members = base.Members;

              MemberList coercions = this.ExplicitCoercionMethods;

              int n = coercions == null ? 0 : coercions.Count;

              TypeNodeList typeList = this.Types = new TypeNodeList(n);

              for (int i = 0; i < n; i++){

                Method coercion = coercions[i] as Method;

                if (coercion == null) continue;

                typeList.Add(coercion.ReturnType);

              }

            }

            return this.members;

          }

          members = this.Members = new MemberList();

          //Value field

          members.Add(new Field(this, null, FieldFlags.Private, StandardIds.Value, CoreSystemTypes.Object, null));

          //FromObject

          ParameterList parameters = new ParameterList(1);

          parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, CoreSystemTypes.Object, null, null));

          Method m = new Method(this, null, StandardIds.FromObject, parameters, this, null); 

          m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

          members.Add(m);

          //coercion operators

          parameters = new ParameterList(1);

          parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, CoreSystemTypes.Object, null, null));

          m = new Method(this, null, StandardIds.opExplicit, parameters, this, null); 

          m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

          members.Add(m);

          parameters = new ParameterList(1);

          parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, this, null, null));

          m = new Method(this, null, StandardIds.opImplicit, parameters, CoreSystemTypes.Object, null); 

          m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

          members.Add(m);

          TypeNodeList types = this.Types;

          for (int i = 0, n = types.Count; i < n; i++){

            TypeNode t = types[i];

            parameters = new ParameterList(1);

            parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, this, null, null));

            m = new Method(this, null, StandardIds.opImplicit, parameters, t, null); 

            m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

            members.Add(m);

          }

          //Routines to forward interface calls to embedded object

          InterfaceList ifaces = this.Interfaces;

          if (ifaces != null){

            for (int i = 0, n = ifaces.Count; i < n; i++){

              Interface iface = ifaces[i];

              if (iface == null) continue;

              MemberList imembers = iface.Members;

              if (imembers == null) continue;

              for (int j = 0, k = imembers.Count; j < k; j++){

                Method imeth = imembers[j] as Method;

                if (imeth == null) continue;

                if (imeth.IsStatic) continue;

                Method meth = (Method)imeth.Clone();

                meth.Flags &= ~MethodFlags.Abstract;

                meth.DeclaringType = this;

                members.Add(meth);

                meth.Parameters = (imeth.Parameters == null ? null : imeth.Parameters.Clone());

                for (int a = 0, b = meth.Parameters == null ? 0 : meth.Parameters.Count; a < b; a++){

                  Parameter par = meth.Parameters[a];

                  if (par == null) continue;

                  meth.Parameters[a] = par = (Parameter)par.Clone();

                  par.DeclaringMethod = meth;

                }

                this.interfaceMethodFor[meth.UniqueKey] = imeth;

              }

            }

          }

          this.ProvideBodiesForMethods();

        }

        return members;

      }

      set{

        this.members = value;

      }

    }

    private void ProvideBodiesForMethods()

      //^ requires this.members != null;

    {

      MemberList members = this.members;

      Field valueField = (Field)members[0];

      //FromObject

      Method fromObject = (Method)members[1];

      StatementList statements = new StatementList(2);

      Local resultLoc = new Local(Identifier.Empty, this);

      Expression param = fromObject.Parameters[0];

      statements.Add(new AssignmentStatement(new MemberBinding(new UnaryExpression(resultLoc, NodeType.AddressOf), valueField), param));

      statements.Add(new Return(resultLoc));

      fromObject.Body = new Block(statements);

      //to coercion

      Method toMethod = (Method)members[2];

      statements = new StatementList(2);

      resultLoc = new Local(Identifier.Empty, this);

      param = toMethod.Parameters[0];

      Expression castExpr = param;

      TypeNodeList types = this.Types;

      int n = types.Count;

      for (int i = 0; i < n; i++){

        TypeNode t = types[i];

        castExpr = new BinaryExpression(castExpr, new Literal(t, CoreSystemTypes.Type), NodeType.Castclass);

      }

      statements.Add(new AssignmentStatement(new MemberBinding(new UnaryExpression(resultLoc, NodeType.AddressOf), valueField), castExpr));

      statements.Add(new Return(resultLoc));

      toMethod.Body = new Block(statements);

      //from coercions

      Method opImplicit = (Method)members[3];

      opImplicit.Body = new Block(statements = new StatementList(1));

      Expression val = new MemberBinding(new UnaryExpression(opImplicit.Parameters[0], NodeType.AddressOf), valueField);

      statements.Add(new Return(val));

      for (int i = 0; i < n; i++){

        TypeNode t = types[i];

        opImplicit = (Method)members[4+i];

        opImplicit.Body = new Block(statements = new StatementList(1));

        val = new MemberBinding(new UnaryExpression(opImplicit.Parameters[0], NodeType.AddressOf), valueField);

        val = new BinaryExpression(val, new Literal(t, CoreSystemTypes.Type), NodeType.Castclass);

        statements.Add(new Return(val));

      }

      //Routines to forward interface calls to embedded object

      for (int i = 4+n, m = members.Count; i < m; i++){

        Method meth = (Method)members[i];

        Method imeth = (Method)this.interfaceMethodFor[meth.UniqueKey];

        Interface iface = (Interface)imeth.DeclaringType;

        statements = new StatementList(2);

        ParameterList parameters = meth.Parameters;

        int k = parameters == null ? 0 : parameters.Count;

        ExpressionList arguments = new ExpressionList(k);

        if (parameters != null)

          for (int j = 0; j < k; j++) arguments.Add(parameters[j]);

        Expression obj = new BinaryExpression(new MemberBinding(meth.ThisParameter, valueField), new Literal(iface, CoreSystemTypes.Type), NodeType.Castclass);

        MethodCall mcall = new MethodCall(new MemberBinding(obj, imeth), arguments, NodeType.Callvirt);

        mcall.Type = imeth.ReturnType;

        statements.Add(new ExpressionStatement(mcall));

        statements.Add(new Return());

        meth.Body = new Block(statements);

      }

    }

  }

  public class TypeUnion : Struct{

    private TypeNodeList types; //sorted by UniqueKey

    public TypeNodeList Types{

      get{

        if (this.types != null) return this.types;

        if (this.ProvideTypeMembers != null) { MemberList mems = this.Members; if (mems != null) mems = null; }

        return this.types;          

      }

      set{

        this.types = value;

      }

    }



    private TypeUnion(TypeNodeList types, Identifier tName){

      this.NodeType = NodeType.TypeUnion;

      this.Flags = TypeFlags.Public|TypeFlags.Sealed;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = tName;

      this.Types = types;

      this.Interfaces = new InterfaceList(SystemTypes.TypeUnion);

      this.isNormalized = true;

    }

    internal TypeUnion(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.NodeType = NodeType.TypeUnion;

      this.typeCode = ElementType.ValueType;

    }



    internal static string/*!*/ BuildName(TypeNodeList types, string separator, ref TypeFlags visibility) {

      int n = types == null ? 0 : types.Count;

      if (n == 0) return "EmtpyUnion";

      StringBuilder sb = new StringBuilder();

      if (types != null)

        for (int i = 0; i < n; i++){

          TypeNode t = types[i];

          if (t == null) continue;

          visibility = TypeNode.GetVisibilityIntersection(visibility, t.Flags & TypeFlags.VisibilityMask);

          sb.Append(t.Name.ToString());

          if (i < n-1) sb.Append(separator);

        }

      return sb.ToString();

    }

    public static bool AreNormalized(TypeNodeList/*!*/ types) {

      int id = 0;

      for (int i = 0, n = types.Count; i < n; i++){

        TypeNode type = types[i];

        if (type == null) continue;

        if (type.UniqueKey <= id || type is TypeUnion) return false;

        id = type.UniqueKey;

      }

      return true;

    }

    public static TypeNodeList/*!*/ Normalize(TypeNodeList/*!*/ types) {

      if (types.Count == 0) return types;

      Hashtable ht = new Hashtable();

      for (int i = 0, n = types.Count; i < n; i++){

        TypeNode type = types[i];

        if (type == null) continue; // error already reported.

        TypeUnion tu = type as TypeUnion;

        if (tu != null){

          for (int ti = 0, tn = tu.Types.Count; ti < tn; ti++){

            type = tu.Types[ti];

            ht[type.UniqueKey] = type;

          }

        }else{

          ht[type.UniqueKey] = type;

        }

      }

      SortedList list = new SortedList(ht);

      TypeNodeList result = new TypeNodeList(list.Count);

      foreach (TypeNode t in list.Values)

        result.Add(t);

      return result;

    }

    public static TypeUnion For(TypeNodeList types, Module module) {

      if (module == null) return null;   

      if (types != null && !TypeUnion.AreNormalized(types))   

        types = TypeUnion.Normalize(types);

      TypeFlags visibility = TypeFlags.Public;

      string name = TypeUnion.BuildName(types, "Or", ref visibility);

      Identifier tName = Identifier.For(name);

      int tCount = 0;

      TypeUnion result = null;

      TypeNode t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      while (t != null){

        //Mangled name is the same. But mangling is not unique, so check for equality.

        TypeUnion tu = t as TypeUnion;

        if (tu != null){

          TypeNodeList ts = tu.Types;

          int n = types == null ? 0 : types.Count;

          bool goodMatch = ts != null && ts.Count == n;

          for (int i = 0; goodMatch && i < n; i++) {

            //^ assert types != null && ts != null;

            goodMatch = types[i] == ts[i];

          }

          if (goodMatch) return tu;

        }

        //Mangle some more

        tName = Identifier.For(name+(++tCount).ToString());

        t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      }

      result = new TypeUnion(types, tName);

      result.DeclaringModule = module;

      module.Types.Add(result);

      module.StructurallyEquivalentType[tName.UniqueIdKey] = result;

      return result;

    }

    public static TypeUnion For(TypeNodeList/*!*/ types, TypeNode/*!*/ referringType) {

      Module module = referringType.DeclaringModule;

      if (module == null) return null;

      if (!TypeUnion.AreNormalized(types))   

        types = TypeUnion.Normalize(types);

      TypeFlags visibility = TypeFlags.Public;

      string name = TypeUnion.BuildName(types, "Or", ref visibility);

      Identifier tName = Identifier.For(name);

      int tCount = 0;

      TypeUnion result = null;

      TypeNode t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      while (t != null){

        //Mangled name is the same. But mangling is not unique, so check for equality.

        TypeUnion tu = t as TypeUnion;

        if (tu != null){

          TypeNodeList ts = tu.Types;

          int n = types.Count;

          bool goodMatch = ts != null && ts.Count == n;

          for (int i = 0; goodMatch && i < n; i++) {

            //^ assert ts != null;

            goodMatch = types[i] == ts[i];

          }

          if (goodMatch) return tu;

        }

        //Mangle some more

        tName = Identifier.For(name+(++tCount).ToString());

        t = module.GetStructurallyEquivalentType(StandardIds.StructuralTypes, tName);

      }

      result = new TypeUnion(types, tName);

      result.DeclaringModule = module;

      switch (visibility){

        case TypeFlags.NestedFamANDAssem:

        case TypeFlags.NestedFamily:

        case TypeFlags.NestedPrivate:

          referringType.Members.Add(result);

          result.DeclaringType = referringType;

          result.Flags &= ~TypeFlags.VisibilityMask;

          result.Flags |= TypeFlags.NestedPrivate;

          break;

        default:

          module.Types.Add(result);

          break;

      }

      module.StructurallyEquivalentType[tName.UniqueIdKey] = result;

      return result;

    }    

    public override bool IsAssignableTo(TypeNode targetType){

      return targetType == this || targetType == CoreSystemTypes.Object;

    }

    public override bool IsStructural{

      get{return true;}

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      TypeUnion t = type as TypeUnion;

      if (t == null) return false;

      return this.IsStructurallyEquivalentList(this.Types, t.Types);

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        TypeNodeList types = this.Types;

        for (int i = 0, n = types == null ? 0 : types.Count; i < n; i++){

          TypeNode t = types[i]; 

          if (t == null) continue;

          result.Add(t);

        }

        return result;

      }

    }

    protected TypeUnion unlabeledUnion = null;

    public virtual TypeUnion UnlabeledUnion{

      get{

        TypeUnion result = this.unlabeledUnion;

        if (result != null) return result;

        if (this.Types == null) return this.unlabeledUnion = this;

        TypeNodeList types = this.Types.Clone();

        bool noChange = true;

        for (int i = 0, n = types.Count; i < n; i++){

          TupleType tup = types[i] as TupleType;

          if (tup != null && tup.Members != null && tup.Members.Count == 3 && tup.Members[0] is Field){

            types[i] = ((Field)tup.Members[0]).Type;

            noChange = false;

          }

        }

        if (noChange) 

          return this.unlabeledUnion = this;

        else

          return this.unlabeledUnion = new TypeUnion(types, Identifier.Empty);

      }

    }

    public override MemberList Members{

      get{

        MemberList members = this.members;

        if (members == null || this.membersBeingPopulated){

          if (this.ProvideTypeMembers != null){

            lock(this){

              if (this.members != null) return this.members;

              members = base.Members;

              MemberList coercions = this.ExplicitCoercionMethods;

              int n = coercions == null ? 0 : coercions.Count;

              TypeNodeList typeList = this.Types = new TypeNodeList(n);

              for (int i = 0; i < n; i++){

                Method coercion = coercions[i] as Method;

                if (coercion == null) continue;

                typeList.Add(coercion.ReturnType);

              }

              return this.members;

            }

          }

          members = this.Members = new MemberList();

          //Value field

          members.Add(new Field(this, null, FieldFlags.Private, StandardIds.Value, CoreSystemTypes.Object, null));

          //Tag field

          members.Add(new Field(this, null, FieldFlags.Private, StandardIds.Tag, CoreSystemTypes.UInt32, null));

          //GetValue method (used to convert from subtype to supertype via FromObject on the superType)

          ParameterList parameters = new ParameterList(0);

          Method m = new Method(this, null, StandardIds.GetValue, parameters, CoreSystemTypes.Object, null);

          m.Flags = MethodFlags.SpecialName|MethodFlags.Public; m.CallingConvention = CallingConventionFlags.HasThis;

          members.Add(m);

          //GetTag method (used in typeswitch)

          parameters = new ParameterList(0);

          m = new Method(this, null, StandardIds.GetTag, parameters, CoreSystemTypes.UInt32, null);

          m.Flags = MethodFlags.SpecialName|MethodFlags.Public; m.CallingConvention = CallingConventionFlags.HasThis;

          members.Add(m);

          //GetTagAsType method (used to convert from subtype to supertype via FromObject on the superType)

          parameters = new ParameterList(0);

          m = new Method(this, null, StandardIds.GetTagAsType, parameters, CoreSystemTypes.Type, null);

          m.Flags = MethodFlags.SpecialName|MethodFlags.Public; m.CallingConvention = CallingConventionFlags.HasThis;

          members.Add(m);

          //GetType

          parameters = new ParameterList(0);

          m = new Method(this, null, StandardIds.GetType, parameters, CoreSystemTypes.Type, null);

          m.Flags = MethodFlags.Public; m.CallingConvention = CallingConventionFlags.HasThis;

          members.Add(m);

          //FromObject

          parameters = new ParameterList(2);

          parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, CoreSystemTypes.Object, null, null));

          parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.TagType, CoreSystemTypes.Type, null, null));

          m = new Method(this, null, StandardIds.FromObject, parameters, this, null); 

          m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

          members.Add(m);

          //coercion operators

          TypeNodeList types = this.Types;

          for (int i = 0, n = types.Count; i < n; i++){

            TypeNode t = types[i];

            parameters = new ParameterList(1);

            parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, t, null, null));

            m = new Method(this, null, StandardIds.opImplicit, parameters, this, null); 

            m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

            members.Add(m);

            parameters = new ParameterList(1);

            parameters.Add(new Parameter(null, ParameterFlags.None, StandardIds.Value, this, null, null));

            m = new Method(this, null, StandardIds.opExplicit, parameters, t, null); 

            m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

            members.Add(m);

          }

          this.ProvideBodiesForMethods();

        }

        return members;

      }

      set{

        this.members = value;

      }

    }

    public void ProvideBodiesForMethods(){

      Method objectGetType = CoreSystemTypes.Object.GetMethod(StandardIds.GetType);

      Method typeGetTypeFromHandle = (Method)CoreSystemTypes.Type.GetMembersNamed(Identifier.For("GetTypeFromHandle"))[0];

      Method typeGetTypeHandle = (Method)CoreSystemTypes.Type.GetMembersNamed(Identifier.For("get_TypeHandle"))[0];

      Method runtimeTypeHandleGetValue = (Method)CoreSystemTypes.RuntimeTypeHandle.GetMembersNamed(Identifier.For("get_Value"))[0];

      if (objectGetType == null || typeGetTypeFromHandle == null || typeGetTypeHandle == null || runtimeTypeHandleGetValue == null) {

        Debug.Fail(""); return;

      }

      MemberList members = this.members;

      if (members == null) return;

      Field valueField = (Field)members[0];

      Field tagField = (Field)members[1];

      //GetValue

      Method getValueMethod = (Method)members[2];

      StatementList statements = new StatementList(1);

      statements.Add(new Return(new MemberBinding(getValueMethod.ThisParameter, valueField)));

      getValueMethod.Body = new Block(statements);

      //GetTag

      Method getTagMethod = (Method)members[3];

      statements = new StatementList(1);

      statements.Add(new Return(new MemberBinding(getTagMethod.ThisParameter, tagField)));

      getTagMethod.Body = new Block(statements);

      //GetTagAsType

      Method getTagAsTypeMethod = (Method)members[4];

      TypeNodeList types = this.Types;

      int n = types.Count;

      Block returnBlock = new Block();

      statements = new StatementList(n+4);

      getTagAsTypeMethod.Body = new Block(statements);

      BlockList targets = new BlockList(n);

      SwitchInstruction sw = new SwitchInstruction(new MemberBinding(getTagAsTypeMethod.ThisParameter, tagField), targets);

      statements.Add(sw);

      //TODO: throw an exception

      statements.Add(new ExpressionStatement(new UnaryExpression(new Literal(CoreSystemTypes.Object, CoreSystemTypes.Type), NodeType.Ldtoken))); 

      statements.Add(returnBlock);

      for (int i = 0; i < n; i++){

        TypeNode t = types[i];

        StatementList ldToken = new StatementList(2);

        ldToken.Add(new ExpressionStatement(new UnaryExpression(new Literal(t, CoreSystemTypes.Type), NodeType.Ldtoken)));

        ldToken.Add(new Branch(null, returnBlock));

        Block ldtokBlock = new Block(ldToken);

        targets.Add(ldtokBlock);

        statements.Add(ldtokBlock);

      }

      statements = returnBlock.Statements = new StatementList(1);

      statements.Add(new Return(new MethodCall(new MemberBinding(null, typeGetTypeFromHandle), null)));

      //GetType

      Method getTypeMethod = (Method)members[5];

      statements = new StatementList(4);

      getTypeMethod.Body = new Block(statements);

      MemberBinding mb = new MemberBinding(getTypeMethod.ThisParameter, valueField);

      Local loc = new Local(CoreSystemTypes.Object);

      statements.Add(new AssignmentStatement(loc, mb));

      Block callGetTagAsType = new Block();

      statements.Add(new Branch(new UnaryExpression(loc, NodeType.LogicalNot), callGetTagAsType));

      statements.Add(new Return(new MethodCall(new MemberBinding(loc, objectGetType), null)));

      statements.Add(callGetTagAsType);

      statements.Add(new Return(new MethodCall(new MemberBinding(getTypeMethod.ThisParameter, getTagAsTypeMethod), null)));

      //FromObject

      Method fromObjectMethod = (Method)members[6];

      fromObjectMethod.InitLocals = true;

      statements = new StatementList(n+8); //TODO: get the right expression

      fromObjectMethod.Body = new Block(statements);

      MethodCall getTypeHandle = new MethodCall(new MemberBinding(fromObjectMethod.Parameters[1], typeGetTypeHandle), null, NodeType.Callvirt);

      Local handle = new Local(Identifier.Empty, CoreSystemTypes.RuntimeTypeHandle);

      statements.Add(new AssignmentStatement(handle, getTypeHandle));

      MethodCall getValue = new MethodCall(new MemberBinding(new UnaryExpression(handle, NodeType.AddressOf), runtimeTypeHandleGetValue), null);

      getValue.Type = CoreSystemTypes.UIntPtr; 

      statements.Add(new ExpressionStatement(getValue));

      Local temp = new Local(Identifier.Empty, CoreSystemTypes.UInt32);

      Local result = new Local(Identifier.Empty, this);

      Expression dup = new Expression(NodeType.Dup);

      Block next = new Block();

      Block curr = new Block();

      Block setTag = new Block();

      for (int i = 0; i < n; i++){

        TypeNode t = types[i];

        StatementList stats = curr.Statements = new StatementList(4);

        UnaryExpression ldtok = new UnaryExpression(new Literal(t, CoreSystemTypes.Type), NodeType.Ldtoken);

        stats.Add(new AssignmentStatement(handle, ldtok));

        getValue = new MethodCall(new MemberBinding(new UnaryExpression(handle, NodeType.AddressOf), runtimeTypeHandleGetValue), null);

        Expression compare = new BinaryExpression(dup, getValue, NodeType.Eq);

        stats.Add(new Branch(compare, next));

        stats.Add(new AssignmentStatement(temp, new Literal(i, CoreSystemTypes.UInt32)));

        if (i < n-1)

          stats.Add(new Branch(null, setTag));

        statements.Add(curr);

        curr = next;

        next = new Block();

      }

      statements.Add(curr);

      statements.Add(setTag);

      statements.Add(new ExpressionStatement(new UnaryExpression(null, NodeType.Pop)));

      Expression resultAddr = new UnaryExpression(result, NodeType.AddressOf);

      statements.Add(new AssignmentStatement(new MemberBinding(resultAddr, tagField), temp));

      statements.Add(new AssignmentStatement(new MemberBinding(resultAddr, valueField), fromObjectMethod.Parameters[0]));

      statements.Add(new Return(result));

      for (int i = 0; i < n; i++){

        TypeNode t = types[i];

        if (t == null) continue;

        bool isValueType = t.IsValueType;

        MemberBinding tExpr = new MemberBinding(null, t);

        Method opImplicit = (Method)members[7+i*2];

        opImplicit.Body = new Block(statements = new StatementList(3));

        statements.Add(new AssignmentStatement(new MemberBinding(resultAddr, tagField), new Literal(i, CoreSystemTypes.UInt32)));

        Parameter p0 = opImplicit.Parameters[0];

        p0.Type = t;

        Expression val = p0;

        if (isValueType) val = new BinaryExpression(val, tExpr, NodeType.Box, CoreSystemTypes.Object);

        statements.Add(new AssignmentStatement(new MemberBinding(resultAddr, valueField), val));

        statements.Add(new Return(result));

        Method opExplicit = (Method)members[8+i*2];

        opExplicit.ReturnType = t;

        opExplicit.Body = new Block(statements = new StatementList(1));

        Expression loadValue = new MemberBinding(new UnaryExpression(opExplicit.Parameters[0], NodeType.AddressOf), valueField);

        if (isValueType)

          val = new AddressDereference(new BinaryExpression(loadValue, tExpr, NodeType.Unbox), t);

        else

          val = new BinaryExpression(loadValue, tExpr, NodeType.Castclass);

        statements.Add(new Return(val));

      }

    }

  }

  /// <summary>

  /// Bundles a type with a boolean expression. The bundle is a subtype of the given type.

  /// The class is a struct with a single private field of the given type and implicit coercions to and from the underlying type.

  /// The to coercion checks that the constraint is satisfied and throws ArgumentOutOfRangeException if not.

  /// </summary>

  public class ConstrainedType : Struct{

    protected TypeNode underlyingType;

    public TypeNode UnderlyingTypeExpression;

    public Expression Constraint;

    public ConstrainedType(TypeNode/*!*/ underlyingType, Expression/*!*/ constraint) {

      this.NodeType = NodeType.ConstrainedType;

      this.underlyingType = underlyingType;

      this.Flags = TypeFlags.Public|TypeFlags.Sealed|TypeFlags.SpecialName;

      this.Constraint = constraint;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = Identifier.For("Constrained type:"+base.UniqueKey);

      this.Interfaces = new InterfaceList(SystemTypes.ConstrainedType);

    }

    public ConstrainedType(TypeNode/*!*/ underlyingType, Expression/*!*/ constraint, TypeNode/*!*/ declaringType) {

      this.NodeType = NodeType.ConstrainedType;

      this.underlyingType = underlyingType;

      this.Flags = TypeFlags.NestedPublic|TypeFlags.Sealed|TypeFlags.SpecialName;

      this.Constraint = constraint;

      this.Namespace = StandardIds.StructuralTypes;

      this.Name = Identifier.For("Constrained type:"+base.UniqueKey);

      this.Interfaces = new InterfaceList(SystemTypes.ConstrainedType);

      this.DeclaringType = declaringType;

      this.DeclaringModule = declaringType.DeclaringModule;

      declaringType.Members.Add(this);

    }

    internal ConstrainedType(NestedTypeProvider provideNestedTypes, TypeAttributeProvider provideAttributes, TypeMemberProvider provideMembers, object handle)

      : base(provideNestedTypes, provideAttributes, provideMembers, handle) {

      this.NodeType = NodeType.ConstrainedType;

      this.typeCode = ElementType.ValueType;

    }

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(1);

        result.Add(this.UnderlyingType);

        return result;

      }

    }

    public virtual void ProvideMembers(){

      MemberList members = this.members = new MemberList();

      //Value field

      Field valueField = new Field(this, null, FieldFlags.Assembly, StandardIds.Value, this.underlyingType, null);

      members.Add(valueField);

      //Implicit conversion from this type to underlying type

      ParameterList parameters = new ParameterList(1);

      Parameter valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, this, null, null);

      parameters.Add(valuePar);

      Method toUnderlying = new Method(this, null, StandardIds.opImplicit, parameters, this.underlyingType, null); 

      toUnderlying.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

      members.Add(toUnderlying);

      //Implicit conversion from underlying type to this type

      parameters = new ParameterList(1);

      parameters.Add(valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, this.underlyingType, null, null));

      Method fromUnderlying = new Method(this, null, StandardIds.opImplicit, parameters, this, null); 

      fromUnderlying.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

      members.Add(fromUnderlying);

      this.AddCoercionWrappers(this.UnderlyingType.ExplicitCoercionMethods, StandardIds.opExplicit, fromUnderlying, toUnderlying);

      this.AddCoercionWrappers(this.UnderlyingType.ImplicitCoercionMethods, StandardIds.opImplicit, fromUnderlying, toUnderlying);

    }

    private void AddCoercionWrappers(MemberList/*!*/ coercions, Identifier/*!*/ id, Method/*!*/ fromUnderlying, Method/*!*/ toUnderlying) {

      MemberList members = this.members;

      for (int i = 0, n = coercions.Count; i < n; i++){

        Method coercion = coercions[i] as Method;

        if (coercion == null || coercion.Parameters == null || coercion.Parameters.Count != 1) continue;

        ParameterList parameters = new ParameterList(1);

        Parameter valuePar = new Parameter(null, ParameterFlags.None, StandardIds.Value, null, null, null);

        parameters.Add(valuePar);

        Method m = new Method(this, null, id, parameters, null, null);

        m.Flags = MethodFlags.Static|MethodFlags.SpecialName|MethodFlags.Public;

        Expression arg = valuePar;

        MethodCall call = new MethodCall(new MemberBinding(null, coercion), new ExpressionList(arg));

        if (coercion.ReturnType == this.UnderlyingType){

          m.ReturnType = this;

          valuePar.Type = coercion.Parameters[0].Type;

          call = new MethodCall(new MemberBinding(null, fromUnderlying), new ExpressionList(call));

        }else{

          m.ReturnType = coercion.ReturnType;

          valuePar.Type = this;

          call.Operands[0] = new MethodCall(new MemberBinding(null, toUnderlying), new ExpressionList(arg));

        }

        m.Body = new Block(new StatementList(new Return(call)));

        members.Add(m);

      }

    }

    public void ProvideBodiesForMethods(){

      MemberList members = this.members;

      if (members == null) return;

      Field valueField = (Field)members[0];

      //Implicit conversion from this type to underlying type

      Method toUnderlying = (Method)members[1];

      Parameter valuePar = toUnderlying.Parameters[0];

      StatementList statements = new StatementList(1);

      statements.Add(new Return(new MemberBinding(new UnaryExpression(valuePar, NodeType.AddressOf), valueField)));

      toUnderlying.Body = new Block(statements);

      //Implicit conversion from underlying type to this type

      Method fromUnderlying = (Method)members[2];

      valuePar = fromUnderlying.Parameters[0];

      statements = new StatementList(4);

      fromUnderlying.Body = new Block(statements);

      Block succeed = new Block();

      Local temp = new Local(Identifier.Empty, this);

      statements.Add(new Branch(this.Constraint, succeed));

      InstanceInitializer constr = SystemTypes.ArgumentOutOfRangeException.GetConstructor();

      if (constr == null) { Debug.Fail(""); return; }

      MemberBinding argException = new MemberBinding(null, constr);

      statements.Add(new Throw(new Construct(argException, null)));

      statements.Add(succeed);

      statements.Add(new AssignmentStatement(new MemberBinding(new UnaryExpression(temp, NodeType.AddressOf), valueField), valuePar));

      statements.Add(new Return(temp));

    }

    public TypeNode UnderlyingType{

      get{

        TypeNode underlyingType = this.underlyingType;

        if (underlyingType == null){

          Field f = this.GetField(StandardIds.Value);

          if (f != null)

            this.underlyingType = underlyingType = f.Type;

        }

        return underlyingType;

      }

      set{

        this.underlyingType = value;

      }

    }

  }

#endif

  public abstract class TypeModifier : TypeNode{

    private TypeNode/*!*/ modifier;

    private TypeNode/*!*/ modifiedType;

#if !MinimalReader

    public TypeNode ModifierExpression;

    public TypeNode ModifiedTypeExpression;

#endif

    internal TypeModifier(NodeType type, TypeNode/*!*/ modifier, TypeNode/*!*/ modified)

      : base(type){

      this.modifier = modifier;

      this.modifiedType = modified;

      this.DeclaringModule = modified.DeclaringModule;

      this.Namespace = modified.Namespace;

      if (type == NodeType.OptionalModifier){

        this.typeCode = ElementType.OptionalModifier;

        this.Name = Identifier.For("optional("+modifier.Name+") "+modified.Name);

        this.fullName = "optional("+modifier.FullName+") "+modified.FullName;

      }else{

        this.typeCode = ElementType.RequiredModifier;

        this.Name = Identifier.For("required("+modifier.Name+") "+modified.Name);

        this.fullName = "required("+modifier.FullName+") "+modified.FullName;

      }

      this.Flags = modified.Flags;

    }

    public TypeNode/*!*/ Modifier {

      get{return this.modifier;}

      set{this.modifier = value;}

    }

    public TypeNode/*!*/ ModifiedType {

      get{return this.modifiedType;}

      set{this.modifiedType = value;}

    }

    public override Node/*!*/ Clone(){

      Debug.Assert(false);

      return base.Clone();

    }

    public override string GetFullUnmangledNameWithoutTypeParameters() {

      return this.ModifiedType.GetFullUnmangledNameWithoutTypeParameters();

    }

    public override string GetFullUnmangledNameWithTypeParameters() {

      return this.ModifiedType.GetFullUnmangledNameWithTypeParameters();

    }

    public override string/*!*/ GetUnmangledNameWithoutTypeParameters() {

      return this.ModifiedType.GetUnmangledNameWithoutTypeParameters();

    }

    public override bool IsUnmanaged {

      get{return this.ModifiedType.IsUnmanaged;}

    }

    public override bool IsStructural

    {

      get{return true;}

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      if (this.NodeType != type.NodeType) return false;

      TypeModifier t = type as TypeModifier;

      if (t == null){Debug.Assert(false); return false;}

      if (this.Modifier != t.Modifier && (this.Modifier == null || !this.Modifier.IsStructurallyEquivalentTo(t.Modifier)))

        return false;

      if (this.ModifiedType != t.ModifiedType && (this.ModifiedType == null || !this.ModifiedType.IsStructurallyEquivalentTo(t.ModifiedType)))

        return false;

      return true;

    }

    public override bool IsValueType {

      get {

        return this.ModifiedType.IsValueType;

      }

    }



    public override bool IsPointerType {

      get {

        return this.ModifiedType.IsPointerType;

      }

    }



#if ExtendedRuntime

    public override bool IsPointerFree

    {

      get { return this.ModifiedType.IsPointerFree; }

    }

    public override bool IsReferenceType

    {

      get {

        return this.ModifiedType.IsReferenceType;

      }

    }

#endif



    public override bool IsTemplateParameter {

      get {

        return this.ModifiedType.IsTemplateParameter;

      }

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList(2);

        result.Add(this.ModifiedType);

        result.Add(this.Modifier);

        return result;

      }

    }

#if FxCop

    internal override void GetName(TypeFormat options, StringBuilder name)

    {

      if (options.ShowTypeModifiers)

      {

        base.GetName(options, name);

        return;

      }

      this.modifiedType.GetName(options, name);

    }

#endif

  }

  public class OptionalModifier : TypeModifier{

    internal OptionalModifier(TypeNode/*!*/ modifier, TypeNode/*!*/ modified)

      : base(NodeType.OptionalModifier, modifier, modified){

    }

    public static OptionalModifier For(TypeNode modifier, TypeNode modified) {

      if (modified == null || modifier == null) return null;

      return (OptionalModifier)modified.GetModified(modifier, true);

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      this.ModifiedType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

      sb.Append('!');

      this.Modifier.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

    }

#endif

  }

  public class RequiredModifier : TypeModifier{

    internal RequiredModifier(TypeNode/*!*/ modifier, TypeNode/*!*/ modified)

      : base(NodeType.RequiredModifier, modifier, modified){

    }

    public static RequiredModifier/*!*/ For(TypeNode/*!*/ modifier, TypeNode/*!*/ modified) {

      return (RequiredModifier)modified.GetModified(modifier, false);

    }

#if !NoXml

    internal override void AppendDocumentIdMangledName(StringBuilder/*!*/ sb, TypeNodeList methodTypeParameters, TypeNodeList typeParameters) {

      this.ModifiedType.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

      sb.Append('|');

      this.Modifier.AppendDocumentIdMangledName(sb, methodTypeParameters, typeParameters);

    }

#endif

  }

#if !MinimalReader

  public class OptionalModifierTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ModifiedType;

    public TypeNode Modifier;



    public OptionalModifierTypeExpression(TypeNode elementType, TypeNode modifier)

      : base(NodeType.OptionalModifierTypeExpression){

      this.ModifiedType = elementType;

      this.Modifier = modifier;

    }

    public OptionalModifierTypeExpression(TypeNode elementType, TypeNode modifier, SourceContext sctx)

      : this(elementType, modifier){

      this.SourceContext = sctx;

    }

    /// <summary>

    /// Only needed because IsUnmanaged test is performed in the Looker rather than checker. Once the test

    /// is moved, this code can be removed.

    /// </summary>

    public override bool IsUnmanaged {

      get {

        return this.ModifiedType == null ? false : this.ModifiedType.IsUnmanaged;

      }

    }



  }

  public class RequiredModifierTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ModifiedType;

    public TypeNode Modifier;



    public RequiredModifierTypeExpression(TypeNode elementType, TypeNode modifier)

      : base(NodeType.RequiredModifierTypeExpression){

      this.ModifiedType = elementType;

      this.Modifier = modifier;

    }

    public RequiredModifierTypeExpression(TypeNode elementType, TypeNode modifier, SourceContext sctx)

      : this(elementType, modifier){

      this.SourceContext = sctx;

    }

    /// <summary>

    /// Can be removed once the Unmanaged check moves from Looker to Checker.

    /// </summary>

    public override bool IsUnmanaged {

      get {

        return this.ModifiedType == null ? false : this.ModifiedType.IsUnmanaged;

      }

    }



  }

#endif  

  public class FunctionPointer : TypeNode{

    internal FunctionPointer(TypeNodeList parameterTypes, TypeNode/*!*/ returnType, Identifier name)

      : base(NodeType.FunctionPointer){

      this.Name = name;

      this.Namespace = returnType.Namespace;

      this.parameterTypes = parameterTypes;

      this.returnType = returnType;

      this.typeCode = ElementType.FunctionPointer;

      this.varArgStart = int.MaxValue;

    }

    private CallingConventionFlags callingConvention;

    public CallingConventionFlags CallingConvention{

      get{return this.callingConvention;}

      set{this.callingConvention = value;}

    }

    private TypeNodeList parameterTypes;

    public TypeNodeList ParameterTypes{

      get{return this.parameterTypes;}

      set{this.parameterTypes = value;}

    }

    private TypeNode returnType;

    public TypeNode ReturnType{

      get{return this.returnType;}

      set{this.returnType = value;}

    }

    private int varArgStart;

    public int VarArgStart{

      get{return this.varArgStart;}

      set{this.varArgStart = value;}

    }

    public override bool IsStatic{

      get{return (this.CallingConvention & CallingConventionFlags.HasThis) == 0;}

    }

    public override bool IsStructural{

      get{return true;}

    }

    protected TypeNodeList structuralElementTypes;

    public override TypeNodeList StructuralElementTypes{

      get{

        TypeNodeList result = this.structuralElementTypes;

        if (result != null) return result;

        this.structuralElementTypes = result = new TypeNodeList();

        result.Add(this.ReturnType);

        TypeNodeList ptypes = this.ParameterTypes;

        for (int i = 0, n = ptypes == null ? 0 : ptypes.Count; i < n; i++){

          TypeNode ptype = ptypes[i]; 

          if (ptype == null) continue;

          result.Add(ptype);

        }

        return result;

      }

    }

    public override bool IsStructurallyEquivalentTo(TypeNode type){

      if (type == null) return false;

      if (this == type) return true;

      FunctionPointer t = type as FunctionPointer;

      if (t == null) return false;

      if (this.Flags != t.Flags || this.CallingConvention != t.CallingConvention || this.VarArgStart != t.VarArgStart) return false;

      if (this.ReturnType == null || t.ReturnType == null) return false;

      if (this.ReturnType != t.ReturnType && !this.ReturnType.IsStructurallyEquivalentTo(t.ReturnType)) return false;

      return this.IsStructurallyEquivalentList(this.ParameterTypes, t.ParameterTypes);

    }

    public static FunctionPointer/*!*/ For(TypeNodeList/*!*/ parameterTypes, TypeNode/*!*/ returnType) {

      Module mod = returnType.DeclaringModule;

      if (mod == null) { Debug.Fail(""); mod = new Module(); }

      StringBuilder sb = new StringBuilder("function pointer ");

      sb.Append(returnType.FullName);

      sb.Append('(');

      for (int i = 0, n = parameterTypes == null ? 0 : parameterTypes.Count; i < n; i++){

        TypeNode type = parameterTypes[i];

        if (type == null) continue;

        if (i != 0) sb.Append(',');

        sb.Append(type.FullName);

      }

      sb.Append(')');

      Identifier name = Identifier.For(sb.ToString());

      TypeNode t = mod.GetStructurallyEquivalentType(returnType.Namespace, name);

      int counter = 1;

      while (t != null){

        FunctionPointer fp = t as FunctionPointer;

        if (fp != null){

          if (fp.ReturnType == returnType && FunctionPointer.ParameterTypesAreEquivalent(fp.ParameterTypes, parameterTypes))

            return fp;

        }

        name = Identifier.For(name.ToString()+counter++);

        t = mod.GetStructurallyEquivalentType(returnType.Namespace, name);

      }

      FunctionPointer result = t as FunctionPointer;

      if (result == null){

        result = new FunctionPointer(parameterTypes, returnType, name);

        result.DeclaringModule = mod;

        mod.StructurallyEquivalentType[name.UniqueIdKey] = result;

      }

      return result;      

    }

    private static bool ParameterTypesAreEquivalent(TypeNodeList list1, TypeNodeList list2){

      if (list1 == null || list2 == null) return list1 == list2;

      int n = list1.Count;

      if (n != list2.Count) return false;

      for (int i = 0; i < n; i++)

        if (list1[i] != list2[i]) return false;

      return true;

    }

  }

  public interface ISymbolicTypeReference{

  }

#if !MinimalReader

  public class ArrayTypeExpression : ArrayType, ISymbolicTypeReference{

    //TODO: add expressions for elementType, rank, sizes and lowerbounds

    public bool LowerBoundIsUnknown;

    public ArrayTypeExpression()

      : base(){

      this.NodeType = NodeType.ArrayTypeExpression;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank)

      : base(elementType, rank){

      this.NodeType = NodeType.ArrayTypeExpression;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank, int[] sizes)

      : base(elementType, rank, sizes){

      this.NodeType = NodeType.ArrayTypeExpression;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank, int[] sizes, int[] lowerBounds)

      : base(elementType, rank, sizes, sizes){

      this.NodeType = NodeType.ArrayTypeExpression;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank, SourceContext sctx)

      : base(elementType, rank){

      this.NodeType = NodeType.ArrayTypeExpression;

      this.SourceContext = sctx;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank, int[] sizes, SourceContext sctx)

      : base(elementType, rank, sizes){

      this.NodeType = NodeType.ArrayTypeExpression;

      this.SourceContext = sctx;

    }

    public ArrayTypeExpression(TypeNode/*!*/ elementType, int rank, int[] sizes, int[] lowerBounds, SourceContext sctx)

      : base(elementType, rank, sizes, sizes){

      this.NodeType = NodeType.ArrayTypeExpression;

      this.SourceContext = sctx;

    }

  }

  public class ClassExpression : Class, ISymbolicTypeReference{

    public Expression Expression;



    public ClassExpression(Expression expression){

      this.NodeType = NodeType.ClassExpression;

      this.Expression = expression;

    }

    public ClassExpression(Expression expression, TypeNodeList templateArguments){

      this.NodeType = NodeType.ClassExpression;

      this.Expression = expression;

      this.TemplateArguments = templateArguments;

      if (templateArguments != null) this.TemplateArgumentExpressions = templateArguments.Clone();

    }

    public ClassExpression(Expression expression, SourceContext sctx){

      this.NodeType = NodeType.ClassExpression;

      this.Expression = expression;

      this.SourceContext = sctx;

    }

    public ClassExpression(Expression expression, TypeNodeList templateArguments, SourceContext sctx) {

      this.NodeType = NodeType.ClassExpression;

      this.Expression = expression;

      this.TemplateArguments = this.TemplateArgumentExpressions = templateArguments;

      if (templateArguments != null) this.TemplateArgumentExpressions = templateArguments.Clone();

      this.SourceContext = sctx;

    }

  }

#endif

  public class InterfaceExpression : Interface, ISymbolicTypeReference{

    private Expression expression;

    public InterfaceExpression(Expression expression)

      : base(null){

      this.NodeType = NodeType.InterfaceExpression;

      this.Expression = expression;

    }

#if !MinimalReader

    public InterfaceExpression(Expression expression, SourceContext sctx)

      : base(null){

      this.NodeType = NodeType.InterfaceExpression;

      this.Expression = expression;

      this.SourceContext = sctx;

    }

#endif

    public Expression Expression{

      get{return this.expression;}

      set{this.expression = value;}

    }

  }

#if !MinimalReader

  public class FlexArrayTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public FlexArrayTypeExpression(TypeNode elementType)

      : base(NodeType.FlexArrayTypeExpression){

      this.ElementType = elementType;

    }

    public FlexArrayTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.FlexArrayTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class FunctionTypeExpression : TypeNode, ISymbolicTypeReference{

    public ParameterList Parameters;

    public TypeNode ReturnType;

    public FunctionTypeExpression(TypeNode returnType, ParameterList parameters)

      : base(NodeType.FunctionTypeExpression){

      this.ReturnType = returnType;

      this.Parameters = parameters;

    }

    public FunctionTypeExpression(TypeNode returnType, ParameterList parameters, SourceContext sctx)

      : base(NodeType.FunctionTypeExpression){

      this.ReturnType = returnType;

      this.Parameters = parameters;

      this.SourceContext = sctx;

    }

  }

  public class PointerTypeExpression : Pointer, ISymbolicTypeReference{

    public PointerTypeExpression(TypeNode/*!*/ elementType)

      : base(elementType){

      this.NodeType = NodeType.PointerTypeExpression;

    }

    public PointerTypeExpression(TypeNode/*!*/ elementType, SourceContext sctx)

      : base(elementType){

      this.NodeType = NodeType.PointerTypeExpression;

      this.SourceContext = sctx;

    }

    /// <summary>

    /// This is only needed because the Unmanaged test is done in the Looker rather than the checker.

    /// (Once the check moves, this can be removed).

    /// </summary>

    public override bool IsUnmanaged {

      get {

        return true;

      }

    }



  }

  public class ReferenceTypeExpression : Reference, ISymbolicTypeReference{

    public ReferenceTypeExpression(TypeNode/*!*/ elementType)

      : base(elementType){

      this.NodeType = NodeType.ReferenceTypeExpression;

    }

    public ReferenceTypeExpression(TypeNode/*!*/ elementType, SourceContext sctx)

      : base(elementType){

      this.NodeType = NodeType.ReferenceTypeExpression;

      this.SourceContext = sctx;

    }

  }

  public class StreamTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public StreamTypeExpression(TypeNode elementType)

      : base(NodeType.StreamTypeExpression){

      this.ElementType = elementType;

    }

    public StreamTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.StreamTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class NonEmptyStreamTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public NonEmptyStreamTypeExpression(TypeNode elementType)

      : base(NodeType.NonEmptyStreamTypeExpression){

      this.ElementType = elementType;

    }

    public NonEmptyStreamTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.NonEmptyStreamTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class BoxedTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public BoxedTypeExpression(TypeNode elementType)

      : base(NodeType.BoxedTypeExpression){

      this.ElementType = elementType;

    }

    public BoxedTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.BoxedTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class InvariantTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public InvariantTypeExpression(TypeNode elementType)

      : base(NodeType.InvariantTypeExpression){

      this.ElementType = elementType;

    }

    public InvariantTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.InvariantTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class NonNullTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public NonNullTypeExpression(TypeNode elementType)

      : base(NodeType.NonNullTypeExpression){

      this.ElementType = elementType;

    }

    public NonNullTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.NonNullTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class NonNullableTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public NonNullableTypeExpression(TypeNode elementType)

      : base(NodeType.NonNullableTypeExpression){

      this.ElementType = elementType;

    }

    public NonNullableTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.NonNullableTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class NullableTypeExpression : TypeNode, ISymbolicTypeReference{

    public TypeNode ElementType;

    public NullableTypeExpression(TypeNode elementType)

      : base(NodeType.NullableTypeExpression){

      this.ElementType = elementType;

    }

    public NullableTypeExpression(TypeNode elementType, SourceContext sctx)

      : base(NodeType.NullableTypeExpression){

      this.ElementType = elementType;

      this.SourceContext = sctx;

    }

  }

  public class TupleTypeExpression : TypeNode, ISymbolicTypeReference{

    public FieldList Domains;

    public TupleTypeExpression(FieldList domains)

      : base(NodeType.TupleTypeExpression){

      this.Domains = domains;

    }

    public TupleTypeExpression(FieldList domains, SourceContext sctx)

      : base(NodeType.TupleTypeExpression){

      this.Domains = domains;

      this.SourceContext = sctx;

    }

  }

  public class TypeIntersectionExpression: TypeNode, ISymbolicTypeReference{

    public TypeNodeList Types;

    public TypeIntersectionExpression(TypeNodeList types)

      : base(NodeType.TypeIntersectionExpression){

      this.Types = types;

    }

    public TypeIntersectionExpression(TypeNodeList types, SourceContext sctx)

      : base(NodeType.TypeIntersectionExpression){

      this.Types = types;

      this.SourceContext = sctx;

    }

  }

  public class TypeUnionExpression: TypeNode, ISymbolicTypeReference{

    public TypeNodeList Types;

    public TypeUnionExpression(TypeNodeList types)

      : base(NodeType.TypeUnionExpression){

      this.Types = types;

    }

    public TypeUnionExpression(TypeNodeList types, SourceContext sctx)

      : base(NodeType.TypeUnionExpression){

      this.Types = types;

      this.SourceContext = sctx;

    }

  }

  public class TypeExpression : TypeNode, ISymbolicTypeReference{

    public Expression Expression;

    public int Arity;



    public TypeExpression(Expression expression)

      : base(NodeType.TypeExpression){

      this.Expression = expression;

    }

    public TypeExpression(Expression expression, TypeNodeList templateArguments)

      : base(NodeType.TypeExpression){

      this.Expression = expression;

      this.templateArguments = this.TemplateArgumentExpressions = templateArguments;

    }

    public TypeExpression(Expression expression, int arity)

      : base(NodeType.TypeExpression) {

      this.Expression = expression;

      this.Arity = arity;

    }

    public TypeExpression(Expression expression, SourceContext sctx)

      : base(NodeType.TypeExpression){

      this.Expression = expression;

      this.SourceContext = sctx;

    }

    public TypeExpression(Expression expression, TypeNodeList templateArguments, SourceContext sctx)

      : base(NodeType.TypeExpression){

      this.Expression = expression;

      this.templateArguments = this.TemplateArgumentExpressions = templateArguments;

      this.SourceContext = sctx;

    }

    public TypeExpression(Expression expression, int arity, SourceContext sctx)

      : base(NodeType.TypeExpression) {

      this.Expression = expression;

      this.Arity = arity;

      this.SourceContext = sctx;

    }

    public override bool IsUnmanaged {

      get{

        Literal lit = this.Expression as Literal;

        if (lit != null){

          TypeNode t = lit.Value as TypeNode;

          if (t != null) return t.IsUnmanaged;

          if (lit.Value is TypeCode) return true;

        }

        return true;

      }

    }

  }

  public class TypeReference : Node {

    public TypeNode Type;

    public TypeNode Expression;



    public TypeReference(TypeNode typeExpression)

      : base(NodeType.TypeReference){

      this.Expression = typeExpression;

      if (typeExpression != null)

        this.SourceContext = typeExpression.SourceContext;

    }

    public TypeReference(TypeNode typeExpression, TypeNode type)

      : base(NodeType.TypeReference){

      this.Expression = typeExpression;

      this.Type = type;

      if (typeExpression != null)

        this.SourceContext = typeExpression.SourceContext;

    }

    public static explicit operator TypeNode(TypeReference typeReference){

      return null == (object)typeReference ? null : typeReference.Type;

    }

    public static bool operator==(TypeReference typeReference, TypeNode type){

      return null == (object)typeReference ? null == (object)type : typeReference.Type == type;

    }

    public static bool operator==(TypeNode type, TypeReference typeReference){

      return null == (object)typeReference ? null == (object)type : typeReference.Type == type;

    }

    public static bool operator!=(TypeReference typeReference, TypeNode type){

      return null == (object)typeReference ? null != (object)type : typeReference.Type != type;

    }

    public static bool operator!=(TypeNode type, TypeReference typeReference){

      return null == (object)typeReference ? null != (object)type : typeReference.Type != type;

    }

    public override bool Equals(object obj){

      return obj == (object)this || obj == (object)this.Type;

    }

    public override int GetHashCode(){

      return base.GetHashCode();

    }

  }

  public class ArglistArgumentExpression : NaryExpression {

    public ArglistArgumentExpression(ExpressionList args, SourceContext sctx) : base(args, NodeType.ArglistArgumentExpression) {

      this.SourceContext = sctx;

    }

  }

  public class ArglistExpression : Expression {

    public ArglistExpression(SourceContext sctx) : base(NodeType.ArglistExpression) {

      this.SourceContext = sctx;

    }

  }

  public class RefValueExpression : BinaryExpression {

    public RefValueExpression(Expression typedreference, Expression type, SourceContext sctx) 

      : base(typedreference, type, NodeType.RefValueExpression){

      this.SourceContext = sctx;

    }



  }

  public class RefTypeExpression : UnaryExpression {

    public RefTypeExpression(Expression typedreference, SourceContext sctx) 

      : base(typedreference, NodeType.RefTypeExpression){

      this.SourceContext = sctx;

    }



  }

#endif

#if ExtendedRuntime

  public delegate Expression Coercer(Expression source, TypeNode targetType, TypeViewer typeViewer);

  public sealed class StreamAdapter{

    private StreamAdapter(){}

    public static TypeNode For(Interface/*!*/ sourceStream, Interface/*!*/ targetStream, Module/*!*/ module, Coercer/*!*/ coercer, SourceContext sctx) {

      return StreamAdapter.For(sourceStream, targetStream, null, module, coercer, sctx);

    }

    public static TypeNode For(Interface /*!*/sourceStream, Interface/*!*/ targetStream, TypeNode/*!*/ referringType, Coercer/*!*/ coercer, SourceContext sctx) {

      if (referringType == null){Debug.Assert(false); return null;}

      return StreamAdapter.For(sourceStream, targetStream, referringType, referringType.DeclaringModule, coercer, sctx);

    }

    public static TypeNode For(Interface/*!*/ sourceStream, Interface/*!*/ targetStream, TypeNode referringType, Module/*!*/ module, Coercer/*!*/ coercer, SourceContext sctx) {

      Debug.Assert(sourceStream.Template == SystemTypes.GenericIEnumerable && targetStream.Template == SystemTypes.GenericIEnumerable);

      Identifier id = Identifier.For("AdapterFor" + sourceStream.Name + "To" + targetStream.Name);

      for (int i = 1; ;i++){

        TypeNode t = module.GetStructurallyEquivalentType(targetStream.Namespace, id);

        if (t == null) break;

        if (t.IsAssignableTo(targetStream)){

          InstanceInitializer cons = t.GetConstructor(sourceStream);

          if (cons != null) return t;

        }

        id = Identifier.For(id.ToString()+i);

      }

      Method sGetEnumerator = sourceStream.GetMethod(StandardIds.GetEnumerator);

      Method tGetEnumerator = targetStream.GetMethod(StandardIds.GetEnumerator);

      if (sGetEnumerator == null || tGetEnumerator == null) { Debug.Fail(""); return null; }

      Interface sGetEnumeratorReturnType = (Interface)TypeNode.StripModifiers(sGetEnumerator.ReturnType);

      Interface tGetEnumeratorReturnType = (Interface)TypeNode.StripModifiers(tGetEnumerator.ReturnType);

      //^ assert sGetEnumeratorReturnType != null && tGetEnumeratorReturnType != null;

      TypeNode enumeratorAdapter = null;

      if (referringType != null)

        enumeratorAdapter = EnumeratorAdapter.For(id, sGetEnumeratorReturnType, tGetEnumeratorReturnType, referringType, coercer, sctx);

      else

        enumeratorAdapter = EnumeratorAdapter.For(id, sGetEnumeratorReturnType, tGetEnumeratorReturnType, module, coercer, sctx);

      if (enumeratorAdapter == null) return null;

      InterfaceList interfaces = new InterfaceList(targetStream);

      MemberList members = new MemberList(3);

      Class adapter = new Class(module, null, null, TypeFlags.Sealed, targetStream.Namespace, id, CoreSystemTypes.Object, interfaces, members);

      adapter.IsNormalized = true;

      if (referringType == null ||

      (sourceStream.Flags & TypeFlags.VisibilityMask) == TypeFlags.Public && (targetStream.Flags & TypeFlags.VisibilityMask) == TypeFlags.Public){

        adapter.Flags |= TypeFlags.Public;

        module.Types.Add(adapter);

      }else{

        adapter.Flags |= TypeFlags.NestedPrivate;

        referringType.Members.Add(adapter);

        adapter.DeclaringType = referringType;

      }

      module.StructurallyEquivalentType[id.UniqueIdKey] = adapter;



      //Field to hold source stream

      Field ssField = new Field(adapter, null, FieldFlags.Private, StandardIds.Value, sourceStream, null);

      members.Add(ssField);



      //Constructor

      This ThisParameter = new This(adapter);

      Parameter par = new Parameter(null, ParameterFlags.None, StandardIds.Value, sourceStream, null, null);

      StatementList statements = new StatementList(3);

      InstanceInitializer cstr = CoreSystemTypes.Object.GetConstructor();

      if (cstr == null) { Debug.Fail(""); return adapter; }

      MethodCall mcall = new MethodCall(new MemberBinding(ThisParameter, cstr), new ExpressionList(0), NodeType.Call, CoreSystemTypes.Void);

      statements.Add(new ExpressionStatement(mcall));

      statements.Add(new AssignmentStatement(new MemberBinding(ThisParameter, ssField), par));

      statements.Add(new Return());

      InstanceInitializer acons = new InstanceInitializer(adapter, null, new ParameterList(par), new Block(statements));

      acons.Flags |= MethodFlags.Public;

      acons.ThisParameter = ThisParameter;

      members.Add(acons);



      //GetEnumerator

      ThisParameter = new This(adapter);

      statements = new StatementList(1);

      mcall = new MethodCall(new MemberBinding(new MemberBinding(ThisParameter, ssField), sGetEnumerator),

        new ExpressionList(0), NodeType.Callvirt, sGetEnumerator.ReturnType);

      cstr = enumeratorAdapter.GetConstructor(sGetEnumerator.ReturnType);

      if (cstr == null) { Debug.Fail(""); return adapter; }

      Construct constr = new Construct(new MemberBinding(null, cstr), new ExpressionList(mcall));

      statements.Add(new Return(constr));

      Method getEnumerator = new Method(adapter, null, StandardIds.GetEnumerator, null, tGetEnumerator.ReturnType, new Block(statements));

      getEnumerator.Flags = MethodFlags.Public | MethodFlags.Virtual | MethodFlags.NewSlot | MethodFlags.HideBySig;

      getEnumerator.CallingConvention = CallingConventionFlags.HasThis;

      getEnumerator.ThisParameter = ThisParameter;

      members.Add(getEnumerator);



      //IEnumerable.GetEnumerator

      Method ieGetEnumerator = SystemTypes.IEnumerable.GetMethod(StandardIds.GetEnumerator);

      if (ieGetEnumerator == null) { Debug.Fail(""); return adapter; }

      ThisParameter = new This(adapter);

      statements = new StatementList(1);

      mcall = new MethodCall(new MemberBinding(new MemberBinding(ThisParameter, ssField), ieGetEnumerator),

        new ExpressionList(0), NodeType.Callvirt, SystemTypes.IEnumerator);

      statements.Add(new Return(mcall));

      getEnumerator = new Method(adapter, null, StandardIds.IEnumerableGetEnumerator, null, SystemTypes.IEnumerator, new Block(statements));

      getEnumerator.ThisParameter = ThisParameter;

      getEnumerator.ImplementedInterfaceMethods = new MethodList(ieGetEnumerator);

      getEnumerator.CallingConvention = CallingConventionFlags.HasThis;

      getEnumerator.Flags = MethodFlags.Private | MethodFlags.Virtual | MethodFlags.SpecialName;

      members.Add(getEnumerator);



      return adapter;

    }

  }

  internal sealed class EnumeratorAdapter{

    private EnumeratorAdapter(){}

    internal static TypeNode For(Identifier/*!*/ id, Interface/*!*/ sourceIEnumerator, Interface/*!*/ targetIEnumerator, Module/*!*/ module, Coercer/*!*/ coercer, SourceContext sctx) {

      return EnumeratorAdapter.For(id, sourceIEnumerator, targetIEnumerator, null, module, coercer, sctx);

    }

    internal static TypeNode For(Identifier/*!*/ id, Interface/*!*/ sourceIEnumerator, Interface/*!*/ targetIEnumerator, TypeNode/*!*/ referringType, Coercer/*!*/ coercer, SourceContext sctx) {

      if (referringType == null){Debug.Assert(false); return null;}

      return EnumeratorAdapter.For(id, sourceIEnumerator, targetIEnumerator, referringType, referringType.DeclaringModule, coercer, sctx);

    }

    private static TypeNode For(Identifier/*!*/ id, Interface/*!*/ sourceIEnumerator, Interface/*!*/ targetIEnumerator, TypeNode referringType, Module/*!*/ module, Coercer/*!*/ coercer, SourceContext sctx) {

      Method sGetCurrent = sourceIEnumerator.GetMethod(StandardIds.getCurrent);

      if (sGetCurrent == null) { Debug.Fail(""); return null; }

      Method sMoveNext = sourceIEnumerator.GetMethod(StandardIds.MoveNext);

      if (sMoveNext == null) sMoveNext = SystemTypes.IEnumerator.GetMethod(StandardIds.MoveNext);

      Method tGetCurrent = targetIEnumerator.GetMethod(StandardIds.getCurrent);

      if (tGetCurrent == null) { Debug.Fail(""); return null; }

      Method tMoveNext = targetIEnumerator.GetMethod(StandardIds.MoveNext);

      if (tMoveNext == null) tMoveNext = SystemTypes.IEnumerator.GetMethod(StandardIds.MoveNext);

      Local loc = new Local(sGetCurrent.ReturnType);

      Expression curr = coercer(loc, tGetCurrent.ReturnType, null);

      if (curr == null) return null;

      id = Identifier.For("Enumerator"+id.ToString());

      InterfaceList interfaces = new InterfaceList(targetIEnumerator, SystemTypes.IDisposable);

      MemberList members = new MemberList(5);

      Class adapter = new Class(module, null, null, TypeFlags.Public, targetIEnumerator.Namespace, id, CoreSystemTypes.Object, interfaces, members);

      adapter.IsNormalized = true;

      if (referringType == null ||

      (sourceIEnumerator.Flags & TypeFlags.VisibilityMask) == TypeFlags.Public && (targetIEnumerator.Flags & TypeFlags.VisibilityMask) == TypeFlags.Public){

        adapter.Flags |= TypeFlags.Public;

        module.Types.Add(adapter);

      }else{

        adapter.Flags |= TypeFlags.NestedPrivate;

        referringType.Members.Add(adapter);

        adapter.DeclaringType = referringType;

      }

      //Field to hold source enumerator

      Field seField = new Field(adapter, null, FieldFlags.Private, StandardIds.Value, sourceIEnumerator, null);

      members.Add(seField);



      //Constructor

      Parameter par = new Parameter(null, ParameterFlags.None, StandardIds.Value, sourceIEnumerator, null, null);

      StatementList statements = new StatementList(3);

      This ThisParameter = new This(adapter);

      InstanceInitializer constr = CoreSystemTypes.Object.GetConstructor();

      if (constr == null) { Debug.Fail(""); return null; }

      MethodCall mcall = new MethodCall(new MemberBinding(ThisParameter, constr),

        new ExpressionList(0), NodeType.Call, CoreSystemTypes.Void);

      statements.Add(new ExpressionStatement(mcall));

      statements.Add(new AssignmentStatement(new MemberBinding(ThisParameter, seField), par));

      statements.Add(new Return());

      InstanceInitializer acons = new InstanceInitializer(adapter, null, new ParameterList(par), new Block(statements));

      acons.Flags |= MethodFlags.Public;

      acons.ThisParameter = ThisParameter;

      members.Add(acons);



      //get_Current

      statements = new StatementList(2);

      ThisParameter = new This(adapter);

      mcall = new MethodCall(new MemberBinding(new MemberBinding(ThisParameter, seField), sGetCurrent),

        new ExpressionList(0), NodeType.Callvirt, sGetCurrent.ReturnType);

      mcall.SourceContext = sctx;

      statements.Add(new AssignmentStatement(loc, mcall));

      statements.Add(new Return(curr));

      Method getCurrent = new Method(adapter, null, StandardIds.getCurrent, null, tGetCurrent.ReturnType, new Block(statements));

      getCurrent.Flags = MethodFlags.Public | MethodFlags.Virtual | MethodFlags.NewSlot | MethodFlags.HideBySig | MethodFlags.SpecialName;

      getCurrent.CallingConvention = CallingConventionFlags.HasThis;

      getCurrent.ThisParameter = ThisParameter;

      members.Add(getCurrent);



      //IEnumerator.GetCurrent

      statements = new StatementList(1);

      ThisParameter = new This(adapter);

      MethodCall callGetCurrent = new MethodCall(new MemberBinding(ThisParameter, getCurrent), new ExpressionList(0), NodeType.Call, getCurrent.ReturnType);

      if (getCurrent.ReturnType.IsValueType) {

        MemberBinding etExpr = new MemberBinding(null, getCurrent.ReturnType);

        statements.Add(new Return(new BinaryExpression(callGetCurrent, etExpr, NodeType.Box, CoreSystemTypes.Object)));

      }else

        statements.Add(new Return(callGetCurrent));

      Method ieGetCurrent = new Method(adapter, null, StandardIds.IEnumeratorGetCurrent, null, CoreSystemTypes.Object, new Block(statements));

      ieGetCurrent.ThisParameter = ThisParameter;

      ieGetCurrent.ImplementedInterfaceMethods = new MethodList(SystemTypes.IEnumerator.GetMethod(StandardIds.getCurrent));

      ieGetCurrent.CallingConvention = CallingConventionFlags.HasThis;

      ieGetCurrent.Flags = MethodFlags.Private | MethodFlags.Virtual | MethodFlags.SpecialName;

      members.Add(ieGetCurrent);



      //IEnumerator.Reset

      Method ieReset = SystemTypes.IEnumerator.GetMethod(StandardIds.Reset);

      if (ieReset == null) { Debug.Fail(""); return null; }

      statements = new StatementList(2);

      ThisParameter = new This(adapter);

      MethodCall callSourceReset = new MethodCall(new MemberBinding(ThisParameter, ieReset), new ExpressionList(0), NodeType.Callvirt, CoreSystemTypes.Object);

      statements.Add(new ExpressionStatement(callSourceReset));

      statements.Add(new Return());

      Method reset = new Method(adapter, null, StandardIds.IEnumeratorReset, null, CoreSystemTypes.Void, new Block(statements));

      reset.ThisParameter = ThisParameter;

      reset.ImplementedInterfaceMethods = new MethodList(ieReset);

      reset.CallingConvention = CallingConventionFlags.HasThis;

      reset.Flags = MethodFlags.Private | MethodFlags.Virtual | MethodFlags.SpecialName;

      members.Add(reset);



      //MoveNext

      if (sMoveNext == null) { Debug.Fail(""); return null; }

      statements = new StatementList(1);

      ThisParameter = new This(adapter);

      mcall = new MethodCall(new MemberBinding(new MemberBinding(ThisParameter, seField), sMoveNext),

        new ExpressionList(0), NodeType.Callvirt, CoreSystemTypes.Boolean);

      statements.Add(new Return(mcall));

      Method moveNext = new Method(adapter, null, StandardIds.MoveNext, null, CoreSystemTypes.Boolean, new Block(statements));

      moveNext.Flags = MethodFlags.Public | MethodFlags.Virtual | MethodFlags.NewSlot | MethodFlags.HideBySig;

      moveNext.CallingConvention = CallingConventionFlags.HasThis;

      moveNext.ThisParameter = ThisParameter;

      members.Add(moveNext);



      //IDispose.Dispose

      statements = new StatementList(1);

      //TODO: call Dispose on source enumerator

      statements.Add(new Return());

      Method dispose = new Method(adapter, null, StandardIds.Dispose, null, CoreSystemTypes.Void, new Block(statements));

      dispose.CallingConvention = CallingConventionFlags.HasThis;

      dispose.Flags = MethodFlags.Public | MethodFlags.Virtual;

      adapter.Members.Add(dispose);

      return adapter;

    }

  }

#endif

#if FxCop

  public class EventNode : Member{

#else

  public class Event : Member{

#endif

    private EventFlags flags;

    private Method handlerAdder;

    private Method handlerCaller;

    private MethodFlags handlerFlags;

    private Method handlerRemover;

    private TypeNode handlerType;

    private MethodList otherMethods;

#if !MinimalReader

    public TypeNode HandlerTypeExpression;

    /// <summary>The list of types (just one in C#) that contain abstract or virtual events that are explicity implemented or overridden by this event.</summary>

    public TypeNodeList ImplementedTypes;

    public TypeNodeList ImplementedTypeExpressions;

    /// <summary>Provides a delegate instance that is added to the event upon initialization.</summary>

    public Expression InitialHandler;

    public Field BackingField;

#endif

#if FxCop

    public EventNode()

#else

    public Event()

#endif

      : base(NodeType.Event){

    }

#if !MinimalReader

    public Event(TypeNode declaringType, AttributeList attributes, EventFlags flags, Identifier name, 

      Method handlerAdder, Method handlerCaller, Method handlerRemover, TypeNode handlerType)

      : base(declaringType, attributes, name, NodeType.Event){

      this.Flags = flags;

      this.HandlerAdder = handlerAdder;

      this.HandlerCaller = handlerCaller;

      this.HandlerRemover = handlerRemover;

      this.HandlerType = handlerType;

    }

#endif

    /// <summary>Bits characterizing this event.</summary>

    public EventFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    /// <summary>The method to be called in order to add a handler to an event. Corresponds to the add clause of a C# event declaration.</summary>

    public Method HandlerAdder{

      get{return this.handlerAdder;}

      set{this.handlerAdder = value;}

    }

    /// <summary>The method that gets called to fire an event. There is no corresponding C# syntax.</summary>

    public Method HandlerCaller{

      get{return this.handlerCaller;}

      set{this.handlerCaller = value;}

    }

    public MethodFlags HandlerFlags{

      get{return this.handlerFlags;}

      set{this.handlerFlags = value;}

    }

    /// <summary>The method to be called in order to remove a handler from an event. Corresponds to the remove clause of a C# event declaration.</summary>

    public Method HandlerRemover{

      get{return this.handlerRemover;}

      set{this.handlerRemover = value;}

    }

    /// <summary>The delegate type that a handler for this event must have. Corresponds to the type clause of C# event declaration.</summary>

    public TypeNode HandlerType{

      get{return this.handlerType;}

      set{this.handlerType = value;}

    }

    public MethodList OtherMethods{

      get{return this.otherMethods;}

      set{this.otherMethods = value;}

    }

    protected string fullName;

    public override string/*!*/ FullName {

      get{

        string result = this.fullName;

        if (result == null)

          this.fullName = result = this.DeclaringType.FullName+"."+(this.Name == null ? "" : this.Name.ToString());

        return result;

      }

    }

#if !NoXml

    protected override Identifier GetDocumentationId(){

      StringBuilder sb = new StringBuilder();

      sb.Append("E:");

      if (this.DeclaringType == null) return Identifier.Empty;

      this.DeclaringType.AppendDocumentIdMangledName(sb, null, null);

      sb.Append(".");

      if (this.Name == null) return Identifier.Empty;

      sb.Append(this.Name.Name);

      return Identifier.For(sb.ToString());

    }

#endif

#if !NoReflection

    public static Event GetEvent(System.Reflection.EventInfo eventInfo){

      if (eventInfo == null) return null;

      TypeNode tn = TypeNode.GetTypeNode(eventInfo.DeclaringType);

      if (tn == null) return null;

      return tn.GetEvent(Identifier.For(eventInfo.Name));

    }

    protected System.Reflection.EventInfo eventInfo;

    public virtual System.Reflection.EventInfo GetEventInfo(){

      if (this.eventInfo == null){

        TypeNode tn = this.DeclaringType;

        if (tn == null) return null;

        Type t = tn.GetRuntimeType();

        if (t == null) return null;

        System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.DeclaredOnly;

        if (this.IsPublic) flags |= System.Reflection.BindingFlags.Public; else flags |= System.Reflection.BindingFlags.NonPublic;

        if (this.IsStatic) flags |= System.Reflection.BindingFlags.Static; else flags |= System.Reflection.BindingFlags.Instance; 

        this.eventInfo = t.GetEvent(this.Name.ToString(), flags);

      }

      return this.eventInfo;

    }

#endif

    /// <summary>

    /// True if the methods constituting this event are abstract.

    /// </summary>

    public bool IsAbstract{

      get{return (this.HandlerFlags & MethodFlags.Abstract) != 0;}

    }

    public override bool IsAssembly{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.Assembly;}

    }

    public override bool IsCompilerControlled{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.CompilerControlled;}

    }

    public override bool IsFamily{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.Family;}

    }

    public override bool IsFamilyAndAssembly{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.FamANDAssem;}

    }

    public override bool IsFamilyOrAssembly{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.FamORAssem;}

    }

    public bool IsFinal {

      get { return (this.HandlerFlags & MethodFlags.Final) != 0; }

    }

    public override bool IsPrivate {

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.Private;}

    }

    public override bool IsPublic{

      get{return (this.HandlerFlags & MethodFlags.MethodAccessMask) == MethodFlags.Public;}

    }

    public override bool IsSpecialName{

      get{return (this.Flags & EventFlags.SpecialName) != 0;}

    }

    public override bool IsStatic{

      get{return (this.HandlerFlags & MethodFlags.Static) != 0;}

    }

    /// <summary>

    /// True if that the methods constituting this event are virtual.

    /// </summary>

    public bool IsVirtual{

      get{return (this.HandlerFlags & MethodFlags.Virtual) != 0;}

    }

    public override bool IsVisibleOutsideAssembly{

      get{

        return (this.HandlerAdder != null && this.HandlerAdder.IsVisibleOutsideAssembly) ||

          (this.HandlerCaller != null && this.HandlerCaller.IsVisibleOutsideAssembly) ||

          (this.HandlerRemover != null && this.HandlerRemover.IsVisibleOutsideAssembly);

      }

    }

    public static readonly Event NotSpecified = new Event();

    public override Member HiddenMember{

      get{

        return this.HiddenEvent;

      }

      set{

        this.HiddenEvent = (Event)value;

      }

    }

    protected Property hiddenEvent;

    public virtual Event HiddenEvent{

      get{

        if (this.hiddenMember == Event.NotSpecified) return null;

        Event hiddenEvent = this.hiddenMember as Event;

        if (hiddenEvent != null) return hiddenEvent;



        Method hiddenAdder = this.HandlerAdder == null ? null : this.HandlerAdder.HiddenMethod;

        Method hiddenCaller = this.HandlerCaller == null ? null : this.HandlerCaller.HiddenMethod;

        Method hiddenRemover = this.HandlerRemover == null ? null : this.HandlerRemover.HiddenMethod;

        Event hiddenAdderEvent = hiddenAdder == null ? null : hiddenAdder.DeclaringMember as Event;

        Event hiddenCallerEvent = hiddenCaller == null ? null : hiddenCaller.DeclaringMember as Event;

        Event hiddenRemoverEvent = hiddenRemover == null ? null : hiddenRemover.DeclaringMember as Event;



        hiddenEvent = hiddenAdderEvent;

        if (hiddenCallerEvent != null){

          if (hiddenEvent == null ||

            (hiddenCallerEvent.DeclaringType != null && hiddenCallerEvent.DeclaringType.IsDerivedFrom(hiddenEvent.DeclaringType)))

            hiddenEvent = hiddenCallerEvent;

        }

        if (hiddenRemoverEvent != null){

          if (hiddenEvent == null ||

            (hiddenRemoverEvent.DeclaringType != null && hiddenRemoverEvent.DeclaringType.IsDerivedFrom(hiddenEvent.DeclaringType)))

            hiddenEvent = hiddenRemoverEvent;

        }

        if (hiddenEvent == null){

          this.hiddenMember = Event.NotSpecified;

          return null;

        }

        this.hiddenMember = hiddenEvent;

        return hiddenEvent;

      }

      set{

        this.hiddenMember = value;

      }

    }

    public override Member OverriddenMember{

      get{

        return this.OverriddenEvent;

      }

      set{

        this.OverriddenEvent = (Event)value;

      }

    }

    protected Property overriddenEvent;

    public virtual Event OverriddenEvent{

      get{

        if (this.overriddenMember == Event.NotSpecified) return null;

        Event overriddenEvent = this.overriddenMember as Event;

        if (overriddenEvent != null) return overriddenEvent;



        Method overriddenAdder = this.HandlerAdder == null ? null : this.HandlerAdder.OverriddenMethod;

        Method overriddenCaller = this.HandlerCaller == null ? null : this.HandlerCaller.OverriddenMethod;

        Method overriddenRemover = this.HandlerRemover == null ? null : this.HandlerRemover.OverriddenMethod;

        Event overriddenAdderEvent = overriddenAdder == null ? null : overriddenAdder.DeclaringMember as Event;

        Event overriddenCallerEvent = overriddenCaller == null ? null : overriddenCaller.DeclaringMember as Event;

        Event overriddenRemoverEvent = overriddenRemover == null ? null : overriddenRemover.DeclaringMember as Event;



        overriddenEvent = overriddenAdderEvent;

        if (overriddenCallerEvent != null){

          if (overriddenEvent == null ||

          (overriddenCallerEvent.DeclaringType != null && overriddenCallerEvent.DeclaringType.IsDerivedFrom(overriddenEvent.DeclaringType)))

            overriddenEvent = overriddenCallerEvent;

        }

        if (overriddenRemoverEvent != null){

          if (overriddenEvent == null ||

            (overriddenRemoverEvent.DeclaringType != null && overriddenRemoverEvent.DeclaringType.IsDerivedFrom(overriddenEvent.DeclaringType)))

            overriddenEvent = overriddenRemoverEvent;

        }

        if (overriddenEvent == null){

          this.overriddenMember = Event.NotSpecified;

          return null;

        }

        this.overriddenMember = overriddenEvent;

        return overriddenEvent;

      }

      set{

        this.overriddenMember = value;

      }

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      base.GetName(options, name);

      Method.AppendReturnType(options.ReturnType, this.HandlerType, name);

    }

#endif

  }



#if ExtendedRuntime

  public abstract class MethodContractElement : Node{

    protected MethodContractElement(NodeType nodeType)

      : base(nodeType){

    }

    public bool Inherited;

#if !FxCop && ILOFFSETS

    public int ILOffset;

    // a string that a user wants associated with a particular element

    public Expression UserMessage;

    public Literal SourceConditionText;



#endif



  }

  public abstract class Requires : MethodContractElement {

    public Expression Condition;

    public virtual bool IsWithException { get { return false; } }

    protected Requires()

      : base(NodeType.Requires) {}

    protected Requires(NodeType nodeType)

      : base(nodeType){

    }

    protected Requires(NodeType nodeType, Expression expression)

      : base(nodeType){

      Condition = expression;

    }

  }

  public class RequiresPlain : Requires {

    /// <summary>

    /// If non-null, indicates that this is a Requires&lt;TException&gt; form throwing TException

    /// </summary>

    public TypeNode ExceptionType;



    public override bool IsWithException

    {

      get { return this.ExceptionType != null; }

    }

    public RequiresPlain()

      : base(NodeType.RequiresPlain) {}

    public RequiresPlain(Expression expression)

      : base(NodeType.RequiresPlain, expression) {}

    public RequiresPlain(Expression expression, TypeNode texception)

      : base(NodeType.RequiresPlain, expression) {

      this.ExceptionType = texception;

    }

  }



  public class OldExpression : Expression {

    public Expression expression;

    public OldExpression()

      : base(NodeType.OldExpression) {}

    public OldExpression(Expression expression)

      : base(NodeType.OldExpression) {this.expression = expression;}



    public int ShallowCopyUptoDimension {

      get {

        return copyLevel;

      }

      set {

        copyLevel = value;

      }

    }



    private int copyLevel = 0;

  }

  public class RequiresOtherwise : Requires {

    /// <summary>

    /// The ThrowException can be a type reference (like "NullReferenceException")

    /// or a value that would evaluate to something of an exception type.

    /// (like new NullReferenceException("...") or C.f where the f is a static field

    /// of class C whose type is an exception.

    /// </summary>

    public Expression ThrowException;

    public RequiresOtherwise()

      : base(NodeType.RequiresOtherwise) {}

    public RequiresOtherwise(Expression cond, Expression exc)

      : base(NodeType.RequiresOtherwise, cond){ ThrowException = exc; }

  }



  abstract public class Ensures : MethodContractElement {

    public Expression PostCondition;

    protected Ensures()

      : base(NodeType.Ensures) {}

    protected Ensures(NodeType nodeType)

      : base(nodeType){

    }

    protected Ensures(NodeType nodeType, Expression expression)

      : base(nodeType){

      this.PostCondition = expression;

    }

  }

  public class EnsuresNormal : Ensures{

    public EnsuresNormal()

      : base(NodeType.EnsuresNormal){

    }

    public EnsuresNormal(Expression expression)

      : base(NodeType.EnsuresNormal, expression){

    }

  }

  public class EnsuresExceptional : Ensures{

    public TypeNode Type;

    public TypeNode TypeExpression;

    public Expression Variable;

    public EnsuresExceptional()

      : base(NodeType.EnsuresExceptional){

    }

    public EnsuresExceptional(Expression expression)

      : base(NodeType.EnsuresExceptional, expression){

    }

  }



  public class ContractDeserializerContainer{

    public static IContractDeserializer ContractDeserializer;

  }

  public class MethodContract : Node{

    public Method/*!*/ DeclaringMethod;

    public Method/*!*/ OriginalDeclaringMethod;

    /// <summary>

    /// Used when contract are extracted from code and the contract use delegates with closure objects

    /// </summary>

    protected internal Block contractInitializer;

    protected internal RequiresList requires;

    protected internal EnsuresList ensures;

    protected internal ExpressionList modifies;

    protected internal bool? isPure;



    private static SourceContext SetContext(string/*!*/ filename, int startLine, int startCol, int endLine, int endCol, string/*!*/ sourceText) {

      SourceContext context;

      context.Document = new DocumentWithPrecomputedLineNumbers(filename, startLine, startCol, endLine, endCol);

      context.StartPos = 0;

      context.EndPos = sourceText.Length;

      context.Document.Text = new DocumentText(sourceText);

      context.Document.Text.Length = sourceText.Length;

      return context;

    }

    public static SourceContext GetSourceContext(AttributeNode/*!*/ attr) {

      string filename = "";

      int startLine = 0;

      int startCol = 0;

      int endLine = 0;

      int endCol = 0;

      string sourceText = "";

      if (attr.Expressions != null) {

        for (int expIndex = 1, expLen = attr.Expressions.Count; expIndex < expLen; expIndex++) {

          NamedArgument na = attr.Expressions[expIndex] as NamedArgument;

          if (na == null || na.Name == null) continue;

          Literal lit = na.Value as Literal;

          if (lit == null) continue;

          switch (na.Name.Name) {

            case "Filename":

            case "FileName":

              filename = (string)lit.Value; break;

            case "StartColumn": startCol = (int)lit.Value; break;

            case "StartLine": startLine = (int)lit.Value; break;

            case "EndColumn": endCol = (int)lit.Value; break;

            case "EndLine": endLine = (int)lit.Value; break;

            case "SourceText": sourceText = (string)lit.Value; break;

            default: break;

          }

        }

      }

      SourceContext ctx = SetContext(filename, startLine, startCol, endLine, endCol,sourceText);

      return ctx;

    }

    public Block ContractInitializer

    {

      get

      {

        // materialize contract if this is an instance

        if (contractInitializer == null) SpecializeContract();

        return contractInitializer;

      }

      set

      {

        this.contractInitializer = value;

      }

    }

#if false

    public Block ContractLocalsInitializer

    {

      get

      {

        // materialize contract if this is an instance

        if (contractLocalsInitializer == null) SpecializeContract();

        return contractLocalsInitializer;

      }

      set

      {

        this.contractLocalsInitializer = value;

      }

    }

#endif

    private void SpecializeContract()

    {

      if (this.Specializer == null) return;

      if (this.DeclaringMethod == null) return;

      Method template = this.DeclaringMethod.Template;

      if (template == null) return;



      this.CopyFrom(template.Contract);

      this.contractInitializer = (Block)this.Specializer(this.DeclaringMethod, this.contractInitializer);

      this.ensures = (EnsuresList)this.Specializer(this.DeclaringMethod, this.ensures);

      this.requires = (RequiresList)this.Specializer(this.DeclaringMethod, this.requires);

      this.Specializer = null;

    }

    public RequiresList Requires{

      get{

        if (this.requires != null) return this.requires;

        RequiresList rs = this.requires = new RequiresList();

        if (this.DeclaringMethod != null){

          if (this.Specializer != null && this.DeclaringMethod.Template != null) {

            SpecializeContract();

            return this.requires;

          }

          AttributeList attributes = this.DeclaringMethod.Attributes;

          if (attributes == null || attributes.Count == 0) return rs;

          IContractDeserializer ds = Cci.ContractDeserializerContainer.ContractDeserializer;

          if (ds != null){

            TypeNode t = this.DeclaringMethod.DeclaringType;

            Module savedCurrentAssembly = ds.CurrentAssembly;

            ds.CurrentAssembly = t == null ? null : t.DeclaringModule;

            for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

              AttributeNode attr = attributes[i];

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb != null){

                if (mb.BoundMember == null) continue;

                if (mb.BoundMember.DeclaringType != SystemTypes.RequiresAttribute) continue;

                if (attr.Expressions == null || !(attr.Expressions.Count > 0)) continue;



                Literal l = attr.Expressions[0] as Literal;

                if (l == null) continue;

                string s = (string) l.Value;

                Expression e = null;

                try {

                  e = ds.ParseContract(this,s,null);

                } catch {

                  continue; //return this.requires = new RequiresList();

                }

                if (e != null){

                  RequiresPlain rp = new RequiresPlain(e);

                  SourceContext ctx = MethodContract.GetSourceContext(attr);

                  e.SourceContext = ctx;

                  rs.Add(rp);

                }

              }

            }

            ds.CurrentAssembly = savedCurrentAssembly;

          }

        }

        return this.requires;

      }

      set{

        this.requires = value;

      }

    }

    public EnsuresList Ensures{

      get{

        if (this.ensures != null) return this.ensures;

        EnsuresList es = this.ensures = new EnsuresList();

        if (this.DeclaringMethod != null){

          if (this.Specializer != null && this.DeclaringMethod.Template != null) {

            SpecializeContract();

            return this.ensures;

          }

          AttributeList attributes = this.DeclaringMethod.Attributes;

          if (attributes == null || attributes.Count == 0) return es;

          IContractDeserializer ds = Cci.ContractDeserializerContainer.ContractDeserializer;

          if (ds != null){

            TypeNode t = this.DeclaringMethod.DeclaringType;

            Module savedCurrentAssembly = ds.CurrentAssembly;

            ds.CurrentAssembly = t == null ? null : t.DeclaringModule;

            for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

              AttributeNode attr = attributes[i];

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb != null){

                if (mb.BoundMember == null) continue;

                if (mb.BoundMember.DeclaringType == SystemTypes.ThrowsAttribute) {

                  EnsuresExceptional ee = null;

                  Literal eeType = attr.Expressions[0] as Literal;

                  if (eeType == null) continue;

                  if (eeType.Type == SystemTypes.Type) {

                    TypeNode tn = (TypeNode)eeType.Value;

                    ee = new EnsuresExceptional();

                    ee.Type = tn;

                    es.Add(ee);

                  }

                  if (ee != null && attr.Expressions.Count > 1) {

                    Literal eeCondition = attr.Expressions[1] as Literal;

                    if (eeCondition != null) {

                      string eeString = (string)eeCondition.Value;

                      Expression deserializedEECondition = null;

                      try {

                        deserializedEECondition = ds.ParseContract(this, eeString, null);

                        Comprehension cmp = deserializedEECondition as Comprehension;

                        if (cmp != null) {

                          // See notes in Serializer for how this is represented

                          ComprehensionBinding cmpB = (ComprehensionBinding)cmp.BindingsAndFilters[0];

                          ee.Variable = cmpB.TargetVariable;

                          ee.PostCondition = cmp.Elements[0];

                        } else {

                          ee.PostCondition = deserializedEECondition;

                        }

                        SourceContext eeSourceContext = MethodContract.GetSourceContext(attr);

                        ee.PostCondition.SourceContext = eeSourceContext;

                      }

                      catch {

                        continue; //return this.ensures = new EnsuresList();

                      }

                    }

                  }

                }

                if (mb.BoundMember.DeclaringType != SystemTypes.EnsuresAttribute) continue;

                if (attr.Expressions == null || !(attr.Expressions.Count > 0)) continue;

                Literal l = attr.Expressions[0] as Literal;

                if (l == null) continue;

                string s = (string) l.Value;

                Expression e = null;

                try {

                  e = ds.ParseContract(this,s,null);

                } catch {

                  continue; //return this.ensures = new EnsuresList();

                }

                EnsuresNormal ens = new EnsuresNormal(e);

                SourceContext ctx = MethodContract.GetSourceContext(attr);

                e.SourceContext = ctx;

                es.Add(ens);

              }

            }

            ds.CurrentAssembly = savedCurrentAssembly;

          }

        }

        return this.ensures;

      }

      set{

        this.ensures = value;

      }

    }

    public bool IsPure

    {

      get

      {

        if (this.isPure.HasValue) return this.isPure.Value;

        if (this.DeclaringMethod != null)

        {

          AttributeList attributes = this.DeclaringMethod.Attributes;

          for (int i = 0; attributes != null && i < attributes.Count; i++)

          {

            AttributeNode attr = attributes[i];

            if (attr == null) continue;

            if (attr.Type == null) continue;

            if (attr.Type.Name == null) continue;

            if (attr.Type.Name.Name == "PureAttribute")

            {

              this.isPure = true;

              return true;

            }

          }

        }

        this.isPure = false;

        return false;

      }

    }

    public ExpressionList Modifies{

      get{

        if (this.modifies != null) return this.modifies;

        ExpressionList ms = this.modifies = new ExpressionList();

        if (this.DeclaringMethod != null){

          AttributeList attributes = this.DeclaringMethod.Attributes;

          if (attributes == null || attributes.Count == 0) return ms;

          IContractDeserializer ds = Cci.ContractDeserializerContainer.ContractDeserializer;

          if (ds != null){

            TypeNode t = this.DeclaringMethod.DeclaringType;

            Module savedCurrentAssembly = ds.CurrentAssembly;

            ds.CurrentAssembly = t == null ? null : t.DeclaringModule;

            for (int i = 0, n = attributes == null || attributes.Count == 0 ? 0 : attributes.Count; i < n; i++) {

              AttributeNode attr = attributes[i];

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb != null){

                if (mb.BoundMember == null) continue;

                if (mb.BoundMember.DeclaringType != SystemTypes.ModifiesAttribute) continue;

                if (attr.Expressions == null || !(attr.Expressions.Count > 0)) continue;



                Literal l = attr.Expressions[0] as Literal;

                if (l == null) continue;

                string s = (string) l.Value;

                Expression e = ds.ParseContract(this,s,null);

                if (e == null) continue;

                SourceContext ctx = MethodContract.GetSourceContext(attr);

                e.SourceContext = ctx;

                ms.Add(e);

              }

            }

            ds.CurrentAssembly = savedCurrentAssembly;

          }

        }

        return this.modifies;

      }

      set{

        this.modifies = value;

      }

    }

    public delegate object ContractSpecializerDelegate(Method method, object part);

    public ContractSpecializerDelegate Specializer;

    public MethodContract(Method/*!*/ declaringMethod)

      : base(NodeType.MethodContract) {

      this.DeclaringMethod = this.OriginalDeclaringMethod = declaringMethod;

    }





    public void CopyFrom(MethodContract sourceContract) {

      if ( sourceContract == null ) return;

      this.OriginalDeclaringMethod = sourceContract.OriginalDeclaringMethod;

      

      // Force deserialization (if necessary) to make sure sourceContract is fully populated

      // This is needed for LocalForResult: it is populated in the sourceContract only if the

      // postconditions have been deserialized.

      int dummy = sourceContract.Requires.Count;

      dummy = sourceContract.Ensures.Count + dummy;



      TypeNode t = this.DeclaringMethod.DeclaringType;

      Module m = t.DeclaringModule;

      Duplicator dup = new Duplicator(m,t);

      // Set up DuplicateFor table: all references to parameters from the source contract should be replaced

      // with references to the equivalent parameter from the target contract.

      // These references can be of type "Parameter" or "ParameterField".

      // Also, the local that holds the "result" of the method should be likewise mapped.

      // Also, the "this" parameter should be mapped.

      Method sourceMethod = sourceContract.DeclaringMethod;

      if (sourceMethod != null){

        MethodScope sourceScope = sourceMethod.Scope;

        Method targetMethod = this.DeclaringMethod;

        if (targetMethod != null){

          #region Map the self parameter

          if (sourceMethod.ThisParameter != null && targetMethod.ThisParameter != null){

            dup.DuplicateFor[sourceMethod.ThisParameter.UniqueKey] = targetMethod.ThisParameter;

          }

          #endregion

          #region Map the method parameters

          if (sourceMethod.Parameters != null && targetMethod.Parameters != null

            && sourceMethod.Parameters.Count == targetMethod.Parameters.Count){

            for (int i = 0, n = sourceMethod.Parameters.Count; i < n; i++){

              dup.DuplicateFor[sourceMethod.Parameters[i].UniqueKey] = targetMethod.Parameters[i];

            }

          }

          #endregion

          #region Map the ParameterFields

          MethodScope targetScope = targetMethod.Scope;

          if (sourceScope != null && targetScope != null){

            MemberList sourceScopeMembers = sourceScope.Members;

            for (int i = 0, n = sourceScopeMembers != null ? sourceScopeMembers.Count : 0; i < n; i++){

              ParameterField sourcePF = sourceScopeMembers[i] as ParameterField;

              if (sourcePF == null) continue;

              Parameter sourceP = sourcePF.Parameter;

              if (sourceP == null){ Debug.Assert(false); continue; }

              int index = sourceP.ParameterListIndex;

              if (targetMethod.Parameters == null || targetMethod.Parameters.Count <= index || index < 0){

                Debug.Assert(false); continue;

              }

              Parameter targetParameter = targetMethod.Parameters[index];

              Field f = targetScope.GetField(targetParameter.Name);

              if (f == null){ Debug.Assert(false); continue; }

              ParameterField targetPF = f as ParameterField;

              if (targetPF == null){ Debug.Assert(false); continue; }

              dup.DuplicateFor[sourcePF.UniqueKey] = targetPF;

            }

          }

          #endregion

        }

      }

      MethodContract duplicatedMC = dup.VisitMethodContract(sourceContract);

      duplicatedMC.isPure = sourceContract.IsPure; // force looking at attributes

      if (duplicatedMC != null && duplicatedMC.Requires != null && duplicatedMC.Requires.Count > 0) {

        RequiresList reqList = new RequiresList();

        for (int i = 0, n = duplicatedMC.Requires.Count; i< n; i++){

          Requires r = duplicatedMC.Requires[i];

          if (r != null) r.Inherited = true;

          reqList.Add(r);

        }

        if (this.requires != null)

        {

          foreach (Requires r in this.requires)

          {

            reqList.Add(r);

          }

        }

        this.Requires = reqList;

      }

      if (duplicatedMC != null && duplicatedMC.Ensures != null && duplicatedMC.Ensures.Count > 0 ) {

        EnsuresList enList = new EnsuresList();

        for(int i = 0, n = duplicatedMC.Ensures.Count; i < n; i++) {

          Ensures e = duplicatedMC.Ensures[i];

          if (e == null) continue;

          e.Inherited = true;

          enList.Add(e);

        }

        if (this.ensures != null)

        {

          foreach (Ensures e in this.ensures)

          {

            enList.Add(e);

          }

        }

        this.Ensures = enList;

      }

      if (duplicatedMC != null && duplicatedMC.Modifies != null && duplicatedMC.Modifies.Count > 0) {

        ExpressionList modlist = this.Modifies = (this.Modifies == null ? new ExpressionList() : this.Modifies);

        for (int i = 0, n = duplicatedMC.Modifies.Count; i < n; i++)

          modlist.Add(duplicatedMC.Modifies[i]);

      }

      this.ContractInitializer = duplicatedMC.ContractInitializer;

      return;

    }

  }



  /// <summary>

  /// This is a method, as we need a binding for "this".

  /// </summary>

  public class Invariant : Method{

    public Expression Condition;

#if !FxCop && ILOFFSETS

    public int ILOffset;

    // a string that a user wants associated with a particular element

    public Literal UserMessage;

    public Literal SourceConditionText;

#endif



    public Invariant(TypeNode declaringType, AttributeList attributes, Identifier name)

    {

      this.NodeType = NodeType.Invariant;

      this.attributes = attributes;

      this.DeclaringType = declaringType;

      this.Name = name;

      // this is called from the parser, so we have to avoid triggering CoreSystemType initialization.

      this.ReturnType = new TypeExpression(new Literal(TypeCode.Boolean), 0);

      this.ReturnTypeExpression = new TypeExpression(new Literal(TypeCode.Boolean), 0);

    }

    // called from Foxtrot

    public Invariant(TypeNode declaringType, Expression invariant, string name)

    {

      this.NodeType = NodeType.Invariant;

      this.DeclaringType = declaringType;

      this.Condition = invariant;

      if (name == null)

      {

        name = "ObjectInvariant";

      }

      this.Name = Identifier.For(name);

      this.ReturnType = new TypeExpression(new Literal(TypeCode.Boolean), 0);

      this.ReturnTypeExpression = new TypeExpression(new Literal(TypeCode.Boolean), 0);

    }

  }



  public class ModelfieldContract : Node {

    protected Field mf; //the modelfield this contract applies to (might be a temporary modelfield that stores unresolved override information)

    protected Property ifaceMf; //the interface modelfield this contract applies to.

    //invariant mf != null && ifaceMF == null || mf == null && ifaceMf != null;



    public Expression Witness = null;

    public bool HasExplicitWitness = false; //set to true if this modelfield has an explicitly specified witness. NOTE: Not serialized, i.e., not available in boogie!

    public ExpressionList/*!*/ SatisfiesList = new ExpressionList();            



    public TypeNode DeclaringType;



    public Member/*!*/ Modelfield { get { return this.mf == null ? (Member)this.ifaceMf : (Member)this.mf; } }

    public TypeNode/*!*/ ModelfieldType { get { return this.mf == null ? this.ifaceMf.Type : this.mf.Type; } }    

    private bool isOverride = false;

    public bool IsOverride {

      //slighty complicated to work both before and after serialization, and before and after update of modelfield reference if this contract is overriding a baseclass contract. 

      get {

        if (this.isOverride == true) return true;

        return !(this.Modelfield.DeclaringType == this.DeclaringType);

      }

      set {

        //requires value == true; (setting to false has no real meaning or effect)

        isOverride = value;

      }

    }



    private bool isSealed = false;  //set to true if modelfield itself is sealed (i.e., has the keyword).

    public bool IsSealed {

      get { if (this.isSealed) return true;

            if (this.DeclaringType == null) return false; //defensive check

            return this.DeclaringType.IsSealed;        

      }

      set { //requires value == true and the modelfield(contract) itself is sealed</summary>

        this.isSealed = value; }

    }    



    /// <summary>      

    /// ensures that the result is a new modelfieldcontract with an empty set of satisfies clauses and a default witness.

    /// ensures that the SourceContext of the result and the default witness are set to name.SourceContext.

    /// requires all attributes to be non-null

    /// </summary>    

    public ModelfieldContract(TypeNode declaringType, AttributeList attrs, TypeNode type, Identifier name, SourceContext sctx)

      : base(NodeType.ModelfieldContract)

    {

      this.DeclaringType = declaringType;            

      this.SourceContext = sctx;      

      if (declaringType is Class) {

        this.mf = new Field(declaringType, attrs, FieldFlags.Public, name, type, null); //note: if the modelfield has an override modifier, then mf is a placeholder. This will be signalled by a 'Private' flag.        

        this.mf.IsModelfield = true;

        this.mf.SourceContext = this.SourceContext;

      } else if (declaringType is Interface) {

        //Treat as a property with a getter that will return a modelfield from an implementing class        

        #region create a default abstract getter method getM

        Method getM = new Method(declaringType, new AttributeList(), new Identifier("get_" + name.Name), new ParameterList(), type, null);

        getM.SourceContext = this.SourceContext;

        getM.CallingConvention = CallingConventionFlags.HasThis; //needs to be changed when we want to allow static modelfields

        //Give getM [NoDefaultContract] so that it can easily be called in specs

        InstanceInitializer ndCtor = SystemTypes.NoDefaultContractAttribute.GetConstructor();        

        if (ndCtor != null)

          getM.Attributes.Add(new AttributeNode(new MemberBinding(null, ndCtor), null, AttributeTargets.Method));

        //Give getM "confined" (otherwise it still can't be called in specs, as it has NoDefaultContract)

        // That means make it [Pure][Reads(Reads.Owned)]

        InstanceInitializer pCtor = SystemTypes.PureAttribute.GetConstructor();        

        if (pCtor != null)

          getM.Attributes.Add(new AttributeNode(new MemberBinding(null, pCtor), null, AttributeTargets.Method));

        InstanceInitializer rCtor = SystemTypes.ReadsAttribute.GetConstructor(); // can use nullary ctor since default is confined

        if (rCtor != null)

          getM.Attributes.Add(new AttributeNode(new MemberBinding(null, rCtor), null, AttributeTargets.Method));

        //To the user, a modelfield on an interface is a field. Therefore, the user should be allowed to give it a [Rep] attribute.

        //But we treat the modelfield as a property, which is not a valid target for [Rep].  

        //We convert a [Rep] on the property to an [Owned] on the getter.                                        

        int nrOfAttrs = (attrs == null ? 0 : attrs.Count);

        for (int i = 0, j = 0; i < nrOfAttrs; i++) {          

          Identifier attrI = (attrs[i].Constructor as Identifier); //seems we need a HACK: Constructor has not been processed yet (by Looker).

          if (i == j && attrI != null && attrI.Name == "Rep") { //test i == j for slightly improved error handling on multiple [Rep]'s

            InstanceInitializer oCtor = SystemTypes.RepAttribute.GetConstructor();

            if (oCtor != null) { 

              getM.Attributes.Add(new AttributeNode(new MemberBinding(null, oCtor), null, AttributeTargets.Method));

              attrs[i] = null;

            }

          } else {

            attrs[j] = attrs[i];

            j = j + 1;

          }

        }

        declaringType.Members.Add(getM);

        getM.Flags = MethodFlags.Public | MethodFlags.Abstract | MethodFlags.NewSlot | MethodFlags.Virtual | MethodFlags.SpecialName | MethodFlags.HideBySig;        

        #endregion

        ifaceMf = new Property(declaringType, attrs, PropertyFlags.None, name, getM, null);

        ifaceMf.IsModelfield = true;

        ifaceMf.SourceContext = this.SourceContext;

        getM.DeclaringMember = ifaceMf;

      }      

    }

    

    /// <summary>

    /// ensures result.Modelfield == modelfield.    

    /// </summary>  

    public ModelfieldContract(TypeNode/* ! */ declaringType, Field/* ! */ modelfield)

      : base(NodeType.ModelfieldContract) {

      this.DeclaringType = declaringType;

      this.SourceContext = modelfield.SourceContext;      

      this.mf = modelfield;      

      if (modelfield.DeclaringType != declaringType)

        this.IsOverride = true;

    }    



    /// <summary>

    /// requires this.IsOverride == true;

    /// requires that newMf is a member of a superclass of mfC.DeclaringType;

    /// ensures this.Modelfield == newMf;

    /// this method can be used to update the modelfield of an overriding modelfieldcontract to the modelfield that is overridden.

    /// </summary>

    /// <param name="newMf">The overridden modelfield that this modelfieldContract applies to</param>

    public void UpdateModelfield(Field newMf) {

      this.mf = newMf;      

    }

    

    private ModelfieldContract nearestOverriddenContract; //null when this not an overriding contract (or when getNearestContractContract has not yet been called) 

    /// <summary>

    /// ensures: if this contract overrides a superclass contract, then result is the nearest overridden contract, else result == null. 

    /// </summary>       

    public ModelfieldContract NearestOverriddenContract {

      get {

        if (this.nearestOverriddenContract != null) return this.nearestOverriddenContract;



        if (this.mf == null) return null; //interface modelfieldContracts can't override

        if (!this.IsOverride) return null;

        #region scan superclasses until nearest overriden contract is found, then return that contract.

        for (Class currentClass = this.DeclaringType.BaseType as Class; currentClass != null; currentClass = currentClass.BaseClass) {

          foreach (ModelfieldContract currentMfC in currentClass.Contract.ModelfieldContracts) {

            if (currentMfC.Modelfield == this.mf) {

              this.nearestOverriddenContract = currentMfC;

              return this.nearestOverriddenContract;

            }

          }

        }

        Debug.Assert(false);  //an overridden contract should have been found and returned.  

        return this.nearestOverriddenContract;

        #endregion

      }

    }



  }



  public sealed class ModelfieldContractList {

    private ModelfieldContract[]/*!*/ elements;

    private int count = 0;

    public ModelfieldContractList() {

      this.elements = new ModelfieldContract[8];

      //^ base();

    }

    public ModelfieldContractList(int n) {

      this.elements = new ModelfieldContract[n];

      //^ base();

    }

    public ModelfieldContractList(params ModelfieldContract[] elements) {

      if (elements == null) elements = new ModelfieldContract[0];

      this.elements = elements;

      this.count = elements.Length;

      //^ base();

    }

    public void Add(ModelfieldContract element) {

      int n = this.elements.Length;

      int i = this.count++;

      if (i == n) {

        int m = n * 2; if (m < 8) m = 8;

        ModelfieldContract[] newElements = new ModelfieldContract[m];

        for (int j = 0; j < n; j++) newElements[j] = elements[j];

        this.elements = newElements;

      }

      this.elements[i] = element;

    }

    public ModelfieldContractList/*!*/ Clone() {

      ModelfieldContract[] elements = this.elements;

      int n = this.count;

      ModelfieldContractList result = new ModelfieldContractList(n);

      result.count = n;

      ModelfieldContract[] newElements = result.elements;

      for (int i = 0; i < n; i++)

        newElements[i] = elements[i];

      return result;

    }

    public int Count {

      get { return this.count; }

      set { this.count = value; }

    }

    [Obsolete("Use Count property instead.")]

    public int Length {

      get { return this.count; }

      set { this.count = value; }

    }

    public ModelfieldContract this[int index] {

      get {

        return this.elements[index];

      }

      set {

        this.elements[index] = value;

      }

    }

    public Enumerator GetEnumerator() {

      return new Enumerator(this);

    }

    public struct Enumerator {

      private int index;

      private readonly ModelfieldContractList/*!*/ list;

      public Enumerator(ModelfieldContractList/*!*/ list) {

        this.index = -1;

        this.list = list;

      }

      public ModelfieldContract Current {

        get {

          return this.list[this.index];

        }

      }

      public bool MoveNext() {

        return ++this.index < this.list.count;

      }

      public void Reset() {

        this.index = -1;

      }

    }

  }



  public class TypeContract : Node {

    public TypeNode DeclaringType;

    protected internal ModelfieldContractList modelfieldContracts;



    /// <summary> 

    /// Deserializes attr.Expressions[i] as expression E.

    /// requires attr.Expressions.Count > i;    

    /// requires this.DeclaringType != null;

    /// </summary> 

    /// <returns>E if succesfull, null otherwise.</returns>

    private Expression getIndexFromAttribute(AttributeNode attr, int i) {      

      Debug.Assert(attr != null && attr.Expressions.Count > i && this.DeclaringType != null); //something's wrong with the IL we are deserializing, should have generated an error while constructing the IL.

      IContractDeserializer ds = Cci.ContractDeserializerContainer.ContractDeserializer;

      if (ds == null) return null;

      ds.CurrentAssembly = this.DeclaringType.DeclaringModule;

      Literal l = attr.Expressions[i] as Literal;

      if (l == null) return null;

      string s = (string)l.Value;

      return ds.ParseContract(this, s, null);      

    }



    /// <summary>

    /// requires attr.Expressions.Count > 0

    /// ensures if attr.Expressions[0] can be deserialized as modelfield F, then:

    ///   if F key in contractLookup, then returns matching value, else returns new ModelfieldContract mfC for F

    /// else returns null

    /// ensures if new mfC created, then  (F, mfC) in contractLookup and mfC in this.ModelfieldContracts

    /// </summary>

    private ModelfieldContract getContractFor(AttributeNode attr, Dictionary<Field, ModelfieldContract> contractLookup) {

      Expression mfBinding = this.getIndexFromAttribute(attr, 0);

      

      //extract modelfield from mfBinding

      if (!(mfBinding is MemberBinding)) return null;

      Field modelfield = (mfBinding as MemberBinding).BoundMember as Field;

      if (modelfield == null) return null;



      //If this modelfield does not yet have a contract, then create one now and add <modelfield,mfC> to createdContracts       

      ModelfieldContract mfC = null;

      if (!contractLookup.TryGetValue(modelfield, out mfC)) {                

        mfC = new ModelfieldContract(this.DeclaringType, modelfield);        

        this.modelfieldContracts.Add(mfC);

        contractLookup.Add(modelfield, mfC);

      }



      return mfC;

    }



    public ModelfieldContractList/*!*/ ModelfieldContracts {

      get {

        if (this.modelfieldContracts == null) {                  

          this.modelfieldContracts = new ModelfieldContractList();

          #region deserialize the modelfieldcontracts if needed

          Dictionary<Field,ModelfieldContract> createdContracts = new Dictionary<Field,ModelfieldContract>(); //key = modelfield memberbinding, value = contract for that modelfield (if one was created already)

          if (this.DeclaringType != null) {                      

            foreach (AttributeNode attr in this.DeclaringType.Attributes) {                

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb == null || mb.BoundMember == null) continue;

              if (mb.BoundMember.DeclaringType == SystemTypes.ModelfieldContractAttribute) {

                ModelfieldContract mfC = this.getContractFor(attr, createdContracts);

                Expression witness = this.getIndexFromAttribute(attr, 1);

                if (witness == null) continue;

                witness.SourceContext = MethodContract.GetSourceContext(attr);

                mfC.Witness = witness;

              } else if (mb.BoundMember.DeclaringType == SystemTypes.SatisfiesAttribute) {                

                ModelfieldContract mfC = this.getContractFor(attr, createdContracts);

                Expression satClause = this.getIndexFromAttribute(attr, 1);

                if (satClause == null) continue;

                satClause.SourceContext = MethodContract.GetSourceContext(attr);

                mfC.SatisfiesList.Add(satClause);              

              }                               

            }

          }

          #endregion

        }

        return this.modelfieldContracts;  

      }

      set { this.modelfieldContracts = value; }

    }



    public InvariantList InheritedInvariants;

    protected internal InvariantList invariants;

    public InvariantList Invariants{

      get{

        if (this.invariants != null) return this.invariants;

        InvariantList invs = this.invariants = new InvariantList();

        if (this.DeclaringType != null){

          AttributeList attributes = this.DeclaringType.Attributes;

          IContractDeserializer ds = Cci.ContractDeserializerContainer.ContractDeserializer;

          if (ds != null){

            Module savedCurrentAssembly = ds.CurrentAssembly;

            ds.CurrentAssembly = this.DeclaringType == null ? null : this.DeclaringType.DeclaringModule;

            for (int i = 0, n = attributes == null || attributes.Count == 0 ? 0 : attributes.Count; i < n; i++){

              AttributeNode attr = attributes[i];

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb != null){

                if (mb.BoundMember == null) continue;

                if (mb.BoundMember.DeclaringType != SystemTypes.InvariantAttribute) continue;

                if (attr.Expressions == null || !(attr.Expressions.Count > 0)) continue;



                Literal l = attr.Expressions[0] as Literal;

                if (l == null) continue;

                string s = (string) l.Value;

                Expression e = ds.ParseContract(this,s,null);

                if (e != null){

                  Invariant inv = new Invariant(this.DeclaringType,null,Identifier.For("invariant"+i));

                  SourceContext ctx = MethodContract.GetSourceContext(attr);

                  inv.SourceContext = ctx;

                  inv.Condition = e;

                  invs.Add(inv);

                }

              }

            }

            // Make the type contract look as it does when the type is compiled from source

            this.FramePropertyGetter = this.DeclaringType.GetMethod(Identifier.For("get_SpecSharp::FrameGuard"), null);

            this.InitFrameSetsMethod = this.DeclaringType.GetMethod(Identifier.For("SpecSharp::InitGuardSets"), null);

            this.InvariantMethod = this.DeclaringType.GetMethod(Identifier.For("SpecSharp::CheckInvariant"), CoreSystemTypes.Boolean);

            this.FrameProperty = this.DeclaringType.GetProperty(Identifier.For("SpecSharp::FrameGuard"));

            this.FrameField = this.DeclaringType.GetField(Identifier.For("SpecSharp::frameGuard"));

            ds.CurrentAssembly = savedCurrentAssembly;

          }

        }

        return this.invariants;

      }

      set{

        this.invariants = value;

      }

    }



    // when non-null, points to the method added to the DeclaringType that will have the invariants in its body

    // needed so when each invariant is visited, the proper environment can be set up for it.

    // NB: Dont' visit it as part of StandardVisitor

    public Field FrameField;

    public Property FrameProperty;

    public Method FramePropertyGetter;

    public Method InitFrameSetsMethod;

    public Method InvariantMethod;// when non-null, points to the method added to the DeclaringType that will have the invariants in its body

    /// <summary>

    /// Microsoft.Contracts.FrameGuardGetter implementation for this class.

    /// </summary>

    public Method GetFrameGuardMethod;

    /// <summary>

    /// When types get constructed via the Reader, we let the Invariants be initialized on demand.

    /// When the parser creates a type, we want the type contract to contain the empty invariant list

    /// so that it won't grovel through the attributes on first access to Invariants.

    /// </summary>

    /// <param name="containingType"></param>

    public TypeContract(TypeNode containingType) : this(containingType, false)

    {

    }

    public TypeContract(TypeNode containingType, bool initInvariantList)

      : base(NodeType.TypeContract) {

      this.DeclaringType = containingType;

      if (initInvariantList) {

        this.invariants = new InvariantList();

      }

    }

    public int InvariantCount { get { return Invariants == null ? 0 : Invariants.Count; } }

    public int ModelfieldContractCount { get { return ModelfieldContracts == null ? 0 : ModelfieldContracts.Count; } }

  }

  public interface IContractDeserializer{

    // when text is a requires, ensures, or modifies

    Expression ParseContract(MethodContract mc, string text, ErrorNodeList errors);

    // when text is an assertion or an assume in code

    Expression ParseContract(Method m, string text, ErrorNodeList errs);

    // when text is an invariant

    Expression ParseContract(TypeContract/*!*/ tc, string text, ErrorNodeList errs);

    Module CurrentAssembly { get; set; }

    ErrorNodeList ErrorList { get; set; }

  }

#endif



  public class Method : Member{

#if ExtendedRuntime

    /// <summary>

    /// Gets the first attribute of the given type in the attribute list of this method, or in the attribute list

    /// of the method's declaring member (if it exists).

    /// Returns null if none found.

    /// This should not be called until the AST containing this member has been processed to replace symbolic references

    /// to members with references to the actual members.

    /// </summary>

    public virtual AttributeNode GetAttributeFromSelfOrDeclaringMember (TypeNode attributeType) {

      AttributeNode a = base.GetAttribute(attributeType);

      if (a == null && this.DeclaringMember != null) {

        a = this.DeclaringMember.GetAttribute(attributeType);

      }

      return a;

    }

#endif

#if ExtendedRuntime

    protected internal MethodContract/*?*/ contract;

    internal static readonly MethodContract/*!*/ DummyContract = new MethodContract(null);

    /// <summary>The preconditions, postconditions, and modifies clauses of this method.</summary>

    public virtual MethodContract/*?*/ Contract {

      get {

        if (contract != null) return contract == Method.DummyContract ? null : contract;

        // There may be serialized contracts in the method's attributes.

        MethodContract mc = new MethodContract(this);

        // Pull on the properties to see if anything shows up

        int count = mc.Requires.Count;

        count += mc.Ensures.Count;

        count += mc.Modifies.Count;

        count += (mc.IsPure) ? 1 : 0;

        if (0 < count) { contract = mc; return contract; } else { contract = Method.DummyContract; return null; }

      }

      set {

        contract = value;

        if (value != null) {

          contract.DeclaringMethod = this;

        }

      }

    }

#endif

#if !MinimalReader

    public TypeNodeList ImplementedTypes;

    public TypeNodeList ImplementedTypeExpressions;

    public bool HasCompilerGeneratedSignature = true;

    public TypeNode ReturnTypeExpression;

    /// <summary>Provides a way to retrieve the parameters and local variables defined in this method given their names.</summary>

    public MethodScope Scope;

    public bool HasOutOfBandContract = false;

    protected TrivialHashtable/*!*/ Locals = new TrivialHashtable();

#endif

#if !FxCop

    public LocalList LocalList;

    protected SecurityAttributeList securityAttributes;

    /// <summary>Contains declarative security information associated with the type.</summary>

    public SecurityAttributeList SecurityAttributes {

      get {

        if (this.securityAttributes != null) return this.securityAttributes;

        if (this.attributes == null) {

          AttributeList al = this.Attributes; //Getting the type attributes also gets the security attributes, in the case of a type that was read in by the Reader

          if (al != null) al = null;

          if (this.securityAttributes != null) return this.securityAttributes;

        }

        return this.securityAttributes = new SecurityAttributeList(0);

      }

      set {

        this.securityAttributes = value;

      }

    }

#else

    internal SecurityAttributeList securityAttributes;

    public SecurityAttributeList SecurityAttributes{

      get{return this.securityAttributes;}

      internal set{this.securityAttributes = value;}

    }

    private LocalCollection locals;

    public LocalCollection Locals{

      get{

        if (locals == null) this.Body = this.Body;

        return this.locals;

      }

      internal set {

        this.locals = value;

      }

    }

    /// <summary>

    ///     Gets a value indicating whether the method is a property or event accessor.

    /// </summary>

    /// <value>

    ///     <see langword="true"/> if the <see cref="Method"/> is a property or event

    ///     accessor; otherwise, <see langword="false"/>.

    /// </value>

    /// <remarks>

    ///     <see cref="IsAccessor"/> returns <see langword="true"/> if 

    ///     <see cref="DeclaringMember"/> is not <see langword="null"/>.

    /// </remarks>

    public bool IsAccessor{

      get{return this.declaringMember != null;}

    }

    internal static bool EnforceMethodRepresentationCreationPolicy;

    internal static int PopulatedBodiesCount;

    internal static int PopulatedInstructionsCount;

#endif

    public delegate void MethodBodyProvider(Method/*!*/ method, object/*!*/ handle, bool asInstructionList);

    public MethodBodyProvider ProvideBody;

    public object ProviderHandle; //Opaque information to be used by the method body provider

#if ILOFFSETS

    public readonly int MethodToken;

    public Method(MethodBodyProvider provider, object handle, int methodToken)

      : this(provider, handle)

    {

      this.MethodToken = methodToken;

    }

#endif

    public Method()

      : base(NodeType.Method){

    }

    public Method(MethodBodyProvider provider, object handle)

      : base(NodeType.Method){

      this.ProvideBody = provider;

      this.ProviderHandle = handle;

    }

    public Method(TypeNode declaringType, AttributeList attributes, Identifier name, ParameterList parameters, TypeNode returnType, Block body)

      : base(declaringType, attributes, name, NodeType.Method){

      this.body = body;

      this.Parameters = parameters; // important to use setter here.

      this.returnType = returnType;

    }

    private MethodFlags flags;

    public MethodFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private MethodImplFlags implFlags;

    public MethodImplFlags ImplFlags{

      get{return this.implFlags;}

      set{this.implFlags = value;}

    }

    private MethodList implementedInterfaceMethods;

    public MethodList ImplementedInterfaceMethods{

      get{return this.implementedInterfaceMethods;}

      set{this.implementedInterfaceMethods = value;}

    }

#if !MinimalReader

    private MethodList implicitlyImplementedInterfaceMethods;

    /// <summary>

    /// Computes the implicitly implemented methods for any method, not necessarily being compiled.

    /// </summary>

    public MethodList ImplicitlyImplementedInterfaceMethods{

      get{

        if (this.implicitlyImplementedInterfaceMethods == null){

          this.implicitlyImplementedInterfaceMethods = new MethodList();

          // There are several reasons that this method cannot implicitly implement any interface method.

          if ((this.ImplementedInterfaceMethods == null || this.ImplementedInterfaceMethods.Count == 0) && this.IsPublic && !this.IsStatic){

            // It can implicitly implement an interface method for those interfaces that

            // the method's type explicitly declares it implements

            if (this.DeclaringType != null && this.DeclaringType.Interfaces != null){

              foreach (Interface i in this.DeclaringType.Interfaces){

                if (i == null) continue;

                Method match = i.GetMatchingMethod(this);

                // But it cannot implicitly implement an interface method if there is

                // an explicit implementation in the same type.

                if (match != null && match.ReturnType == this.ReturnType && !this.DeclaringType.ImplementsExplicitly(match))

                  this.implicitlyImplementedInterfaceMethods.Add(match);

              }

            }

            // It can implicitly implement an interface method if it overrides a base class

            // method and *that* method implicitly implements the interface method.

            // (Note: if this method's type does *not* explicitly declare that it implements

            // the interface, then unless the method overrides a method that does, it is *not*

            // used as an implicit implementation.)

            if (this.OverriddenMethod != null){

              foreach (Method method in this.OverriddenMethod.ImplicitlyImplementedInterfaceMethods)

                // But it cannot implicitly implement an interface method if there is

                // an explicit implementation in the same type.

                if (!this.DeclaringType.ImplementsExplicitly(method)) {

                  int i = 0;

                  int n = this.implicitlyImplementedInterfaceMethods.Count;

                  while (i < n) {

                    Method alreadyImplementedMethod = this.implicitlyImplementedInterfaceMethods[i];

                    if (alreadyImplementedMethod == method) break; // don't add it twice

                    i++;

                  }

                  if (i == n)

                    this.implicitlyImplementedInterfaceMethods.Add(method);

                }

            }

          }

        }

        return this.implicitlyImplementedInterfaceMethods;

      }

      set {

        this.implicitlyImplementedInterfaceMethods = value;

      }

    }

#endif

    private CallingConventionFlags callingConvention;

    public CallingConventionFlags CallingConvention{

      get{return this.callingConvention;}

      set{this.callingConvention = value;}

    }

    private bool initLocals = true;

    /// <summary>True if all local variables are to be initialized to default values before executing the method body.</summary>

    public bool InitLocals{

      get{return this.initLocals;}

      set{this.initLocals = value;}

    }

    private bool isGeneric;

    /// <summary>True if this method is a template that conforms to the rules for a CLR generic method.</summary>

    public bool IsGeneric{

      get{return this.isGeneric;}

      set{this.isGeneric = value;}

    }

    private ParameterList parameters;

    /// <summary>The parameters this method has to be called with.</summary>

    public ParameterList Parameters{

      get{return this.parameters;}

      set{

        this.parameters = value;

        if (value != null) {

          for (int i = 0, n = value.Count; i < n; i++) {

            Parameter par = parameters[i];

            if (par == null) continue;

            par.DeclaringMethod = this;

          }

        }

      }

    }

    private PInvokeFlags pInvokeFlags = PInvokeFlags.None;

    public PInvokeFlags PInvokeFlags{

      get{return this.pInvokeFlags;}

      set{this.pInvokeFlags = value;}

    }

    private Module pInvokeModule;

    public Module PInvokeModule{

      get{return this.pInvokeModule;}

      set{this.pInvokeModule = value;}

    }

    private string pInvokeImportName;

    public string PInvokeImportName{

      get{return this.pInvokeImportName;}

      set{this.pInvokeImportName = value;}

    }

    private AttributeList returnAttributes;

    /// <summary>Attributes that apply to the return value of this method.</summary>

    public AttributeList ReturnAttributes{

      get{return this.returnAttributes;}

      set{this.returnAttributes = value;}

    }

    private MarshallingInformation returnTypeMarshallingInformation;

    public MarshallingInformation ReturnTypeMarshallingInformation{

      get{return this.returnTypeMarshallingInformation;}

      set{this.returnTypeMarshallingInformation = value;}

    }

    private TypeNode returnType;

    /// <summary>The type of value that this method may return.</summary>

    public TypeNode ReturnType{

      get{return this.returnType;}

      set{this.returnType = value;}

    }

    private Member declaringMember;

    /// <summary>Provides the declaring event or property of an accessor.</summary>

    public Member DeclaringMember{

      get{

        if (this.declaringMember == null && this.DeclaringType != null && !this.DeclaringType.membersBeingPopulated) {

          MemberList dummyMembers = this.DeclaringType.Members; //evaluate for side effect of filling in declaringMember

        }

        return this.declaringMember;

      }

      set{this.declaringMember = value;}

    }

    private This thisParameter;

    public This ThisParameter{

      get{

        if (this.thisParameter == null && !this.IsStatic && this.DeclaringType != null) {

          if (this.DeclaringType.IsValueType)

            this.ThisParameter = new This(this.DeclaringType.GetReferenceType());

          else

            this.ThisParameter = new This(this.DeclaringType);

        }

        return this.thisParameter;

      }

      set{

        if (value != null) value.DeclaringMethod = this;

        this.thisParameter = value;

      }

    }

    protected internal Block body;

    /// <summary>The instructions constituting the body of this method, in the form of a tree.</summary>

    public virtual Block Body{

      get{

        if (this.body != null) return this.body;

        if (this.ProvideBody != null && this.ProviderHandle != null){

          lock (Module.GlobalLock){

            if (this.body == null){

              this.ProvideBody(this, this.ProviderHandle, false);

#if FxCop

              if (EnforceMethodRepresentationCreationPolicy && this.body.Statements.Count > 0)

                System.Threading.Interlocked.Increment(ref Method.PopulatedBodiesCount);

#endif

            }

          }

        }

        return this.body;

      }

      set{

#if FxCop

        if (EnforceMethodRepresentationCreationPolicy && value == null && this.body != null && this.body.Statements.Count > 0)

          System.Threading.Interlocked.Decrement(ref Method.PopulatedBodiesCount);

#endif

        this.body = value;

      }

    }

    /// <summary>

    /// A delegate that is called the first time Attributes is accessed, if non-null.

    /// Provides for incremental construction of the type node.

    /// Must not leave Attributes null.

    /// </summary>

    public MethodAttributeProvider ProvideMethodAttributes;

    /// <summary>

    /// The type of delegates that fill in the Attributes property of the given method.

    /// </summary>

    public delegate void MethodAttributeProvider(Method/*!*/ method, object/*!*/ handle);

    public override AttributeList Attributes {

      get{

        if (this.attributes == null){

          if (this.ProvideMethodAttributes != null && this.ProviderHandle != null){

            lock (Module.GlobalLock){

              if (this.attributes == null)

                this.ProvideMethodAttributes(this, this.ProviderHandle);

            }

          }else

            this.attributes = new AttributeList(0);

        }

        return this.attributes;

      }

      set{

        this.attributes = value;

      }

    }

#if FxCop

    internal void ClearBody(){

#else

    public void ClearBody(){

#endif

      lock(Module.GlobalLock){ 

        this.Body = null;

        this.Instructions = null;

#if !FxCop

        this.LocalList = null;

#else

        this.Locals = null;

#endif

      }

    }

    protected string conditionalSymbol;

    protected bool doesNotHaveAConditionalSymbol;

    public string ConditionalSymbol{

      get{

        if (this.doesNotHaveAConditionalSymbol) return null;

        if (this.conditionalSymbol == null){

          lock (this){

            if (this.conditionalSymbol != null) return this.conditionalSymbol;

            AttributeNode condAttr = this.GetAttribute(SystemTypes.ConditionalAttribute);

            if (condAttr != null && condAttr.Expressions != null && condAttr.Expressions.Count > 0){

              Literal lit = condAttr.Expressions[0] as Literal;

              if (lit != null){

                this.conditionalSymbol = lit.Value as string;

                if (this.conditionalSymbol != null) return this.conditionalSymbol;

              }

            }

            this.doesNotHaveAConditionalSymbol = true;

          }

        }

        return this.conditionalSymbol;

      }

      set{

        this.conditionalSymbol = value;

      }

    }

    protected InstructionList instructions;

    /// <summary>The instructions constituting the body of this method, in the form of a linear list of Instruction nodes.</summary>

    public virtual InstructionList Instructions{

      get{

        if (this.instructions != null) return this.instructions;

        if (this.ProvideBody != null && this.ProviderHandle != null){

          lock (Module.GlobalLock){

            if (this.instructions == null){

              this.ProvideBody(this, this.ProviderHandle, true);

#if FxCop

              if (EnforceMethodRepresentationCreationPolicy)

                  System.Threading.Interlocked.Increment(ref Method.PopulatedInstructionsCount);

#endif

            }

          }

        }

        return this.instructions;

      }

      set{

#if FxCop

        if (EnforceMethodRepresentationCreationPolicy && this.instructions != null && value == null)

          System.Threading.Interlocked.Decrement(ref Method.PopulatedInstructionsCount);

#endif

        this.instructions = value;

      }

    }

#if !FxCop

    protected ExceptionHandlerList exceptionHandlers;

    public virtual ExceptionHandlerList ExceptionHandlers{

      get{

        if (this.exceptionHandlers != null) return this.exceptionHandlers;

        Block dummy = this.Body;

        if (this.exceptionHandlers == null) this.exceptionHandlers = new ExceptionHandlerList(0);

        return this.exceptionHandlers;

      }

      set{

        this.exceptionHandlers = value;

      }

    }

#endif

#if !NoXml

    protected override Identifier GetDocumentationId(){

      if (this.Template != null) return this.Template.GetDocumentationId();

      StringBuilder sb = new StringBuilder(this.DeclaringType.DocumentationId.ToString());

      sb[0] = 'M';

      sb.Append('.');

      if (this.NodeType == NodeType.InstanceInitializer)

        sb.Append("#ctor");

      else if (this.Name != null){

        sb.Append(this.Name.ToString());

        if (TargetPlatform.GenericTypeNamesMangleChar != 0 && this.TemplateParameters != null && this.TemplateParameters.Count > 0) {

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(TargetPlatform.GenericTypeNamesMangleChar);

          sb.Append(this.TemplateParameters.Count);            

        }

      }

      ParameterList parameters = this.Parameters;

      for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){

        Parameter par = parameters[i];

        if (par == null || par.Type == null) continue;

        if (i == 0)

          sb.Append('(');

        else

          sb.Append(',');

        par.Type.AppendDocumentIdMangledName(sb, this.TemplateParameters, this.DeclaringType.TemplateParameters);

        if (i == n-1)

          sb.Append(')');

      }

      if (this.IsSpecialName && this.ReturnType != null && this.Name != null && 

        (this.Name.UniqueIdKey == StandardIds.opExplicit.UniqueIdKey || this.Name.UniqueIdKey == StandardIds.opImplicit.UniqueIdKey)){

        sb.Append('~');

        this.ReturnType.AppendDocumentIdMangledName(sb, this.TemplateParameters, this.DeclaringType.TemplateParameters);

      }

      return Identifier.For(sb.ToString());

    }

#endif

    protected internal string fullName;

    public override string/*!*/ FullName {

      get{

        if (this.fullName != null) return this.fullName;

        StringBuilder sb = new StringBuilder();

        if (this.DeclaringType != null) {

          sb.Append(this.DeclaringType.FullName);

          sb.Append('.');

          if (this.NodeType == NodeType.InstanceInitializer)

            sb.Append("#ctor");

          else if (this.Name != null)

            sb.Append(this.Name.ToString());

          ParameterList parameters = this.Parameters;

          for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++) {

            Parameter par = parameters[i];

            if (par == null || par.Type == null) continue;

            if (i == 0)

              sb.Append('(');

            else

              sb.Append(',');

            sb.Append(par.Type.FullName);

            if (i == n - 1)

              sb.Append(')');

          }

        }

        return this.fullName = sb.ToString();

      }

    }

#if ExtendedRuntime

    public override string HelpText {

      get {

        if (this.helpText != null)

          return this.helpText;

        StringBuilder sb = new StringBuilder(base.HelpText);

        // if there is already some help text, start the contract on a new line

        bool startWithNewLine = (sb.Length != 0);

        if (this.Contract != null){

          MethodContract mc = this.Contract;

          RequiresList rs = mc.Requires;

          if (rs != null && rs.Count == 0) { mc.Requires = null; rs = mc.Requires; }

          for (int i = 0, n = rs == null ? 0 : rs.Count; i < n; i++){

            Requires r = rs[i];

            if (r == null) continue;

            Expression e = r.Condition;

            if (e.SourceContext.StartPos < e.SourceContext.EndPos && e.SourceContext.SourceText != ""){

              if (startWithNewLine) sb.Append('\n');

              sb.Append("requires ");

              sb.Append(e.SourceContext.SourceText);

              sb.Append(";");

              startWithNewLine = true;

            }

          }

          EnsuresList es = mc.Ensures;

          if (es != null && es.Count == 0) { mc.Ensures = null; es = mc.Ensures; }

          if (es != null) {

            for (int i = 0, n = es.Count; i < n; i++) {

              Ensures e = es[i];

              if (e == null) continue;

              if (startWithNewLine) sb.Append('\n');

              EnsuresExceptional ee = e as EnsuresExceptional;

              if (ee != null) {

                sb.Append("throws ");

                if (ee.Variable != null) { sb.Append("("); }

                sb.Append(ee.Type.Name.ToString());

                if (ee.Variable != null) {

                  sb.Append(" ");

                  sb.Append(ee.Variable.SourceContext.SourceText);

                  sb.Append(")");

                }

              }

              if (e.PostCondition != null) {

                if (ee != null) {

                  sb.Append(" ");

                }

                Expression cond = e.PostCondition;

                sb.Append("ensures ");

                sb.Append(cond.SourceContext.SourceText);

              }

              sb.Append(";");

              startWithNewLine = true;

            }

          }

          ExpressionList exps = mc.Modifies;

          // Force deserialization in case that is needed

          if (exps != null && exps.Count == 0) { mc.Modifies = null; exps = mc.Modifies; }

          if (exps != null) {

            for (int i = 0, n = exps.Count; i < n; i++) {

              Expression mod = exps[i];

              if (mod != null && mod.SourceContext.StartPos < mod.SourceContext.EndPos && mod.SourceContext.SourceText != "") {

                if (startWithNewLine) sb.Append('\n');

                sb.Append("modifies ");

                sb.Append(mod.SourceContext.SourceText);

                sb.Append(";");

                startWithNewLine = true;

              }

            }

          }

        }

        return this.helpText = sb.ToString();

      }

      set {

        base.HelpText = value;

      }

    }

#endif

    public virtual string GetUnmangledNameWithoutTypeParameters(){

      return this.GetUnmangledNameWithoutTypeParameters(false);

    }

    public virtual string GetUnmangledNameWithoutTypeParameters(bool omitParameterTypes){

      StringBuilder sb = new StringBuilder();

      if (this.NodeType == NodeType.InstanceInitializer)

        sb.Append("#ctor");

      else if (this.Name != null) {

        string name = this.Name.ToString();

        int lastDot = name.LastIndexOf('.');

        int lastMangle = name.LastIndexOf('>');

        // explicit interface method overrides will have typenames in

        // their method name, which may also contain type parameters

        if (lastMangle < lastDot)

          lastMangle = -1;

        if (lastMangle > 0)

          sb.Append(name.Substring(0, lastMangle+1));

        else

          sb.Append(name);

      }

      if (omitParameterTypes) return sb.ToString();

      ParameterList parameters = this.Parameters;

      for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++) {

        Parameter par = parameters[i];

        if (par == null || par.Type == null) continue;

        if (i == 0)

          sb.Append('(');

        else

          sb.Append(',');

        sb.Append(par.Type.GetFullUnmangledNameWithTypeParameters());

        if (i == n - 1) {

#if !MinimalReader

          if (this.IsVarArg) {

            sb.Append(", __arglist");

          }

#endif

          sb.Append(')');

        }

      }

      return sb.ToString();

    }

    public virtual string GetUnmangledNameWithTypeParameters(){

      return this.GetUnmangledNameWithTypeParameters(false);

    }

    public virtual string GetUnmangledNameWithTypeParameters(bool omitParameterTypes){

      StringBuilder sb = new StringBuilder();

      sb.Append(this.GetUnmangledNameWithoutTypeParameters(true));

      TypeNodeList templateParameters = this.TemplateParameters;

      for (int i = 0, n = templateParameters == null ? 0 : templateParameters.Count; i < n; i++){

        TypeNode tpar = templateParameters[i];

        if (tpar == null) continue;

        if (i == 0)

          sb.Append('<');

        else

          sb.Append(',');

        sb.Append(tpar.Name.ToString());

        if (i == n-1)

          sb.Append('>');

      }

      if (omitParameterTypes) return sb.ToString();

      ParameterList parameters = this.Parameters;

      for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){

        Parameter par = parameters[i];

        if (par == null || par.Type == null) continue;

        if (i == 0)

          sb.Append('(');

        else

          sb.Append(',');

        sb.Append(par.Type.GetFullUnmangledNameWithTypeParameters());

        if (i == n-1)

          sb.Append(')');

      }

      return sb.ToString();

    }

    public virtual string GetFullUnmangledNameWithTypeParameters(){

      return this.GetFullUnmangledNameWithTypeParameters(false);

    }

    public virtual string GetFullUnmangledNameWithTypeParameters(bool omitParameterTypes){

      StringBuilder sb = new StringBuilder();

      sb.Append(this.DeclaringType.GetFullUnmangledNameWithTypeParameters());

      sb.Append('.');

      sb.Append(this.GetUnmangledNameWithTypeParameters());

      return sb.ToString();

    }

    public static MethodFlags GetVisibilityUnion(Method m1, Method m2){

      if (m1 == null && m2 != null) return m2.Flags & MethodFlags.MethodAccessMask;

      if (m2 == null && m1 != null) return m1.Flags & MethodFlags.MethodAccessMask;

      if (m1 == null || m2 == null) return MethodFlags.CompilerControlled;

      return Method.GetVisibilityUnion(m1.Flags, m2.Flags);

    }

    public static MethodFlags GetVisibilityUnion(MethodFlags vis1, MethodFlags vis2){

      vis1 &= MethodFlags.MethodAccessMask;

      vis2 &= MethodFlags.MethodAccessMask;

      switch (vis1){

        case MethodFlags.Public:

          return MethodFlags.Public;

        case MethodFlags.Assembly:

        switch (vis2){

          case MethodFlags.Public:

            return MethodFlags.Public;

          case MethodFlags.FamORAssem:

          case MethodFlags.Family:

            return MethodFlags.FamORAssem;

          default:

            return vis1;

        }

        case MethodFlags.FamANDAssem:

        switch (vis2){

          case MethodFlags.Public:

            return MethodFlags.Public;

          case MethodFlags.Assembly:

            return MethodFlags.Assembly;

          case MethodFlags.FamORAssem:

            return MethodFlags.FamORAssem;

          case MethodFlags.Family:

            return MethodFlags.Family;

          default:

            return vis1;

        }

        case MethodFlags.FamORAssem:

        switch (vis2){

          case MethodFlags.Public:

            return MethodFlags.Public;

          default:

            return vis1;

        }

        case MethodFlags.Family:

        switch (vis2){

          case MethodFlags.Public:

            return MethodFlags.Public;

          case MethodFlags.FamORAssem:

          case MethodFlags.Assembly:

            return MethodFlags.FamORAssem;

          default:

            return vis1;

        }

        default:

          return vis2;

      }

    }

#if !NoReflection

    public virtual object Invoke(object targetObject, params object[] arguments){

      System.Reflection.MethodInfo methInfo = this.GetMethodInfo();

      if (methInfo == null) return null;

      return methInfo.Invoke(targetObject, arguments);

    }

    public virtual Literal Invoke(Literal/*!*/ targetObject, params Literal[] arguments){

      int n = arguments == null ? 0 : arguments.Length;

      object[] args = n == 0 ? null : new object[n];

      if (args != null && arguments != null)

        for (int i = 0; i < n; i++) {

          Literal lit = arguments[i];

          args[i] = lit == null ? null : lit.Value;

        }

      return new Literal(this.Invoke(targetObject.Value, args));

    }

#endif

#if !MinimalReader

    protected bool isNormalized;

    public virtual bool IsNormalized{

      get{

        if (this.isNormalized) return true;

        if (this.DeclaringType == null || this.SourceContext.Document != null) return false;

        return this.isNormalized = this.DeclaringType.IsNormalized;

      }

      set{

        this.isNormalized = value;

      }

    }

#endif

    public virtual bool IsAbstract{

      get{return (this.Flags & MethodFlags.Abstract) != 0;}

    }

    public override bool IsAssembly{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.Assembly;}

    }

    public override bool IsCompilerControlled{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.CompilerControlled;}

    }

    public virtual bool IsExtern{

      get{return (this.Flags & MethodFlags.PInvokeImpl) != 0 || (this.ImplFlags & (MethodImplFlags.Runtime|MethodImplFlags.InternalCall)) != 0;}

    }

    public override bool IsFamily{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.Family;}

    }

    public override bool IsFamilyAndAssembly{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.FamANDAssem;}

    }

    public override bool IsFamilyOrAssembly{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.FamORAssem;}

    }

    public virtual bool IsFinal{

      get{return (this.Flags & MethodFlags.Final) != 0;}

    }

#if !MinimalReader

    public virtual bool IsInternalCall {

      get { return (this.ImplFlags & MethodImplFlags.InternalCall) != 0; }

    }

#endif

    public override bool IsPrivate {

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.Private;}

    }

    public override bool IsPublic{

      get{return (this.Flags & MethodFlags.MethodAccessMask) == MethodFlags.Public;}

    }

    public override bool IsSpecialName{

      get{return (this.Flags & MethodFlags.SpecialName) != 0;}

    }

    public override bool IsStatic{

      get{return (this.Flags & MethodFlags.Static) != 0;}

    }

    /// <summary>

    /// True if this method can in principle be overridden by a method in a derived class.

    /// </summary>

    public virtual bool IsVirtual{

      get{return (this.Flags & MethodFlags.Virtual) != 0;}

    }

#if !MinimalReader

    public virtual bool IsNonSealedVirtual{

      get{

        return (this.Flags & MethodFlags.Virtual) != 0 && (this.Flags & MethodFlags.Final) == 0 && 

          (this.DeclaringType == null || (this.DeclaringType.Flags & TypeFlags.Sealed) == 0);

      }

    }

    public virtual bool IsVirtualAndNotDeclaredInStruct{

      get{

        return (this.Flags & MethodFlags.Virtual) != 0 && (this.DeclaringType == null || !(this.DeclaringType is Struct));

      }

    }

#endif

    public override bool IsVisibleOutsideAssembly{

      get{

        if (this.DeclaringType != null && !this.DeclaringType.IsVisibleOutsideAssembly) return false;

        switch(this.Flags & MethodFlags.MethodAccessMask){

          case MethodFlags.Public:

            return true;

          case MethodFlags.Family:

          case MethodFlags.FamORAssem:

            if (this.DeclaringType != null && !this.DeclaringType.IsSealed) return true;

            goto default;

          default:

            for (int i = 0, n = this.ImplementedInterfaceMethods == null ? 0 : this.ImplementedInterfaceMethods.Count; i < n; i++){

              Method m = this.ImplementedInterfaceMethods[i];

              if (m == null) continue;

              if (m.DeclaringType != null && !m.DeclaringType.IsVisibleOutsideAssembly) continue;

              if (m.IsVisibleOutsideAssembly) return true;

            }

            return false;

        }

      }

    }

#if ExtendedRuntime

    /// <summary>

    /// VERY IMPORTANT! This property is true only for those pure methods that are *neither*

    /// confined [Reads(Owned)] *nor* state independent [Reads(Nothing)]

    /// </summary>

    public bool IsPure{

      get{

        AttributeNode attr = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.PureAttribute);

        if (attr == null) return false; // no [Pure] at all

        ExpressionList exprs = attr.Expressions;

        if (exprs != null && 0 < exprs.Count) {

          Literal lit = exprs[0] as Literal;

          if (lit != null && (lit.Value is bool)) {

            bool val = (bool)lit.Value;

            if (!val) return false; // [Pure(false)]

          }

        }

        // pure methods must be marked as [Pure] *and* [Reads(Everything)]

        AttributeNode a = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.ReadsAttribute);

        if (a == null) return false;

        Literal l = a.GetPositionalArgument(0) as Literal;

        if (l == null) return false; // because default ctor for Reads sets it to "Owned", not "Everything"

        Microsoft.Contracts.ReadsAttribute.Reads r = (Microsoft.Contracts.ReadsAttribute.Reads)l.Value;

        return r == Microsoft.Contracts.ReadsAttribute.Reads.Everything;

      }

    }

    public bool ApplyDefaultContract {

      get{

        return this.GetAttribute(SystemTypes.NoDefaultContractAttribute) == null;

      }

    }

    public bool IsPropertyGetter{

      get{

        if (this.DeclaringMember == null) return false;

        Property p = this.DeclaringMember as Property;

        if (p == null) return false;

        if (p.Getter == this) return true;

        if (this.Template != null) {

          p = this.Template.DeclaringMember as Property;

          if (p != null) return p.Getter == this.Template;

        }

        return false;

      }

    }

    public bool IsPropertySetter {

      get {

        if (this.DeclaringMember == null) return false;

        Property p = this.DeclaringMember as Property;

        if (p == null) return false;

        if (p.Setter == this) return true;

        if (this.Template != null) {

          p = this.Template.DeclaringMember as Property;

          if (p != null) return p.Setter == this.Template;

        }

        return false;

      }

    }

    public bool IsConfined {

      get{

        if (this.DeclaringType is Struct || this.IsStatic) return false; // structs can't own anything



        // default: instance property getters are confined

        if (this.ApplyDefaultContract && this.IsPropertyGetter &&

           this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.PureAttribute) == null) {

          return true;

        }

        

        // TODO: Remove the next if test after LKG > 11215 (20 December 2007)

        if (this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.ConfinedAttribute) != null) return true;



        AttributeNode attr = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.PureAttribute);

        if (attr == null)

          return false; // not pure at all, so how could it be confined?

        // Make sure it isn't [Pure(false)]

        ExpressionList exprs = attr.Expressions;

        if (exprs != null && 0 < exprs.Count) {

          Literal lit = exprs[0] as Literal;

          if (lit != null && (lit.Value is bool)) {

            bool val = (bool)lit.Value;

            if (!val) return false; // [Pure(false)]

          }

        }



        AttributeNode a = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.ReadsAttribute);

        if (a == null) {

          // [Pure] by itself means confined on an instance method in a class

          // otherwise, must specify Reads(Owned) in order to be considered confined

          return !this.IsStatic;

        }

        Literal l = a.GetPositionalArgument(0) as Literal;

        if (l == null) return true; // because default ctor for Reads sets it that way

        Microsoft.Contracts.ReadsAttribute.Reads r = (Microsoft.Contracts.ReadsAttribute.Reads)l.Value;

        return r == Microsoft.Contracts.ReadsAttribute.Reads.Owned;

      }

    }

    public bool IsWriteConfined {

      get {

        return this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.WriteConfinedAttribute) != null

            || IsConfined || IsStateIndependent;

      }

    }

    public bool IsStateIndependent{

      get{

        if (this.ApplyDefaultContract && this.IsPropertyGetter && (this.DeclaringType is Struct || this.IsStatic) &&

           this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.PureAttribute) == null) {

          return true;

        }

        

        // TODO: Remove the next if test after LKG > 11215 (20 December 2007)

        if (this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.StateIndependentAttribute) != null) return true;



        AttributeNode attr = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.PureAttribute);

        if (attr == null)

          return false; // not pure at all, so how could it be confined?

        // Make sure it isn't [Pure(false)]

        ExpressionList exprs = attr.Expressions;

        if (exprs != null && 0 < exprs.Count) {

          Literal lit = exprs[0] as Literal;

          if (lit != null && (lit.Value is bool)) {

            bool val = (bool)lit.Value;

            if (!val) return false; // [Pure(false)]

          }

        }



        AttributeNode a = this.GetAttributeFromSelfOrDeclaringMember(SystemTypes.ReadsAttribute);

        if (a == null) {

          // [Pure] by itself means state independent on an instance method in a struct

          // or any a static method (either in a struct or in a class)

          // otherwise, must specify Reads(Nothing) in order to be considered state independent

          return this.IsStatic || this.DeclaringType is Struct;

        }

        Literal l = a.GetPositionalArgument(0) as Literal;

        if (l == null) return false; // because default ctor for Reads sets it that way

        Microsoft.Contracts.ReadsAttribute.Reads r = (Microsoft.Contracts.ReadsAttribute.Reads)l.Value;

        return r == Microsoft.Contracts.ReadsAttribute.Reads.Nothing;

      }

    }

#endif

#if !MinimalReader

    public bool IsVarArg {

      get { return (this.CallingConvention & CallingConventionFlags.VarArg) != 0; }

    }

    // whether this is a FieldInitializerMethod (declared in Sing#)

    public virtual bool IsFieldInitializerMethod {

      get{

        return false;

      }

    }

#endif

    public override Member HiddenMember{

      get{

        return this.HiddenMethod;

      }

      set{

        this.HiddenMethod = (Method)value;

      }

    }

    public virtual Method HiddenMethod{

      get{

        if (this.hiddenMember == Method.NotSpecified) return null;

        Method hiddenMethod = this.hiddenMember as Method;

        if (hiddenMethod != null) return hiddenMethod;

        if (this.ProvideBody == null) return null;

        if (this.IsVirtual && (this.Flags & MethodFlags.VtableLayoutMask) != MethodFlags.NewSlot) return null;

        TypeNode baseType = this.DeclaringType.BaseType;

        while (baseType != null){

          MemberList baseMembers = baseType.GetMembersNamed(this.Name);

          if (baseMembers != null)

            for (int i = 0, n = baseMembers.Count; i < n; i++){

              Method bmeth = baseMembers[i] as Method;

              if (bmeth == null) continue;

              if (!bmeth.ParametersMatch(this.Parameters)){

                if (this.TemplateParameters != null && this.TemplateParametersMatch(bmeth.TemplateParameters)){

                  if (!bmeth.ParametersMatchStructurally(this.Parameters)) continue;

                }else

                  continue;

              }

              hiddenMethod = bmeth;

              goto done;

            }

          baseType = baseType.BaseType;   

        }

        done:

          if (hiddenMethod == null){

            this.hiddenMember = Method.NotSpecified;

            return null;

          }

        this.hiddenMember = hiddenMethod;

        return hiddenMethod;

      }

      set{

        this.hiddenMember = value;

      }

    }

    public override Member OverriddenMember{

      get{

        return this.OverriddenMethod;

      }

      set{

        this.OverriddenMethod = (Method)value;

      }

    }

    public virtual Method OverriddenMethod{

      get{

        if ((this.Flags & MethodFlags.VtableLayoutMask) == MethodFlags.NewSlot) return null;

        if (this.overriddenMember == Method.NotSpecified) return null;

        Method overriddenMethod = this.overriddenMember as Method;

        if (overriddenMethod != null) return overriddenMethod;

        if (this.ProvideBody == null) return null;

        if (!this.IsVirtual) return null;

        TypeNode baseType = this.DeclaringType.BaseType;

        while (baseType != null){

          MemberList baseMembers = baseType.GetMembersNamed(this.Name);

          if (baseMembers != null)

            for (int i = 0, n = baseMembers.Count; i < n; i++){

              Method bmeth = baseMembers[i] as Method;

              if (bmeth == null) continue;

              if (!bmeth.ParametersMatch(this.Parameters)){

                if (this.TemplateParameters != null && this.TemplateParametersMatch(bmeth.TemplateParameters)){

                  if (!bmeth.ParametersMatchStructurally(this.Parameters)) continue;

                }else

                  continue;

              }

              overriddenMethod = bmeth;

              goto done;

            }

          baseType = baseType.BaseType;   

        }

      done:

        if (overriddenMethod == null){

          this.overriddenMember = Method.NotSpecified;

          return null;

        }

        this.overriddenMember = overriddenMethod;

        return overriddenMethod;

      }

      set{

        this.overriddenMember = value;

      }

    }

#if !NoReflection

    public static Method GetMethod(System.Reflection.MethodInfo methodInfo){

      if (methodInfo == null) return null;

#if WHIDBEY

      if (methodInfo.IsGenericMethod && !methodInfo.IsGenericMethodDefinition){

        try{

          Method template = Method.GetMethod(methodInfo.GetGenericMethodDefinition());

          if (template == null) return null;

          TypeNodeList templateArguments = new TypeNodeList();

          foreach (Type arg in methodInfo.GetGenericArguments())

            templateArguments.Add(TypeNode.GetTypeNode(arg));

          return template.GetTemplateInstance(template.DeclaringType, templateArguments);

        }catch{

          //TODO: log error

          return null;

        }

      }

#endif

      TypeNode tn = TypeNode.GetTypeNode(methodInfo.DeclaringType);

      if (tn == null) return null;

      System.Reflection.ParameterInfo[] paramInfos = methodInfo.GetParameters();

      int n = paramInfos == null ? 0 : paramInfos.Length;

      TypeNode[] parameterTypes = new TypeNode[n];

      for (int i = 0; i < n; i++){

        System.Reflection.ParameterInfo param = paramInfos[i];

        if (param == null) return null;

        parameterTypes[i] = TypeNode.GetTypeNode(param.ParameterType);

      }

      TypeNodeList paramTypes = new TypeNodeList(parameterTypes);

      TypeNode returnType = TypeNode.GetTypeNode(methodInfo.ReturnType);

      MemberList members = tn.GetMembersNamed(Identifier.For(methodInfo.Name));

      for (int i = 0, m = members == null ? 0 : members.Count; i < m; i++){

        Method meth = members[i] as Method;

        if (meth == null) continue;

        if (!meth.ParameterTypesMatch(paramTypes)) continue;

        if (meth.ReturnType != returnType) continue;

        return meth;

      }

      return null;

    }

#endif

#if !NoReflection && !MinimalReader && WHIDBEY

    protected System.Reflection.Emit.DynamicMethod dynamicMethod;

    public virtual System.Reflection.Emit.DynamicMethod GetDynamicMethod(){

      return this.GetDynamicMethod(false);

    }

    public virtual System.Reflection.Emit.DynamicMethod GetDynamicMethod(bool skipVisibility)

      //^ requires this.DeclaringType != null && this.DeclaringType.DeclaringModule != null && this.IsNormalized && this.Name != null  && this.ReturnType != null;

      //^ requires (this.CallingConvention & CallingConventionFlags.ArgumentConvention) == CallingConventionFlags.StandardCall;

      //^ requires !this.IsGeneric;

    {

      if (this.dynamicMethod == null){

        if (this.DeclaringType == null || this.DeclaringType.DeclaringModule == null || !this.IsNormalized || this.Name == null || this.ReturnType == null){

          Debug.Assert(false); return null;

        }

        if ((this.CallingConvention & CallingConventionFlags.ArgumentConvention) != CallingConventionFlags.StandardCall || this.IsGeneric){

          Debug.Assert(false); return null;

        }

        string name = this.Name.Name;

        System.Reflection.MethodAttributes attrs = (System.Reflection.MethodAttributes)this.Flags;

        System.Reflection.CallingConventions callConv = System.Reflection.CallingConventions.Standard;

        callConv |= (System.Reflection.CallingConventions)(this.CallingConvention & ~CallingConventionFlags.ArgumentConvention);

        System.Type rtype = this.ReturnType.GetRuntimeType();

        System.Type owner = this.DeclaringType.GetRuntimeType();

        if (owner == null) { Debug.Fail(""); return null; }

        System.Reflection.Module module = owner.Module;

        System.Reflection.Emit.DynamicMethod dmeth;

        int numPars = this.Parameters == null ? 0 : this.Parameters.Count;

        System.Type[] paramTypes = new Type[numPars];

        for (int i = 0; i < numPars; i++){

          Parameter par = this.Parameters[i];

          if (par == null || par.Type == null){Debug.Assert(false); return null;}

          paramTypes[i] = par.Type.GetRuntimeType();

        }

        if (this.DeclaringType == this.DeclaringType.DeclaringModule.Types[0])

          dmeth = new System.Reflection.Emit.DynamicMethod(name, attrs, callConv, rtype, paramTypes, module, skipVisibility);

        else

          dmeth = new System.Reflection.Emit.DynamicMethod(name, attrs, callConv, rtype, paramTypes, owner, skipVisibility);

        dmeth.InitLocals = true;

        ReGenerator reGenerator = new ReGenerator(dmeth.GetILGenerator());

        reGenerator.VisitMethod(this);

      }

      return this.dynamicMethod;

    }

#endif

#if !NoReflection

    protected System.Reflection.MethodInfo methodInfo;

    public virtual System.Reflection.MethodInfo GetMethodInfo(){

      if (this.methodInfo == null){

        if (this.DeclaringType == null) return null;

#if WHIDBEY

        if (this.IsGeneric && this.Template != null){

          try{

            System.Reflection.MethodInfo templateInfo = this.Template.GetMethodInfo();

            if (templateInfo == null) return null;

            TypeNodeList args = this.TemplateArguments;

            Type[] arguments = new Type[args.Count];

            for (int i = 0; i < args.Count; i++) arguments[i] = args[i].GetRuntimeType();

            return templateInfo.MakeGenericMethod(arguments);

          }catch{

            //TODO: log error

            return null;

          }

        }

#endif

        Type t = this.DeclaringType.GetRuntimeType();

        if (t == null) return null;

        Type retType = typeof(object);

        if (!this.isGeneric) {

          //Can't do this for generic methods since it may involve a method type parameter

          retType = this.ReturnType.GetRuntimeType();

          if (retType == null) return null;

        }

        ParameterList pars = this.Parameters;

        int n = pars == null ? 0 : pars.Count;

        Type[] types = new Type[n];

        for (int i = 0; i < n; i++){

          Parameter p = pars[i];

          if (p == null || p.Type == null) return null;

          Type pt;

          if (this.isGeneric)

            pt = types[i] = typeof(object); //Have to cheat here since the type might involve a type parameter of the method and getting the runtime type for that is a problem

            //unless we already have the method info in hand

          else

            pt = types[i] = p.Type.GetRuntimeType();

          if (pt == null) return null;

        }

        System.Reflection.MemberInfo[] members = t.GetMember(this.Name.ToString(), System.Reflection.MemberTypes.Method, 

          BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Static|BindingFlags.Public|BindingFlags.NonPublic);

        foreach (System.Reflection.MethodInfo meth in members){

          if (meth == null) continue;

          if (meth.IsStatic != this.IsStatic) continue;

          if (meth.ReturnType != retType) continue;

#if WHIDBEY

          if (meth.IsGenericMethodDefinition) {

            TypeNodeList templateParams = this.TemplateParameters;

            Type[] genericArgs = meth.GetGenericArguments();

            if (templateParams == null || genericArgs == null || templateParameters.Count != genericArgs.Length) goto tryNext;

            for (int i = 0, m = genericArgs.Length; i < m; i++) {

              TypeNode t1 = templateParameters[i];

              Type t2 = genericArgs[i];

              if (t1 == null || t2 == null || t1.Name == null || t1.Name.Name != t2.Name) goto tryNext;

            }

          }

#endif

          System.Reflection.ParameterInfo[] parameters = meth.GetParameters();

          int parCount = parameters == null ? 0 : parameters.Length;

          if (parCount != n) continue;

          for (int i = 0; i < n; i++){

            //^ assert parameters != null;

            System.Reflection.ParameterInfo par = parameters[i];

            if (par == null) goto tryNext;

            if (this.isGeneric) {

              //We don't have the runtime type for the parameter, so just check that the name is the same

              Parameter p = pars[i];

              if (par.Name != p.Name.Name) goto tryNext;

            } else {

              if (par.ParameterType != types[i]) goto tryNext;

            }

          }

          return this.methodInfo = meth;

        tryNext:;

        }

      }

      return this.methodInfo;

    }

#endif

#if !MinimalReader

    protected TypeNode[] parameterTypes;

    public virtual TypeNode[]/*!*/ GetParameterTypes() {

      if (this.parameterTypes != null) return this.parameterTypes;

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      TypeNode[] types = this.parameterTypes = new TypeNode[n];

      for (int i = 0; i < n; i++){

        Parameter p = pars[i];

        if (p == null) continue;

        types[i] = p.Type;

      }

      return types;

    }

#endif

    public virtual bool ParametersMatch(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type != par2.Type) return false;

      }

      return true;

    }

#if !MinimalReader

    public virtual bool ParametersMatchExceptLast(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n-1; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type != par2.Type) return false;

      }

      return true;

    }

#endif

    public virtual bool ParametersMatchStructurally(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type == null || par2.Type == null) return false;

        if (par1.Type != par2.Type && !par1.Type.IsStructurallyEquivalentTo(par2.Type)) return false;

      }

      return true;

    }

#if !MinimalReader

    public virtual bool ParametersMatchStructurallyIncludingOutFlag(ParameterList parameters){

      return this.ParametersMatchStructurallyIncludingOutFlag(parameters, false);

    }

    public virtual bool ParametersMatchStructurallyIncludingOutFlag(ParameterList parameters, bool allowCoVariance){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type == null || par2.Type == null) return false;

        if ((par1.Flags&ParameterFlags.Out) != (par2.Flags&ParameterFlags.Out)) return false;

        if (par1.Type != par2.Type && !par1.Type.IsStructurallyEquivalentTo(par2.Type)){

          if (allowCoVariance && !par2.Type.IsValueType) return par2.Type.IsAssignableTo(par1.Type);

          return false;

        }

      }

      return true;

    }

    public virtual bool ParametersMatchStructurallyExceptLast(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n-1; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type == null || par2.Type == null) return false;

        if (par1.Type != par2.Type && !par1.Type.IsStructurallyEquivalentTo(par2.Type)) return false;

      }

      return true;

    }

    public virtual bool ParametersMatchIncludingOutFlag(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1.Type != par2.Type) return false;

        if ((par1.Flags&ParameterFlags.Out) != (par2.Flags&ParameterFlags.Out)) return false;

      }

      return true;

    }

#endif

    public virtual bool ParameterTypesMatch(TypeNodeList argumentTypes){

      int n = this.Parameters == null ? 0 : this.Parameters.Count;

      int m = argumentTypes == null ? 0 : argumentTypes.Count;

      if (n != m) return false;

      if (argumentTypes == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par = this.Parameters[i];

        if (par == null) return false;

        TypeNode argType = argumentTypes[i];

        if (par.Type != argType){

          TypeNode pType = TypeNode.StripModifiers(par.Type);

          argType = TypeNode.StripModifiers(argType);

          if (pType != argType) return false;

        }

      }

      return true;

    }

    public virtual bool ParameterTypesMatchStructurally(TypeNodeList argumentTypes){

      int n = this.Parameters == null ? 0 : this.Parameters.Count;

      int m = argumentTypes == null ? 0 : argumentTypes.Count;

      if (n != m) return false;

      if (argumentTypes == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par = this.Parameters[i];

        TypeNode argType = argumentTypes[i];

        if (par.Type != argType){

          TypeNode pType = TypeNode.StripModifiers(par.Type);

          argType = TypeNode.StripModifiers(argType);

          if (pType == null || !pType.IsStructurallyEquivalentTo(argType)) return false;

        }

      }

      return true;

    }

    public virtual bool TemplateParametersMatch(TypeNodeList templateParameters){

      TypeNodeList locPars = this.TemplateParameters;

      if (locPars == null) return templateParameters == null || templateParameters.Count == 0;

      if (templateParameters == null) return false;

      int n = locPars.Count;

      if (n != templateParameters.Count) return false;

      for (int i = 0; i < n; i++){

        TypeNode tp1 = locPars[i];

        TypeNode tp2 = templateParameters[i];

        if (tp1 == null || tp2 == null) return false;

        if (tp1 != tp2 && !tp1.IsStructurallyEquivalentTo(tp2)) return false;

      }

      return true;

    }

#if UseSingularityPDB

    internal TrivialHashtable contextForOffset;

    internal void RecordSequencePoints(PdbFunction methodInfo) {

      if (methodInfo == null || this.contextForOffset != null) return;

      this.contextForOffset = new TrivialHashtable();

      for (int i = 0, n = methodInfo.lines == null ? 0 : methodInfo.lines.Length; i < n; i++) {

        PdbLines lines = methodInfo.lines[i];

        PdbDocument doc = new PdbDocument(lines);

        for (int j = 0, m = lines.lines.Length; j < m; j++) {

          PdbLine line = lines.lines[j];

          if (line.line != 0xfeefee)

            this.contextForOffset[(int)line.offset+1] = new SourceContext(doc, j*2, j*2+1 );

        }

      }

    }

#elif !ROTOR

    internal TrivialHashtable contextForOffset;

    internal void RecordSequencePoints(ISymUnmanagedMethod methodInfo){

      if (methodInfo == null || this.contextForOffset != null) return;

      this.contextForOffset = new TrivialHashtable();

      uint count = methodInfo.GetSequencePointCount();

      IntPtr[] docPtrs = new IntPtr[count];

      uint[] startLines = new uint[count];

      uint[] startCols = new uint[count];

      uint[] endLines = new uint[count];

      uint[] endCols = new uint[count];

      uint[] offsets = new uint[count];

      uint numPoints;

      methodInfo.GetSequencePoints(count, out numPoints, offsets, docPtrs, startLines, startCols, endLines, endCols);

      Debug.Assert(count==numPoints);

      for (int i = 0; i < count; i++){

        //The magic hex constant below works around weird data reported from GetSequencePoints.

        //The constant comes from ILDASM's source code, which performs essentially the same test.

        const uint Magic = 0xFEEFEE;

        if (startLines[i] >= Magic || endLines[i] >= Magic) continue;

        UnmanagedDocument doc = new UnmanagedDocument(docPtrs[i]);

        this.contextForOffset[(int)offsets[i]+1] = 

#if !FxCop

          new SourceContext(doc, doc.GetOffset(startLines[i], startCols[i]), doc.GetOffset(endLines[i], endCols[i]));

#else

          new SourceContext(doc.Name, startLines[i], endLines[i], startCols[i], endCols[i]);

#endif

      }

      for (int i = 0; i < count; i++)

        System.Runtime.InteropServices.Marshal.Release(docPtrs[i]);

    }

#endif

    private static Method NotSpecified = new Method();

    private Method template;

    /// <summary>The (generic) method template from which this method was instantiated. Null if this is not a (generic) method template instance.</summary>

    public Method Template{

      get{

        Method result = this.template;

#if ExtendedRuntime

        if (result == null){

          AttributeList attributes = this.Attributes;

          lock(this){

            if (this.template != null) return this.template;

            for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

              AttributeNode attr = attributes[i];

              if (attr == null) continue;

              MemberBinding mb = attr.Constructor as MemberBinding;

              if (mb == null || mb.BoundMember == null || mb.BoundMember.DeclaringType != SystemTypes.TemplateInstanceAttribute) continue;

              ExpressionList exprs = attr.Expressions;

              if (exprs == null || exprs.Count != 2) continue;

              Literal lit = exprs[0] as Literal;

              if (lit == null) continue;

              TypeNode templ = lit.Value as TypeNode;

              if (templ != null){

                lit = exprs[1] as Literal;

                if (lit == null) continue;

                object[] types = lit.Value as object[];

                if (types == null) continue;

                int m = types == null ? 0 : types.Length;

                TypeNodeList templateArguments = new TypeNodeList(m);

                for (int j = 0; j < m; j++){

                  //^ assert types != null;

                  TypeNode t = types[j] as TypeNode;

                  if (t == null) continue;

                  templateArguments.Add(t);

                }

                this.TemplateArguments = templateArguments;

                MemberList members = templ.GetMembersNamed(this.Name);

                if (members != null)

                  for (int j = 0, k = members.Count; j < k; j++){

                    Method meth = members[j] as Method;

                    if (meth == null) continue;

                    if (meth.ParametersMatch(this.Parameters)){

                      this.template = result = meth; break;

                    }

                  }

              }

            }

            if (result == null)

              this.template = Method.NotSpecified;

          }

        }else 

#endif

          if (result == Method.NotSpecified)

          return null;

        return result;

      }

      set{

        this.template = value;

      }

    }

    private TypeNodeList templateArguments;

    /// <summary>

    /// The arguments used when this (generic) method template instance was instantiated.

    /// </summary>

    public TypeNodeList TemplateArguments{

      get{return this.templateArguments;}

      set{this.templateArguments = value;}

    }

    internal TypeNodeList templateParameters;

    public virtual TypeNodeList TemplateParameters{

      get{

        TypeNodeList result = this.templateParameters;

#if ExtendedRuntime

        if (result == null && this.Template == null){

          this.TemplateParameters = result = new TypeNodeList();

          AttributeList attributes = this.Attributes;

          for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

            AttributeNode attr = attributes[i];

            if (attr == null) continue;

            MemberBinding mb = attr.Constructor as MemberBinding;

            if (mb == null || mb.BoundMember == null || mb.BoundMember.DeclaringType != SystemTypes.TemplateAttribute) continue;

            ExpressionList exprs = attr.Expressions;

            if (exprs == null || exprs.Count != 1) continue;

            Literal lit = exprs[0] as Literal;

            if (lit == null) continue;

            object[] types = lit.Value as object[];

            if (types == null) continue;

            for (int j = 0, m = types == null ? 0 : types.Length; j < m; j++){

              TypeNode t = types[j] as TypeNode;

              if (t == null) continue;

              if (t.NodeType == NodeType.TypeParameter || t.NodeType == NodeType.ClassParameter)

                result.Add(t);

            }

            attributes[i] = null;

          }

        }

        if (result == null || result.Count == 0) return null;

#endif

        return result;

      }

      set{

        this.templateParameters = value;

      }

    }

    public virtual Method/*!*/ GetTemplateInstance(TypeNode referringType, params TypeNode[] typeArguments) {

      return this.GetTemplateInstance(referringType, new TypeNodeList(typeArguments));

    }

    public virtual Method/*!*/ GetTemplateInstance(TypeNode referringType, TypeNodeList typeArguments) {

      if (referringType == null || this.DeclaringType == null){Debug.Assert(false); return this;}

      if (this.IsGeneric) referringType = this.DeclaringType;

      if (referringType != this.DeclaringType && referringType.DeclaringModule == this.DeclaringType.DeclaringModule)

        return this.GetTemplateInstance(this.DeclaringType, typeArguments);

      if (referringType.structurallyEquivalentMethod == null)

        referringType.structurallyEquivalentMethod = new TrivialHashtableUsingWeakReferences();

      Module module = referringType.DeclaringModule;

      if (module == null) return this;

      int n = typeArguments == null ? 0 : typeArguments.Count;

      if (n == 0 || typeArguments == null) return this;

      StringBuilder sb = new StringBuilder(this.Name.ToString());

      sb.Append('<');

      for (int i = 0; i < n; i++){

        TypeNode ta = typeArguments[i]; if (ta == null) continue;

        sb.Append(ta.FullName);

        if (i < n-1) sb.Append(',');

      }

      sb.Append('>');

      Identifier mangledName = Identifier.For(sb.ToString());

      lock(this){

        Method m = (Method)referringType.structurallyEquivalentMethod[mangledName.UniqueIdKey];

        int counter = 1;

        while (m != null){

          if (m.template == this && Method.TypeListsAreEquivalent(m.TemplateArguments, typeArguments))

            return m;

          mangledName = Identifier.For(mangledName.ToString()+counter++);

          m = (Method)referringType.structurallyEquivalentMethod[mangledName.UniqueIdKey];

        }

        Duplicator duplicator = new Duplicator(referringType.DeclaringModule, referringType);

        duplicator.RecordOriginalAsTemplate = true;

        duplicator.SkipBodies = true;

        Method result = duplicator.VisitMethod(this);

        //^ assume result != null;

        result.Attributes = this.Attributes; //These do not get specialized, but may need to get normalized

        result.Name = mangledName;

        result.fullName = null;

        result.template = this;

        result.TemplateArguments = typeArguments;

        TypeNodeList templateParameters = result.TemplateParameters;

        result.TemplateParameters = null;

#if !MinimalReader

        result.IsNormalized = true;

#endif

        if (!this.IsGeneric){

          ParameterList pars = this.Parameters;

          ParameterList rpars = result.Parameters;

          if (pars != null && rpars != null && rpars.Count >= pars.Count)

            for (int i = 0, count = pars.Count; i < count; i++){

              Parameter p = pars[i];

              Parameter rp = rpars[i];

              if (p == null || rp == null) continue;

              rp.Attributes = p.Attributes; //These do not get specialized, but may need to get normalized

            }

        }

        if (!this.IsGeneric && !(result.IsStatic) && this.DeclaringType != referringType){

          result.Flags &= ~(MethodFlags.Virtual|MethodFlags.NewSlot);

          result.Flags |= MethodFlags.Static;

          result.CallingConvention &= ~CallingConventionFlags.HasThis;

          result.CallingConvention |= CallingConventionFlags.ExplicitThis;

          ParameterList pars = result.Parameters;

          if (pars == null) result.Parameters = pars = new ParameterList(1);

          Parameter thisPar = new Parameter(StandardIds.This, this.DeclaringType);

          pars.Add(thisPar);

          for (int i = pars.Count-1; i > 0; i--)

            pars[i] = pars[i-1];

          pars[0] = thisPar;

        }

        referringType.structurallyEquivalentMethod[mangledName.UniqueIdKey] = result;

        Specializer specializer = new Specializer(module, templateParameters, typeArguments);

        specializer.VisitMethod(result);

        if (this.IsGeneric){result.DeclaringType = this.DeclaringType; return result;}

        if (this.IsAbstract) return result;

        referringType.Members.Add(result);

        return result;

      }

    }

    private static bool TypeListsAreEquivalent(TypeNodeList list1, TypeNodeList list2){

      if (list1 == null || list2 == null) return list1 == list2;

      int n = list1.Count;

      if (n != list2.Count) return false;

      for (int i = 0; i < n; i++)

        if (list1[i] != list2[i]) return false;

      return true;

    }

#if !MinimalReader

    /// <summary>

    /// Returns the local associated with the given field, allocating a new local if necessary.

    /// </summary>

    public virtual Local/*!*/ GetLocalForField(Field/*!*/ f){

      Local loc = (Local)this.Locals[f.UniqueKey];

      if (loc == null){

        this.Locals[f.UniqueKey] = loc = new Local(f.Name, f.Type);

        loc.SourceContext = f.Name.SourceContext;

      }

      return loc;

    }

#endif

    //TODO: Also need to add a method for allocating locals

    public Method CreateExplicitImplementation(TypeNode implementingType, ParameterList parameters, StatementList body){

      Method m = new Method(implementingType, null, this.Name, parameters, this.ReturnType, new Block(body));

      m.CallingConvention = CallingConventionFlags.HasThis;

      m.Flags = MethodFlags.Public | MethodFlags.HideBySig | MethodFlags.Virtual | MethodFlags.NewSlot | MethodFlags.Final;

      m.ImplementedInterfaceMethods = new MethodList(this);

      //m.ImplementedTypes = new TypeNodeList(this.DeclaringType);

      return m;

    }



    public virtual bool TypeParameterCountsMatch(Method meth2){

      if (meth2 == null) return false;

      int n = this.TemplateParameters == null ? 0 : this.TemplateParameters.Count;

      int m = meth2.TemplateParameters == null ? 0 : meth2.TemplateParameters.Count;

      return n == m;

    }

    public override string ToString() {

      return this.DeclaringType.GetFullUnmangledNameWithTypeParameters() + "." + this.Name;

    }

#if !MinimalReader

    public bool GetIsCompilerGenerated() {

      InstanceInitializer ii = this as InstanceInitializer;

      return this.HasCompilerGeneratedSignature || (ii != null && ii.IsCompilerGenerated);

    }

#endif

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      base.GetName(options, name);

      AppendTypeParameters(options, name);

      AppendParametersAndReturnType(options, this.Parameters, '(', ')', this.ReturnType, name);

    }

    private void AppendTypeParameters(MemberFormat options, StringBuilder name)

    {

      if (options.ShowGenericMethodTypeParameterNames == false

        || this.templateParameters == null

        || this.templateParameters.Count == 0)

        return;



        name.Append('<');

        TypeNodeList templateParameters = this.TemplateParameters;

        for (int i = 0; i < templateParameters.Count; i++)

        {

          TypeNode templateParameter = templateParameters[i];

          if (i != 0)

          {

            name.Append(',');

            if (options.InsertSpacesBetweenMethodTypeParameters)

              name.Append(' ');

          }

          name.Append(templateParameter.Name.Name);

        }

        name.Append('>');

    }



    internal static void AppendParametersAndReturnType(MemberFormat options, ParameterCollection parameters, char parametersPrefix, char parametersSuffix, TypeNode returnType, StringBuilder name)

    {

      AppendParameters(options.Parameters, parameters, parametersPrefix, parametersSuffix, name);

      AppendReturnType(options.ReturnType, returnType, name);     

    }



    internal static void AppendParameters(ParameterFormat options, ParameterCollection parameters, char prefix, char suffix, StringBuilder name)

    {

        if (parameters == null)

            return;



        if (options.TypeName == TypeNameFormat.None && options.ShowParameterNames == false)

          return;



        name.Append(prefix);

        for (int i = 0; i < parameters.Count; ++i)

        {

          Parameter parameter = parameters[i];

          if (i > 0)

          {

            name.Append(',');

            if (options.InsertSpacesBetweenParameters)

              name.Append(' ');

          }

          if (options.TypeName != TypeNameFormat.None)

          {

            parameter.Type.GetName(options, name);

            if (options.ShowParameterNames) name.Append(' ');

          }

          if (options.ShowParameterNames)

            name.Append(parameter.Name.Name);

        }

        name.Append(suffix);

    }



    internal static void AppendReturnType(TypeFormat options, TypeNode returnType, StringBuilder name)

    {

      if (options.TypeName == TypeNameFormat.None)

        return;



      name.Append(':');

      returnType.GetName(options, name);

    }

#endif

  }

#if !MinimalReader

  public class ProxyMethod : Method{

    public Method ProxyFor;

    public ProxyMethod(TypeNode declaringType, AttributeList attributes, Identifier name, ParameterList parameters, TypeNode returnType, Block body)

      : base(declaringType, attributes, name, parameters, returnType, body) { }

  }

#endif

  public class InstanceInitializer : Method{

#if !MinimalReader

    /// <summary>

    /// True if this constructor calls a constructor declared in the same class, as opposed to the base class.

    /// </summary>

    public bool IsDeferringConstructor;

    /// <summary>

    /// When the source uses the C# compatibility mode, base calls cannot be put after non-null

    /// field initialization, but must be put before the body. But the user can specify where

    /// the base ctor call should be performed by using "base;" as a marker. During parsing

    /// this flag is set so the right code transformations can be performed at code generation.

    /// </summary>

    public bool ContainsBaseMarkerBecauseOfNonNullFields;

    public Block BaseOrDefferingCallBlock;

    public bool IsCompilerGenerated = false;

#endif

    public InstanceInitializer()

      : base(){

      this.NodeType = NodeType.InstanceInitializer;

      this.CallingConvention = CallingConventionFlags.HasThis;

      this.Flags = MethodFlags.SpecialName|MethodFlags.RTSpecialName;

      this.Name = StandardIds.Ctor;

      this.ReturnType = CoreSystemTypes.Void;

    }

    public InstanceInitializer(MethodBodyProvider provider, object handle)

      : base(provider, handle){

      this.NodeType = NodeType.InstanceInitializer;

    }

#if ILOFFSETS

    public InstanceInitializer(MethodBodyProvider provider, object handle, int methodToken)

      : base(provider, handle, methodToken)

    {

      this.NodeType = NodeType.InstanceInitializer;

    }

#endif

#if !MinimalReader

    public InstanceInitializer(TypeNode declaringType, AttributeList attributes, ParameterList parameters, Block body) 

      : this(declaringType, attributes, parameters, body, CoreSystemTypes.Void){

    }

    public InstanceInitializer(TypeNode declaringType, AttributeList attributes, ParameterList parameters, Block body, TypeNode returnType)

      : base(declaringType, attributes, StandardIds.Ctor, parameters, null, body){

      this.NodeType = NodeType.InstanceInitializer;

      this.CallingConvention = CallingConventionFlags.HasThis;

      this.Flags = MethodFlags.SpecialName|MethodFlags.RTSpecialName;

      this.Name = StandardIds.Ctor;

      this.ReturnType = returnType;

    }

#endif

#if !NoReflection

    protected System.Reflection.ConstructorInfo constructorInfo;

    public virtual System.Reflection.ConstructorInfo GetConstructorInfo(){

      if (this.constructorInfo == null){

        if (this.DeclaringType == null) return null;

        Type t = this.DeclaringType.GetRuntimeType();

        if (t == null) return null; 

        ParameterList pars = this.Parameters;

        int n = pars == null ? 0 : pars.Count;

        Type[] types = new Type[n];

        for (int i = 0; i < n; i++){

          Parameter p = pars[i];

          if (p == null || p.Type == null) return null;

          Type pt = types[i] = p.Type.GetRuntimeType();

          if (pt == null) return null;

        }

        System.Reflection.MemberInfo[] members = t.GetMember(this.Name.ToString(), System.Reflection.MemberTypes.Constructor, 

          BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);

        foreach (System.Reflection.ConstructorInfo cons in members){

          if (cons == null) continue;

          System.Reflection.ParameterInfo[] parameters = cons.GetParameters();

          if (parameters != null) {

            if (parameters.Length != n) continue;

            for (int i = 0; i < n; i++) {

              System.Reflection.ParameterInfo par = parameters[i];

              if (par == null || par.ParameterType != types[i]) goto tryNext;

            }

          }

          return this.constructorInfo = cons;

        tryNext:;

        }

      }

      return this.constructorInfo;

    }

#endif

#if !NoReflection

    public override System.Reflection.MethodInfo GetMethodInfo(){

      return null;

    }

    public virtual object Invoke(params object[] arguments){

      System.Reflection.ConstructorInfo constr = this.GetConstructorInfo();

      if (constr == null) return null;

      return constr.Invoke(arguments);

    }

    public virtual Literal Invoke(params Literal[] arguments){

      int n = arguments == null ? 0 : arguments.Length;

      object[] args = n == 0 ? null : new object[n];

      if (args != null && arguments != null)

        for (int i = 0; i < n; i++) {

          Literal lit = arguments[i];

          args[i] = lit == null ? null : lit.Value;

        }

      return new Literal(this.Invoke(args));

    }

#endif

    //initializers never override a base class initializer

    public override bool OverridesBaseClassMember {

      get { return false; }

      set { }

    }

    public override Member OverriddenMember {

      get { return null; }

      set {}

    }

    public override Method OverriddenMethod {

      get { return null; }

      set {}

    }

    public override string ToString() {

      return this.DeclaringType.GetFullUnmangledNameWithTypeParameters() + "(" + this.Parameters + ")";

    }

#if !MinimalReader

    public virtual MemberList GetAttributeConstructorNamedParameters() {

      TypeNode type = this.DeclaringType;

      if (type == null || !type.IsAssignableTo(SystemTypes.Attribute) || type.Members == null)

        return null;

      MemberList memList = type.Members;

      int n = memList.Count;

      MemberList ml = new MemberList(memList.Count);

      for (int i = 0; i < n; ++i) {

        Property p = memList[i] as Property;

        if (p != null && p.IsPublic) {

          if (p.Setter != null && p.Getter != null)

            ml.Add(p);

          continue;

        }

        Field f = memList[i] as Field;

        if (f != null && !f.IsInitOnly && f.IsPublic) {

          ml.Add(f);

        }

      }

      return ml;

    }

#endif

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      GetInitializerName(options, this.DeclaringType, this.Parameters, name, StandardIds.Ctor.Name);

    }

    internal static void GetInitializerName(MemberFormat options, TypeNode declaringType, ParameterCollection parameters, StringBuilder name, string methodName)

    {

      if (options.Type.TypeName != TypeNameFormat.None)

      {

        declaringType.GetName(options, name);

        name.Append('.');

      }

      name.Append(methodName);

      AppendParameters(options.Parameters, parameters, '(', ')', name);

    }

#endif

  }

  public class StaticInitializer : Method{

    public StaticInitializer()

      : base(){

      this.NodeType = NodeType.StaticInitializer;

      this.Flags = MethodFlags.SpecialName|MethodFlags.RTSpecialName|MethodFlags.Static|MethodFlags.HideBySig|MethodFlags.Private;

      this.Name = StandardIds.CCtor;

      this.ReturnType = CoreSystemTypes.Void;

    }

#if ILOFFSETS

    public StaticInitializer(MethodBodyProvider provider, object handle, int methodToken)

      : base(provider, handle, methodToken)

    {

      this.NodeType = NodeType.StaticInitializer;

    }

#endif

    public StaticInitializer(MethodBodyProvider provider, object handle)

      : base(provider, handle){

      this.NodeType = NodeType.StaticInitializer;

    }

#if !MinimalReader

    public StaticInitializer(TypeNode declaringType, AttributeList attributes, Block body)

      : base(declaringType, attributes, StandardIds.CCtor,  null, null, body){

      this.NodeType = NodeType.StaticInitializer;

      this.Flags = MethodFlags.SpecialName|MethodFlags.RTSpecialName|MethodFlags.Static|MethodFlags.HideBySig|MethodFlags.Private;

      this.Name = StandardIds.CCtor;

      this.ReturnType = CoreSystemTypes.Void;

    }

    public StaticInitializer(TypeNode declaringType, AttributeList attributes, Block body, TypeNode voidTypeExpression)

      : base(declaringType, attributes, StandardIds.CCtor, null, null, body) {

      this.NodeType = NodeType.StaticInitializer;

      this.Flags = MethodFlags.SpecialName|MethodFlags.RTSpecialName|MethodFlags.Static|MethodFlags.HideBySig|MethodFlags.Private;

      this.Name = StandardIds.CCtor;

      this.ReturnType = voidTypeExpression;

    }

#endif

#if !NoReflection

    protected System.Reflection.ConstructorInfo constructorInfo;

    public virtual System.Reflection.ConstructorInfo GetConstructorInfo(){

      if (this.constructorInfo == null){

        if (this.DeclaringType == null) return null;

        Type t = this.DeclaringType.GetRuntimeType();

        if (t == null) return null; 

        ParameterList pars = this.Parameters;

        int n = pars == null ? 0 : pars.Count;

        Type[] types = new Type[n];

        for (int i = 0; i < n; i++){

          Parameter p = pars[i];

          if (p == null || p.Type == null) return null;

          Type pt = types[i] = p.Type.GetRuntimeType();

          if (pt == null) return null;

        }

        System.Reflection.MemberInfo[] members = t.GetMember(this.Name.ToString(), System.Reflection.MemberTypes.Constructor, 

          BindingFlags.DeclaredOnly|BindingFlags.Static|BindingFlags.Public|BindingFlags.NonPublic);

        foreach (System.Reflection.ConstructorInfo cons in members){

          if (cons == null) continue;

          System.Reflection.ParameterInfo[] parameters = cons.GetParameters();

          int numPars = parameters == null ? 0 : parameters.Length;

          if (numPars != n) continue;

          if (parameters != null)

            for (int i = 0; i < n; i++){

              System.Reflection.ParameterInfo par = parameters[i];

              if (par == null || par.ParameterType != types[i]) goto tryNext;

            }

          return this.constructorInfo = cons;

        tryNext:;

        }

      }

      return this.constructorInfo;

    }

    public override System.Reflection.MethodInfo GetMethodInfo(){

      return null;

    }

#endif

    //initializers never override a base class initializer

    public override bool OverridesBaseClassMember {

      get { return false; }

      set { }

    }

    public override Member OverriddenMember {

      get { return null; }

      set {}

    }

    public override Method OverriddenMethod {

      get { return null; }

      set {}

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      InstanceInitializer.GetInitializerName(options, this.DeclaringType, this.Parameters, name, StandardIds.CCtor.Name);

    }

#endif

  }

#if !MinimalReader

  public class FieldInitializerBlock : Block{

    public TypeNode Type;

    public bool IsStatic;

    public FieldInitializerBlock()

      : base(){

      this.NodeType = NodeType.FieldInitializerBlock;

    }

    public FieldInitializerBlock(TypeNode type, bool isStatic)

      : base(){

      this.NodeType = NodeType.FieldInitializerBlock;

      this.Type = type;

      this.IsStatic = isStatic;

    }

  }

#endif

#if !MinimalReader

  public class ParameterField : Field{

    protected Parameter parameter;

    public ParameterField(){

    }

    public ParameterField(TypeNode declaringType, AttributeList attributes, FieldFlags flags, Identifier name, 

      TypeNode Type, Literal defaultValue) 

      : base(declaringType, attributes, flags, name, Type, defaultValue){

    }

    public virtual Parameter Parameter{

      get{

        return this.parameter;

      }

      set{

        this.parameter = value;

      }

    }

  }

#endif

  public class Field : Member{

#if !MinimalReader

    /// <summary>Provides a value that is assigned to the field upon initialization.</summary>

    public Expression Initializer;

    public TypeNode TypeExpression;

    public bool HasOutOfBandContract;

    public InterfaceList ImplementedInterfaces;

    public InterfaceList ImplementedInterfaceExpressions;

    // if this is the backing field for some event, then ForEvent is that event

    public Event ForEvent;

    public bool IsModelfield = false; //set to true if this field serves as the representation of a modelfield in a class

#endif

    public Field()

      : base(NodeType.Field){

    }

    public Field(Identifier name)

      : base(NodeType.Field){

      this.Name = name;

    }

    public Field(TypeNode declaringType, AttributeList attributes, FieldFlags flags, Identifier name, 

      TypeNode type, Literal defaultValue)

      : base(declaringType, attributes, name, NodeType.Field){

      this.defaultValue = defaultValue;

      this.flags = flags;

      this.type = type;

    }

    private Literal defaultValue;

    /// <summary>The compile-time value to be substituted for references to this field if it is a literal.</summary>

    public Literal DefaultValue{ //TODO: rename this to LiteralValue

      get{return this.defaultValue;}

      set{this.defaultValue = value;}

    }

    private FieldFlags flags;

    public FieldFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private int offset;

    public int Offset{

      get{return this.offset;}

      set{this.offset = value;}

    }

    private bool isVolatile;

    /// <summary>True if the field may not be cached. Used for sharing data between multiple threads.</summary>

    public bool IsVolatile{

      get{return this.isVolatile;}

      set{this.isVolatile = value;}

    }

    private TypeNode type;

    /// <summary>The type of values that may be stored in the field.</summary>

    public TypeNode Type{

      get{return this.type;}

      set{this.type = value;}

    }

    private MarshallingInformation marshallingInformation;

    public MarshallingInformation MarshallingInformation{

      get{return this.marshallingInformation;}

      set{this.marshallingInformation = value;}

    }

    private byte[] initialData;

    public byte[] InitialData{

      get{return this.initialData;}

      set{this.initialData = value;}

    }

    internal PESection section;

    public PESection Section{

      get{return this.section;}

      set{this.section = value;}

    }

    protected string fullName;

    public override string/*!*/ FullName {

      get{

        string result = this.fullName;

        if (result == null)

          this.fullName = result = this.DeclaringType.FullName+"."+(this.Name == null ? "" : this.Name.ToString());

        return result;

      }

    }

#if !NoXml

    protected override Identifier GetDocumentationId(){

      StringBuilder sb = new StringBuilder();

      sb.Append("F:");

      if (this.DeclaringType == null) return Identifier.Empty;

      sb.Append(this.DeclaringType.FullName);

      sb.Append(".");

      if (this.Name == null) return Identifier.Empty;

      sb.Append(this.Name.Name);

      return Identifier.For(sb.ToString());

    }

#endif

#if !NoReflection

    public static Field GetField(System.Reflection.FieldInfo fieldInfo){

      if (fieldInfo == null) return null;

      TypeNode tn = TypeNode.GetTypeNode(fieldInfo.DeclaringType);

      if (tn == null) return null;

      return tn.GetField(Identifier.For(fieldInfo.Name));

    }

#endif

#if !NoReflection

    protected System.Reflection.FieldInfo fieldInfo;

    public virtual System.Reflection.FieldInfo GetFieldInfo(){

      if (this.fieldInfo == null){

        TypeNode tn = this.DeclaringType;

        if (tn == null) return null;

        Type t = tn.GetRuntimeType();

        if (t == null) return null;

        System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.DeclaredOnly;

        if (this.IsPublic) flags |= System.Reflection.BindingFlags.Public; else flags |= System.Reflection.BindingFlags.NonPublic;

        if (this.IsStatic) flags |= System.Reflection.BindingFlags.Static; else flags |= System.Reflection.BindingFlags.Instance; 

        this.fieldInfo = t.GetField(this.Name.ToString(), flags);

      }

      return this.fieldInfo;

    }

#endif

    /// <summary>True if all references to the field are replaced with a value that is determined at compile-time.</summary>

    public virtual bool IsLiteral{

      get{return (this.Flags & FieldFlags.Literal) != 0;}

    }

    public override bool IsAssembly{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.Assembly;}

    }

    public override bool IsCompilerControlled{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.CompilerControlled;}

    }

    public override bool IsFamily{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.Family;}

    }

    public override bool IsFamilyAndAssembly{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.FamANDAssem;}

    }

    public override bool IsFamilyOrAssembly{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.FamORAssem;}

    }

    /// <summary>True if the field may only be assigned to inside the constructor.</summary>

    public virtual bool IsInitOnly{

      get{return (this.Flags & FieldFlags.InitOnly) != 0;}

    }

    public override bool IsPrivate{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.Private;}

    }

    public override bool IsPublic{

      get{return (this.Flags & FieldFlags.FieldAccessMask) == FieldFlags.Public;}

    }

    public override bool IsSpecialName{

      get{return (this.Flags & FieldFlags.SpecialName) != 0;}

    }

    public override bool IsStatic{

      get{return (this.Flags & FieldFlags.Static) != 0;}

    }

    public override bool IsVisibleOutsideAssembly{

      get{

        if (this.DeclaringType != null && !this.DeclaringType.IsVisibleOutsideAssembly) return false;

        switch(this.Flags & FieldFlags.FieldAccessMask){

          case FieldFlags.Public:

            return true;

          case FieldFlags.Family:

          case FieldFlags.FamORAssem:

            return this.DeclaringType != null && !this.DeclaringType.IsSealed;

          default:

            return false;

        }

      }

    }    

#if !NoReflection

    public virtual object GetValue(object targetObject){

      System.Reflection.FieldInfo fieldInfo = this.GetFieldInfo();

      if (fieldInfo == null) return null;

      return fieldInfo.GetValue(targetObject);

    }

    public virtual Literal GetValue(Literal/*!*/ targetObject){

      return new Literal(this.GetValue(targetObject.Value));

    }

    public virtual void SetValue(object targetObject, object value){

      System.Reflection.FieldInfo fieldInfo = this.GetFieldInfo();

      if (fieldInfo == null) return;

      fieldInfo.SetValue(targetObject, value);

    }

    public virtual void SetValue(Literal/*!*/ targetObject, Literal/*!*/ value) {

      this.SetValue(targetObject.Value, value.Value);

    }

#endif    

#if ExtendedRuntime

    ReferenceFieldSemantics referenceSemantics;

    public ReferenceFieldSemantics ReferenceSemantics{

      get{

        if (this.referenceSemantics == ReferenceFieldSemantics.NotComputed){

          ReferenceFieldSemantics referenceKind;

          TypeNode t = this.Type;

          if (t == null) return this.referenceSemantics;

          if (t is Struct){

            TypeNodeList args;

            bool b = t.IsAssignableToInstanceOf(SystemTypes.GenericIEnumerable, out args);

            if ( b && args!= null && args.Count > 0 && args[0] != null && args[0].IsObjectReferenceType)

              referenceKind = ReferenceFieldSemantics.EnumerableStructOfReferences;

            else if (t.IsAssignableTo(SystemTypes.IEnumerable))

              referenceKind = ReferenceFieldSemantics.EnumerableStructOfReferences;

            else

              referenceKind = ReferenceFieldSemantics.NonReference;

          }else if (t != null && t.IsObjectReferenceType)

            referenceKind = ReferenceFieldSemantics.Reference;

          else

            referenceKind = ReferenceFieldSemantics.NonReference;

          if (referenceKind == ReferenceFieldSemantics.NonReference)

            this.referenceSemantics = referenceKind | ReferenceFieldSemantics.None;

          else{

            if (this.GetAttribute(SystemTypes.LockProtectedAttribute) != null)

              this.referenceSemantics = referenceKind | ReferenceFieldSemantics.LockProtected;

            else if (this.GetAttribute(SystemTypes.ImmutableAttribute) != null)

              this.referenceSemantics = referenceKind | ReferenceFieldSemantics.Immutable;

            else if (this.GetAttribute(SystemTypes.RepAttribute) != null)

              this.referenceSemantics = referenceKind | ReferenceFieldSemantics.Rep;

            else if (this.GetAttribute(SystemTypes.PeerAttribute) != null)

              this.referenceSemantics = referenceKind | ReferenceFieldSemantics.Peer;

            else {

              ReferenceFieldSemantics r = ReferenceFieldSemantics.None;

              this.referenceSemantics = referenceKind | r;

            }

          }

        }

        return this.referenceSemantics;

      }

      set {

        this.referenceSemantics = value;

      }

    }

    public bool IsOwned{

      get{

        return this.IsRep || this.IsPeer;

      }

    }

      public bool IsOnce

      {

          get {

              return this.GetAttribute(SystemTypes.OnceAttribute) != null;

          }

      }



    public bool IsRep{

      get {

        return this.ReferenceSemantics == (ReferenceFieldSemantics.Rep | ReferenceFieldSemantics.Reference);

      }

    }

    public bool IsPeer {

      get {

        return this.ReferenceSemantics == (ReferenceFieldSemantics.Peer | ReferenceFieldSemantics.Reference);

      }

    }

    public bool IsLockProtected {

      get{

        return this.ReferenceSemantics == (ReferenceFieldSemantics.LockProtected | ReferenceFieldSemantics.Reference);

      }

    }

    public bool IsStrictReadonly {

      get {

        return this.GetAttribute(ExtendedRuntimeTypes.StrictReadonlyAttribute) != null;

      }

    }

#endif

    public override string ToString() {

      return this.DeclaringType.GetFullUnmangledNameWithTypeParameters() + "." + this.Name;

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      base.GetName(options, name);

      Method.AppendReturnType(options.ReturnType, this.Type, name);

    }

#endif

  }

#if ExtendedRuntime

  /// <summary>

  /// The behavior of a field in the Spec# object invariants/ownership/concurrency methodology.

  /// </summary>

  public enum ReferenceFieldSemantics{

    NotComputed,

    None,

    Rep,

    LockProtected,

    Immutable,

    Peer,

    SemanticsMask = 0xff,

    Reference = 0x100,

    EnumerableStructOfReferences = 0x200,

    NonReference = 0x300,

    ReferenceMask = 0xff00,

  }

#endif

#if FxCop

  public class PropertyNode : Member{

#else

  public class Property : Member{

#endif

#if !MinimalReader

    /// <summary>

    /// The list of types (just one in C#) that contain abstract or virtual properties that are explicity implemented or overridden by this property.

    /// </summary>

    public TypeNodeList ImplementedTypes;

    public TypeNodeList ImplementedTypeExpressions;

    public bool IsModelfield = false;   //set to true if this property serves as the representation of a modelfield in an interface

#endif

#if FxCop

    public PropertyNode()

#else

    public Property()

#endif

      : base(NodeType.Property){

    }

#if !MinimalReader

    public Property(TypeNode declaringType, AttributeList attributes, PropertyFlags flags, Identifier name, 

      Method getter, Method setter)

      : base(declaringType, attributes, name, NodeType.Property){

      this.flags = flags;

      this.getter = getter;

      this.setter = setter;

      if (getter != null) getter.DeclaringMember = this;

      if (setter != null) setter.DeclaringMember = this;

    }

#endif

    private PropertyFlags flags;

    public PropertyFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private Method getter;

    /// <summary>The method that is called to get the value of this property. Corresponds to the get clause in C#.</summary>

    public Method Getter{

      get{return this.getter;}

      set{this.getter = value;}

    }

    private Method setter;

    /// <summary>The method that is called to set the value of this property. Corresponds to the set clause in C#.</summary>

    public Method Setter{

      get{return this.setter;}

      set{this.setter = value;}

    }

    private MethodList otherMethods;

    /// <summary>Other methods associated with the property. No equivalent in C#.</summary>

    public MethodList OtherMethods{

      get{return this.otherMethods;}

      set{this.otherMethods = value;}

    }

    protected string fullName;

    public override string/*!*/ FullName {

      get{

        if (this.fullName != null) return this.fullName;

        StringBuilder sb = new StringBuilder();

        sb.Append(this.DeclaringType.FullName);

        sb.Append('.');

        if (this.Name != null)

          sb.Append(this.Name.ToString());

        ParameterList parameters = this.Parameters;

        for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){

          Parameter par = parameters[i];

          if (par == null || par.Type == null) continue;

          if (i == 0)

            sb.Append('(');

          else

            sb.Append(',');

          sb.Append(par.Type.FullName);

          if (i == n-1)

            sb.Append(')');

        }

        return this.fullName = sb.ToString();

      }

    }

#if !MinimalReader

    public virtual Method GetBaseGetter() {

      if (this.HidesBaseClassMember) return null;

      TypeNode t = this.DeclaringType;

      if (t == null) return null;

      while (t.BaseType != null){

        t = t.BaseType;

        MemberList mems = t.GetMembersNamed(this.Name);

        for (int i = 0, n = mems == null ? 0 : mems.Count; i < n; i++) {

          Property bprop = mems[i] as Property;

          if (bprop == null) continue;

          if (!bprop.ParametersMatch(this.Parameters)) continue;

          if (bprop.Getter != null) return bprop.Getter;

        }

      }

      return null;

    }

    public virtual Method GetBaseSetter(){

      if (this.HidesBaseClassMember) return null;

      TypeNode t = this.DeclaringType;

      if (t == null) return null;

      while (t.BaseType != null) {

        t = t.BaseType;

        MemberList mems = t.GetMembersNamed(this.Name);

        for (int i = 0, n = mems == null ? 0 : mems.Count; i < n; i++) {

          Property bprop = mems[i] as Property;

          if (bprop == null) continue;

          if (!bprop.ParametersMatch(this.Parameters)) continue;

          if (bprop.Setter != null) return bprop.Setter;

        }

      }

      return null;

    }

#endif

#if !NoXml

    protected override Identifier GetDocumentationId(){

      StringBuilder sb = new StringBuilder(this.DeclaringType.DocumentationId.ToString());

      sb[0] = 'P';

      sb.Append('.');

      if (this.Name != null)

        sb.Append(this.Name.ToString());

      ParameterList parameters = this.Parameters;

      for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){

        Parameter par = parameters[i];

        if (par == null || par.Type == null) continue;

        if (i == 0)

          sb.Append('(');

        else

          sb.Append(',');

        par.Type.AppendDocumentIdMangledName(sb, null, this.DeclaringType.TemplateParameters);

        if (i == n-1)

          sb.Append(')');

      }

      return Identifier.For(sb.ToString());

    }

#endif

#if !NoReflection

    public static Property GetProperty(System.Reflection.PropertyInfo propertyInfo){

      if (propertyInfo == null) return null;

      TypeNode tn = TypeNode.GetTypeNode(propertyInfo.DeclaringType);

      if (tn == null) return null;

      System.Reflection.ParameterInfo[] paramInfos = propertyInfo.GetIndexParameters();

      int n = paramInfos == null ? 0 : paramInfos.Length;

      TypeNode[] parameterTypes = new TypeNode[n];

      if (paramInfos != null)

        for (int i = 0; i < n; i++){

          System.Reflection.ParameterInfo param = paramInfos[i];

          if (param == null) return null;

          parameterTypes[i] = TypeNode.GetTypeNode(param.ParameterType);

        }

      return tn.GetProperty(Identifier.For(propertyInfo.Name), parameterTypes);

    }

#endif



#if !NoReflection

    protected System.Reflection.PropertyInfo propertyInfo;

    public virtual System.Reflection.PropertyInfo GetPropertyInfo(){

      if (this.propertyInfo == null){

        if (this.DeclaringType == null) return null;

        Type t = this.DeclaringType.GetRuntimeType();

        if (t == null) return null; 

        if (this.Type == null) return null;

        Type retType = this.Type.GetRuntimeType();

        if (retType == null) return null;

        ParameterList pars = this.Parameters;

        int n = pars == null ? 0 : pars.Count;

        Type[] types = new Type[n];

        for (int i = 0; i < n; i++){

          Parameter p = pars[i];

          if (p == null || p.Type == null) return null;

          Type pt = types[i] = p.Type.GetRuntimeType();

          if (pt == null) return null;

        }

        System.Reflection.MemberInfo[] members = 

          t.GetMember(this.Name.ToString(), System.Reflection.MemberTypes.Property, 

          BindingFlags.DeclaredOnly|BindingFlags.Instance|BindingFlags.Static|BindingFlags.Public|BindingFlags.NonPublic);

        foreach (System.Reflection.PropertyInfo prop in members){

          if (prop == null || prop.PropertyType != retType) continue;

          System.Reflection.ParameterInfo[] parameters = prop.GetIndexParameters();

          if (parameters == null || parameters.Length != n) continue;

          for (int i = 0; i < n; i++){

            System.Reflection.ParameterInfo parInfo = parameters[i];

            if (parInfo == null || parInfo.ParameterType != types[i]) goto tryNext;

          }

          return this.propertyInfo = prop;

        tryNext:;

        }

      }

      return this.propertyInfo;

    }

    public virtual object GetValue(object targetObject, params object[] indices) {

      System.Reflection.PropertyInfo propInfo = this.GetPropertyInfo();

      if (propInfo == null) throw new InvalidOperationException();

      return propInfo.GetValue(targetObject, indices);

    }

    public virtual Literal GetValue(Literal/*!*/ targetObject, params Literal[] indices){

      int n = indices == null ? 0 : indices.Length;

      object[] inds = n == 0 ? null : new object[n];

      if (inds != null && indices != null)

        for (int i = 0; i < n; i++) {

          Literal lit = indices[i];

          inds[i] = lit == null ? null : lit.Value;

        }

      return new Literal(this.GetValue(targetObject.Value, inds));

    }

    public virtual void SetValue(object targetObject, object value, params object[] indices){

      System.Reflection.PropertyInfo propInfo = this.GetPropertyInfo();

      if (propInfo == null) throw new InvalidOperationException();

      propInfo.SetValue(targetObject, value, indices);

    }

    public virtual void SetValue(Literal/*!*/ targetObject, Literal/*!*/ value, params Literal[] indices){

      int n = indices == null ? 0 : indices.Length;

      object[] inds = n == 0 ? null : new object[n];

      if (inds != null && indices != null)

        for (int i = 0; i < n; i++) {

          Literal lit = indices[i];

          inds[i] = lit == null ? null : lit.Value;

        }

      System.Reflection.PropertyInfo propInfo = this.GetPropertyInfo();

      if (propInfo == null) throw new InvalidOperationException();

      propInfo.SetValue(targetObject.Value, value.Value, inds);

    }

#endif

#if !NoXml

    public override string HelpText {

      get {

        if (this.helpText != null)

          return this.helpText;

        StringBuilder sb = new StringBuilder(base.HelpText);

        // if there is already some help text, start the contract on a new line

        bool startWithNewLine = (sb.Length != 0);

        if (this.Getter != null && this.Getter.HelpText != null && this.Getter.HelpText.Length > 0){

          if (startWithNewLine){

            sb.Append("\n");

            startWithNewLine = false;

          }

          sb.Append("get\n");

          int i = sb.Length;

          sb.Append(this.Getter.HelpText);

          if (sb.Length > i)

            startWithNewLine = true;

        }

        if (this.Setter != null && this.Setter.HelpText != null && this.Setter.HelpText.Length > 0) {

          if (startWithNewLine){

            sb.Append("\n");

            startWithNewLine = false;

          }

          sb.Append("set\n");

          sb.Append(this.Setter.HelpText);

        }

        return this.helpText = sb.ToString();

      }

      set {

        base.HelpText = value;

      }

    }

#endif

    public override bool IsAssembly{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.Assembly;}

    }

    public override bool IsCompilerControlled{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.CompilerControlled;}

    }

    public override bool IsFamily{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.Family;}

    }

    public override bool IsFamilyAndAssembly{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.FamANDAssem;}

    }

    public override bool IsFamilyOrAssembly{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.FamORAssem;}

    }

    public bool IsFinal {

      get {return (this.Getter == null || this.Getter.IsFinal) && (this.Setter == null || this.Setter.IsFinal);}

    }

    public override bool IsPrivate {

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.Private;}

    }

    public override bool IsPublic{

      get{return Method.GetVisibilityUnion(this.Getter, this.Setter) == MethodFlags.Public;}

    }

    public override bool IsSpecialName{

      get{return (this.Flags & PropertyFlags.SpecialName) != 0;}

    }

    public override bool IsStatic{

      get{return (this.Getter == null || this.Getter.IsStatic) && (this.Setter == null || this.Setter.IsStatic);}

    }

    /// <summary>

    /// True if this property can in principle be overridden by a property in a derived class.

    /// </summary>

    public bool IsVirtual{

      get{return (this.Getter == null || this.Getter.IsVirtual) && (this.Setter == null || this.Setter.IsVirtual);}

    }

    public override bool IsVisibleOutsideAssembly{

    get{return (this.Getter != null && this.Getter.IsVisibleOutsideAssembly) || (this.Setter != null && this.Setter.IsVisibleOutsideAssembly);}

    }

    public static readonly Property NotSpecified = new Property();

    public override Member HiddenMember{

      get{

        return this.HiddenProperty;

      }

      set{

        this.HiddenProperty = (Property)value;

      }

    }    

    protected Property hiddenProperty;

    public virtual Property HiddenProperty{

      get{

        if (this.hiddenMember == Property.NotSpecified) return null;

        Property hiddenProperty = this.hiddenMember as Property;

        if (hiddenProperty != null) return hiddenProperty;



        Method hiddenGetter = this.Getter == null ? null : this.Getter.HiddenMethod;

        Method hiddenSetter = this.Setter == null ? null : this.Setter.HiddenMethod;

        Property hiddenGetterProperty = hiddenGetter == null ? null : hiddenGetter.DeclaringMember as Property;

        Property hiddenSetterProperty = hiddenSetter == null ? null : hiddenSetter.DeclaringMember as Property;

        hiddenProperty = hiddenGetterProperty;

        if (hiddenSetterProperty != null){

          if (hiddenProperty == null ||

            (hiddenSetterProperty.DeclaringType != null && hiddenSetterProperty.DeclaringType.IsDerivedFrom(hiddenProperty.DeclaringType)))

            hiddenProperty = hiddenSetterProperty;

        }

        this.hiddenMember = hiddenProperty;

        return hiddenProperty;

      }

      set{

        this.hiddenMember = value;

      }

    }

    public override Member OverriddenMember{

      get{

        return this.OverriddenProperty;

      }

      set{

        this.OverriddenProperty = (Property)value;

      }

    }

    protected Property overriddenProperty;

    public virtual Property OverriddenProperty{

      get{

        if (this.overriddenMember == Property.NotSpecified) return null;

        Property overriddenProperty = this.overriddenMember as Property;

        if (overriddenProperty != null) return overriddenProperty;



        Method overriddenGetter = this.Getter == null ? null : this.Getter.OverriddenMethod;

        Method overriddenSetter = this.Setter == null ? null : this.Setter.OverriddenMethod;

        Property overriddenGetterProperty = overriddenGetter == null ? null : overriddenGetter.DeclaringMember as Property;

        Property overriddenSetterProperty = overriddenSetter == null ? null : overriddenSetter.DeclaringMember as Property;

        overriddenProperty = overriddenGetterProperty;

        if (overriddenSetterProperty != null){

          if (overriddenProperty == null ||

            (overriddenSetterProperty.DeclaringType != null && overriddenSetterProperty.DeclaringType.IsDerivedFrom(overriddenProperty.DeclaringType)))

            overriddenProperty = overriddenSetterProperty;

        }

        this.overriddenMember = overriddenProperty;

        return overriddenProperty;

      }

      set{

        this.overriddenMember = value;

      }

    }

    private ParameterList parameters;

    /// <summary>

    /// The parameters of this property if it is an indexer.

    /// </summary>

    public ParameterList Parameters{

      get{

        if (this.parameters != null) return this.parameters;

        if (this.Getter != null) return this.parameters = this.Getter.Parameters;

        ParameterList setterPars = this.Setter == null ? null : this.Setter.Parameters;

        int n = setterPars == null ? 0 : setterPars.Count - 1;

        ParameterList propPars = this.parameters = new ParameterList(n);

        if (setterPars != null)

        for (int i = 0; i < n; i++) propPars.Add(setterPars[i]);

        return propPars;

      }

      set{

        this.parameters = value;

      }

    }

    public virtual bool ParametersMatch(ParameterList parameters){

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1.Type != par2.Type) return false;

      }

      return true;

    }

    public virtual bool ParametersMatchStructurally(ParameterList parameters) {

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = parameters == null ? 0 : parameters.Count;

      if (n != m) return false;

      if (parameters == null) return true;

      for (int i = 0; i < n; i++) {

        Parameter par1 = pars[i];

        Parameter par2 = parameters[i];

        if (par1 == null || par2 == null) return false;

        if (par1.Type == null || par2.Type == null) return false;

        if (par1.Type != par2.Type && !par1.Type.IsStructurallyEquivalentTo(par2.Type)) return false;

      }

      return true;

    }

    public virtual bool ParameterTypesMatch(TypeNodeList argumentTypes) {

      ParameterList pars = this.Parameters;

      int n = pars == null ? 0 : pars.Count;

      int m = argumentTypes == null ? 0 : argumentTypes.Count;

      if (n != m) return false;

      if (argumentTypes == null) return true;

      for (int i = 0; i < n; i++){

        Parameter par = this.Parameters[i];

        if (par == null) return false;

        TypeNode argType = argumentTypes[i];

        if (par.Type != argType) return false;

      }

      return true;

    }

    protected TypeNode type;

    /// <summary>

    /// The type of value that this property holds.

    /// </summary>

    public virtual TypeNode Type{

      get{

        if (this.type != null) return this.type;

        if (this.Getter != null) return this.type = this.Getter.ReturnType;

        if (this.Setter != null && this.Setter.Parameters != null)

          return this.type = this.Setter.Parameters[this.Setter.Parameters.Count-1].Type;

        return CoreSystemTypes.Object;

      }

      set{

        this.type = value;

      }

    }

#if !MinimalReader

    public TypeNode TypeExpression;

#endif

    public override string ToString() {

      return this.DeclaringType.GetFullUnmangledNameWithTypeParameters() + "." + this.Name;

    }

#if FxCop

    internal override void GetName(MemberFormat options, StringBuilder name)

    {

      base.GetName(options, name);

      ParameterCollection parameters = this.parameters.Count > 0 ? this.parameters : null;

      // AppendParametersAndReturnType will not emit the paramters

      // prefix and suffix if a null ParameterCollection is provided to it.

      // This prevents a parameterless property from being rendered as MyProperty[]

      Method.AppendParametersAndReturnType(options, parameters, '[', ']', this.Type, name);

    }

#endif

  }

  public class Variable : Expression{

    private Identifier name;

#if !MinimalReader

    public TypeNode TypeExpression;

#endif

    public Variable(NodeType type)

      :base(type){

    }

    /// <summary>The name of a stack location. For example the name of a local variable or the name of a method parameter.</summary>

    public Identifier Name{

      get{return this.name;}

      set{this.name = value;}

    }

  }

  public class Parameter : Variable{

    private AttributeList attributes;

    /// <summary>The (C# custom) attributes of this parameter.</summary>

    public AttributeList Attributes{

      get{

        if (this.attributes != null) return this.attributes;

        return this.attributes = new AttributeList();

      }

      set{this.attributes = value;}

    }

    private Expression defaultValue;

    /// <summary>The value that should be supplied as the argument value of this optional parameter if the source code omits an explicit argument value.</summary>

    public Expression DefaultValue{

      get{return this.defaultValue;}

      set{this.defaultValue = value;}

    }

    private ParameterFlags flags;

    public ParameterFlags Flags{

      get{return this.flags;}

      set{this.flags = value;}

    }

    private MarshallingInformation marshallingInformation;

    public MarshallingInformation MarshallingInformation{

      get{return this.marshallingInformation;}

      set{this.marshallingInformation = value;}

    }

    private Method declaringMethod;

    public Method DeclaringMethod{

      get{return this.declaringMethod;}

      set{this.declaringMethod = value;}

    }

    private int parameterListIndex;

    /// <summary>

    /// Zero based index into a parameter list containing this parameter.

    /// </summary>

    public int ParameterListIndex{

      get{return this.parameterListIndex;}

      set{this.parameterListIndex = value;}

    }

    private int argumentListIndex;

    /// <summary>

    /// Zero based index into the list of arguments on the evaluation stack. 

    /// Instance methods have the this object as parameter zero, which means that the first parameter will have value 1, not 0.

    /// </summary>

    public int ArgumentListIndex{

      get{return this.argumentListIndex;}

      set{this.argumentListIndex = value;}

    }

    public Parameter()

      : base(NodeType.Parameter){

    }

    public Parameter(Identifier name, TypeNode type)

      : base(NodeType.Parameter){

      this.Name = name;

      this.Type = type;

    }

#if !MinimalReader

    public Parameter(AttributeList attributes, ParameterFlags flags, Identifier name, TypeNode type, 

      Literal defaultValue, MarshallingInformation marshallingInformation)

      : base(NodeType.Parameter){

      this.attributes = attributes;

      this.defaultValue = defaultValue;

      this.flags = flags;

      this.marshallingInformation = marshallingInformation;

      this.Name = name;

      this.Type = type;

    }

#endif

    /// <summary>

    /// True if the corresponding argument value is used by the callee. (This need not be the case for a parameter marked as IsOut.) 

    /// </summary>

    public virtual bool IsIn{

      get{

        return (this.Flags & ParameterFlags.In) != 0;

      }

      set{

        if (value)

          this.Flags |= ParameterFlags.In;

        else

          this.Flags &= ~ParameterFlags.In;

      }

    }

    /// <summary>

    /// True if the caller can omit providing an argument for this parameter.

    /// </summary>

    public virtual bool IsOptional{

      get{

        return (this.Flags & ParameterFlags.Optional) != 0;

      }

      set{

        if (value)

          this.Flags |= ParameterFlags.Optional;

        else

          this.Flags &= ~ParameterFlags.Optional;

      }

    }

    /// <summary>

    /// True if the corresponding argument must be a left hand expression and will be updated when the call returns.

    /// </summary>

    public virtual bool IsOut{

      get{

        return (this.Flags & ParameterFlags.Out) != 0;

      }

      set{

        if (value)

          this.Flags |= ParameterFlags.Out;

        else

          this.Flags &= ~ParameterFlags.Out;

      }

    }

#if !MinimalReader

    protected internal TypeNode paramArrayElementType = null;

    /// <summary>

    /// If the parameter is a param array, this returns the element type of the array. If not, it returns null.

    /// </summary>

    public virtual TypeNode GetParamArrayElementType(){

      TypeNode result = this.paramArrayElementType;

      if (result == null){

        AttributeNode attr = this.GetParamArrayAttribute();

        if (attr != null){

          TypeNode t = TypeNode.StripModifiers(this.Type);

          Reference r = t as Reference;

          if (r != null) t = r.ElementType;

          ArrayType arr = t as ArrayType;

          if (arr != null && arr.Rank == 1)

            return this.paramArrayElementType = arr.ElementType;

        }

        this.paramArrayElementType = result = Class.DoesNotExist;

      }

      if (result == Class.DoesNotExist) return null;

      return result;

    }

    protected AttributeNode paramArrayAttribute = null;

    public virtual AttributeNode GetParamArrayAttribute(){

      AttributeNode result = this.paramArrayAttribute;

      if (result == null){

        AttributeList attributes = this.Attributes;

        for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++){

          AttributeNode attr = attributes[i];

          if (attr == null) continue;

          TypeNode attrType = null;

          MemberBinding mb = attr.Constructor as MemberBinding;

          if (mb != null)

            attrType = mb.BoundMember.DeclaringType;

          else{

            Literal lit = attr.Constructor as Literal;

            if (lit == null) continue;

            attrType = lit.Value as TypeNode;

          }

          if (attrType == SystemTypes.ParamArrayAttribute)

            return this.paramArrayAttribute = attr;

        }

        result = this.paramArrayAttribute = AttributeNode.DoesNotExist;

      }

      if (result == AttributeNode.DoesNotExist) return null;

      return result;

    }

    public override bool Equals(object obj) {

      ParameterBinding binding = obj as ParameterBinding;

      return obj == this || binding != null && binding.BoundParameter == this;

    }

    public override int GetHashCode() {

      return base.GetHashCode();

    }

    /// <summary>

    /// Gets the first attribute of the given type in the attribute list of this parameter. Returns null if none found.

    /// This should not be called until the AST containing this member has been processed to replace symbolic references

    /// to members with references to the actual members.

    /// </summary>

    public virtual AttributeNode GetAttribute(TypeNode attributeType) {

      if (attributeType == null) return null;

      AttributeList attributes = this.Attributes;

      for (int i = 0, n = attributes == null ? 0 : attributes.Count; i < n; i++) {

        AttributeNode attr = attributes[i];

        if (attr == null) continue;

        MemberBinding mb = attr.Constructor as MemberBinding;

        if (mb != null) {

          if (mb.BoundMember == null) continue;

          if (mb.BoundMember.DeclaringType != attributeType) continue;

          return attr;

        }

        Literal lit = attr.Constructor as Literal;

        if (lit == null) continue;

        if ((lit.Value as TypeNode) != attributeType) continue;

        return attr;

      }

      return null;

    }

#endif

#if ExtendedRuntime

    public virtual bool IsUniversallyDelayed {

      get {

        // Special handling of delegate constructors. Their first argument is delayed.

        if (this.DeclaringMethod != null && this.DeclaringMethod.DeclaringType is DelegateNode) {

          if (this.DeclaringMethod.Parameters[0] == this) { // first parameter (not including this)

            return true;

          }

        }

        return (this.GetAttribute(ExtendedRuntimeTypes.DelayedAttribute) != null);

      }

    }

#endif

    public override string ToString() {

      if (this.Name == null) return "";

      if (this.Type == null) return this.Name.ToString();

      return this.Type.ToString() + " " + this.Name.ToString();

    }

  }

#if !MinimalReader

  public class ParameterBinding : Parameter, IUniqueKey{

    public Parameter/*!*/ BoundParameter;



    public ParameterBinding(Parameter/*!*/ boundParameter, SourceContext sctx) {

      if (boundParameter == null) throw new ArgumentNullException("boundParameter");

      this.BoundParameter = boundParameter;

      this.SourceContext = sctx;

      this.Type = boundParameter.Type;

      this.Name = boundParameter.Name;

      this.TypeExpression = boundParameter.TypeExpression;

      this.Attributes = boundParameter.Attributes;

      this.DefaultValue = boundParameter.DefaultValue;

      this.Flags = boundParameter.Flags;

      this.MarshallingInformation = boundParameter.MarshallingInformation;

      this.DeclaringMethod = boundParameter.DeclaringMethod;

      this.ParameterListIndex = boundParameter.ParameterListIndex;

      this.ArgumentListIndex = boundParameter.ArgumentListIndex;

      //^ base();

    }

    public override int GetHashCode(){

      return this.BoundParameter.GetHashCode();

    }

    public override bool Equals(object obj){

      ParameterBinding pb = obj as ParameterBinding;

      if (pb != null)

        return this.BoundParameter.Equals(pb.BoundParameter);

      else

        return this.BoundParameter.Equals(obj);

    }

    int IUniqueKey.UniqueId{

      get {return this.BoundParameter.UniqueKey;}

    }

  }

#endif

  public class Local : Variable{   

#if !MinimalReader

    public Block DeclaringBlock;

    public bool InitOnly;

    public int Index;

#endif

    public Local()

      : base(NodeType.Local){

    }

    public Local(TypeNode type)

      : base(NodeType.Local){

      this.Name = Identifier.Empty;

      if (type == null) type = CoreSystemTypes.Object;

      this.Type = type;

    }

    public Local(Identifier name, TypeNode type)

      : this(type){

      this.Name = name;

    }

#if !MinimalReader

    public Local(TypeNode type, SourceContext context)

      : this(Identifier.Empty, type, null){

      this.SourceContext = context;

    }

    public Local(Identifier name, TypeNode type, SourceContext context)

      : this(name, type, null){

      this.SourceContext = context;

    }

    public Local(Identifier name, TypeNode type, Block declaringBlock)

      : base(NodeType.Local){

      this.DeclaringBlock = declaringBlock;

      this.Name = name;

      if (type == null) type = CoreSystemTypes.Object;

      this.Type = type;

    }

#endif

    private bool pinned;

    public bool Pinned{

      get{return this.pinned;}

      set{this.pinned = value;}

    }

#if !MinimalReader

    public override bool Equals(object obj){

      LocalBinding binding = obj as LocalBinding;

      return obj == this || binding != null && binding.BoundLocal == this;

    }

    public override int GetHashCode() {

      return base.GetHashCode();

    }

    public override string ToString() {

      if (this.Name == null) return "No name";

      return this.Name.ToString();

    }

#endif



  }

#if !MinimalReader

  public class LocalBinding : Local, IUniqueKey{

    public Local/*!*/ BoundLocal;



    public LocalBinding(Local/*!*/ boundLocal, SourceContext sctx) {

      if (boundLocal == null) throw new ArgumentNullException("boundLocal");

      this.BoundLocal = boundLocal;

      //^ base();

      this.SourceContext = sctx;

      this.Type = boundLocal.Type;

      this.Name = boundLocal.Name;

      this.TypeExpression = boundLocal.TypeExpression;

      this.DeclaringBlock = boundLocal.DeclaringBlock;

      this.Pinned = boundLocal.Pinned;

      this.InitOnly = boundLocal.InitOnly;

      this.Index = boundLocal.Index;

    }

    public override int GetHashCode(){

      return this.BoundLocal.GetHashCode();

    }

    public override bool Equals(object obj){

      LocalBinding lb = obj as LocalBinding;

      if (lb != null)

        return this.BoundLocal.Equals(lb.BoundLocal);

      else

        return this.BoundLocal.Equals(obj);

    }

    int IUniqueKey.UniqueId{

      get {return this.BoundLocal.UniqueKey;}

    }

  }

#endif

  /// <summary>

  /// A named container of types and nested namespaces. 

  /// The name of the container implicitly qualifies the names of the contained types and namespaces.

  /// </summary>

  public class Namespace : Member{

    /// <summary>The FullName of the namespace in the form of an Identifier rather than in the form of a string.</summary>

    public Identifier FullNameId;

#if !MinimalReader

    /// <summary>

    /// Provides alternative names for types and nested namespaces. Useful for introducing shorter names or for resolving name clashes.

    /// The names should be added to the scope associated with this namespace.

    /// </summary>

    public AliasDefinitionList AliasDefinitions;

    /// <summary>

    /// The list of namespaces that are fully contained inside this namespace.

    /// </summary>

    public NamespaceList NestedNamespaces;

    /// <summary>

    /// The Universal Resource Identifier that should be associated with all declarations inside this namespace.

    /// Typically used when the types inside the namespace are serialized as an XML Schema Definition. (XSD)

    /// </summary>

    public Identifier URI;

    /// <summary>

    /// The list of the namespaces of types that should be imported into the scope associated with this namespace.

    /// </summary>

    public UsedNamespaceList UsedNamespaces;

#endif

    /// <summary>

    /// A delegate that is called the first time Types is accessed. Provides for incremental construction of the namespace node.

    /// </summary>

    public TypeProvider ProvideTypes;

    /// <summary>

    /// Opaque information passed as a parameter to the delegate in ProvideTypes. Typically used to associate this namespace

    /// instance with a helper object.

    /// </summary>

    public object ProviderHandle;

    /// <summary>

    /// A method that fills in the Types property of the given namespace. Must not leave Types null.

    /// </summary>

    public delegate void TypeProvider(Namespace @namespace, object handle);



    protected string fullName;

    protected TypeNodeList types;



    public Namespace()

      : base(NodeType.Namespace){

    }

    public Namespace(Identifier name)

      : base(NodeType.Namespace){

      this.Name = name;

      this.FullNameId = name;

      if (name != null)

        this.fullName = name.ToString();

    }

#if !MinimalReader

    public Namespace(Identifier name, TypeProvider provideTypes, object providerHandle)

      : base(NodeType.Namespace){

      this.Name = name;

      this.FullNameId = name;

      if (name != null)

        this.fullName = name.ToString();

      this.ProvideTypes = provideTypes;

      this.ProviderHandle = providerHandle;

    }

    public Namespace(Identifier name, Identifier fullName, AliasDefinitionList aliasDefinitions,  UsedNamespaceList usedNamespaces, 

      NamespaceList nestedNamespaces, TypeNodeList types)

      : base(NodeType.Namespace){

      this.Name = name;

      this.FullNameId = fullName;

      if (fullName != null)

        this.fullName = fullName.ToString();

      this.AliasDefinitions = aliasDefinitions;

      this.NestedNamespaces = nestedNamespaces;

      this.Types = types;

      this.UsedNamespaces = usedNamespaces;

    }

#endif

    public override string/*!*/ FullName {

      get{return this.fullName == null ? "" : this.fullName;}

    }

    public override bool IsAssembly{get{return false;}}

    public override bool IsCompilerControlled{get{return false;}}

    public override bool IsFamily{get{return false;}}

    public override bool IsFamilyAndAssembly{get{return false;}}

    public override bool IsFamilyOrAssembly{get{return false;}}

    public override bool IsPrivate{get{return !this.IsPublic;}}

    public override bool IsPublic{get{return this.isPublic;}}

    protected internal bool isPublic;

    public override bool IsSpecialName{get{return false;}}

    public override bool IsStatic{get{return false;}}

    public override bool IsVisibleOutsideAssembly{get{return false;}}

    /// <summary>

    /// The list of types contained inside this namespace. If the value of Types is null and the value of ProvideTypes is not null, the 

    /// TypeProvider delegate is called to fill in the value of this property.

    /// </summary>

    public TypeNodeList Types{

      get{

        if (this.types == null)

          if (this.ProvideTypes != null)

            lock(this){

              if (this.types == null){

                this.ProvideTypes(this, this.ProviderHandle);

              }

            }

          else

            this.types = new TypeNodeList();

        return this.types;       

      }

      set{

        this.types = value;

      }

    }

  }

#if !MinimalReader

  /// <summary>

  /// The root node of an Abstract Syntax Tree. Typically corresponds to multiple source files compiled to form a single target.

  /// </summary>

  public class Compilation : Node{

    /// <summary>

    /// The compilation parameters that are used for this compilation.

    /// </summary>

    public System.CodeDom.Compiler.CompilerParameters CompilerParameters;

    /// <summary>

    /// The target code object that is produced as a result of this compilation.

    /// </summary>

    public Module TargetModule;

    /// <summary>

    /// A list of all the compilation units (typically source files) that make up this compilation.

    /// </summary>

    public CompilationUnitList CompilationUnits;

    /// <summary>

    /// A scope for symbols that belong to the compilation as a whole. No C# equivalent. Null if not applicable.

    /// </summary>

    public Scope GlobalScope;

    /// <summary>

    /// A list of compilations that produce assemblies and modules that are referenced by this compilation and hence need to be

    /// compiled before this Compilation is compiled. This list is not intended to include already compiled framework assemblies

    /// such as system.dll.

    /// </summary>

    public CompilationList ReferencedCompilations;

    public DateTime LastModified = DateTime.Now;

    public DateTime LastCompiled = DateTime.MinValue;



    public Compilation()

      : base(NodeType.Compilation){

    }

    public Compilation(Module targetModule, CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, Scope globalScope)

      : base(NodeType.Compilation){

      this.CompilationUnits = compilationUnits;

      this.TargetModule = targetModule;

      this.CompilerParameters = compilerParameters;

      this.GlobalScope = globalScope;

    }

    public virtual Compilation CloneCompilationUnits(){

      Compilation clone = (Compilation)base.Clone();

      CompilationUnitList cus = this.CompilationUnits;

      if (cus != null){

        clone.CompilationUnits = cus = cus.Clone();

        for (int i = 0, n = cus.Count; i < n; i++){

          CompilationUnit cu = cus[i];

          if (cu == null) continue;

          cus[i] = cu = (CompilationUnit)cu.Clone();

          cu.Compilation = clone;

          cu.Nodes = null;

        }

      }

      return clone;

    }

  }

  /// <summary>

  /// The root node of an Abstract Syntax Tree. Corresponds to the starting production of the syntax. Equivalent to C# compilation-unit.

  /// Typically a compilation unit corresponds to a single source file.

  /// </summary>

  public class CompilationUnit : Node{

    /// <summary>

    /// An identifier that can be used to retrieve the source text of the compilation unit.

    /// </summary>

    public Identifier Name;

    /// <summary>

    /// An anonymous (name is Identifier.Empty) namespace holding types and nested namespaces.

    /// </summary>

    public NodeList Nodes;

    /// <summary>

    /// The preprocessor symbols that are to treated as defined when compiling this CompilationUnit into the TargetModule.

    /// </summary>

    public Hashtable PreprocessorDefinedSymbols;

    /// <summary>

    /// Pragma warning information.

    /// </summary>

    public TrivialHashtable PragmaWarnInformation;

    /// <summary>

    /// The compilation of which this unit forms a part.

    /// </summary>

    public Compilation Compilation;



    public CompilationUnit()

      : base(NodeType.CompilationUnit){

    }

    public CompilationUnit(Identifier name)

      : base(NodeType.CompilationUnit){

      this.Name = name;

    }

  }

  public class CompilationUnitSnippet : CompilationUnit{

    public DateTime LastModified = DateTime.Now;

    public IParserFactory ParserFactory;

    public Method ChangedMethod;

    public int OriginalEndPosOfChangedMethod;



    public CompilationUnitSnippet(){

      this.NodeType = NodeType.CompilationUnitSnippet;

    }

    public CompilationUnitSnippet(Identifier name, IParserFactory parserFactory, SourceContext sctx){

      this.NodeType = NodeType.CompilationUnitSnippet;

      this.Name = name;

      this.ParserFactory = parserFactory;

      this.SourceContext = sctx;

    }

  }

  public abstract class Composer{

    public abstract Node Compose (Node node, Composer context, bool hasContextReference, Class scope);

    private class NullComposer: Composer{

      public override Node Compose(Node node, Composer context, bool hasContextReference, Class scope){

        return node;

      }

    }

    public static readonly Composer Null = new NullComposer();

  }

  public class Composition: Expression{

    public Expression Expression;

    public Composer Composer;

    public Class Scope;

    public Composition(Expression exp, Composer composer, Class scope)

      : base(NodeType.Composition){

      this.Expression = exp;

      this.Composer = composer;

      this.Scope = scope;

      if (exp != null) this.Type = exp.Type;

    }

  }

#endif

#if ExtendedRuntime  

  // query nodes

  public class QueryAlias: QueryExpression{

    public Identifier Name;

    public Expression Expression;

    public QueryAlias(): base(NodeType.QueryAlias){

    }

  }   

  public abstract class Accessor{

  }

  public class MemberAccessor: Accessor{

    public Member Member;

    public TypeNode Type;

    public bool Yield;

    public Accessor Next;

    public MemberAccessor(Member member){

      this.Member = member;

    }

  }

  public class SequenceAccessor: Accessor{

    public ArrayList Accessors; // member accessors only

    public SequenceAccessor(){

      this.Accessors = new ArrayList();

    }

  }

  public class SwitchAccessor: Accessor{

    public TypeUnion Type;

    public Hashtable Accessors;  // key == type

    public SwitchAccessor(){

      this.Accessors = new Hashtable();

    }

  }

  public enum Cardinality{

    None,       // reference type

    One,        // !

    ZeroOrOne,  // ?

    OneOrMore,  // +

    ZeroOrMore  // *

  }

  public class QueryAxis: QueryExpression{

    public Expression Source;

    public bool IsDescendant;

    public Identifier Name;

    public Identifier Namespace;

    public TypeNode TypeTest;

    public Accessor AccessPlan;

    public Cardinality Cardinality;

    public int YieldCount;

    public TypeNodeList YieldTypes;

    public bool IsCyclic;

    public bool IsIterative;

    public QueryAxis (Expression source, bool isDescendant, Identifier name, TypeNode typeTest)

      : base(NodeType.QueryAxis){

      this.Source = source;

      this.IsDescendant = isDescendant;

      this.Name = name;

      this.TypeTest = typeTest;

    }

  }   

  public class QueryAggregate: QueryExpression{ 

    public Identifier Name;

    public TypeNode AggregateType;

    public Expression Expression;

    public ContextScope Context;

    public QueryGroupBy Group;

    public QueryAggregate(): base(NodeType.QueryAggregate){

    }

  }

  public class ContextScope{

    public ContextScope Previous;

    public TypeNode Type;

    public Expression Target;

    public Expression Position;

    public Block PreFilter;

    public Block PostFilter;

    public ContextScope(ContextScope previous, TypeNode type){

      this.Previous = previous;

      this.Type = type;

    }

  }

  public class QueryContext: QueryExpression{

    public ContextScope Scope;

    public QueryContext()

      : base(NodeType.QueryContext){

    }    

    public QueryContext(ContextScope scope): base(NodeType.QueryContext){

      this.Scope = scope;

      if (scope != null) this.Type = scope.Type;

    }    

  }   

  public class QueryDelete: QueryExpression{

    public Expression Source;    

    public Expression Target;

    public ContextScope Context;

    public Expression SourceEnumerable;

    public QueryDelete(): base(NodeType.QueryDelete){      

    }

  } 

  public class QueryDistinct: QueryExpression{

    public Expression Source;

    public ContextScope Context;

    public QueryGroupBy Group;

    public Expression GroupTarget;

    public QueryDistinct(): base(NodeType.QueryDistinct){

    }

  }  

  public class QueryDifference: QueryExpression{

    public Expression LeftSource;

    public Expression RightSource;

    public QueryDifference() : base(NodeType.QueryDifference){

    }

  }  

  public class QueryExists: QueryExpression{

    public Expression Source;

    public QueryExists() : base(NodeType.QueryExists){

    }

  }  

  public abstract class QueryExpression: Expression{

    protected QueryExpression(NodeType nt): base(nt){

    }

  }

  public class QueryFilter: QueryExpression{

    public Expression Source;

    public Expression Expression;

    public ContextScope Context;

    public QueryFilter(): base(NodeType.QueryFilter){

    }    

    public QueryFilter (Expression source, Expression filter): this(){

      this.Source = source;

      this.Expression = filter;

    }

  } 

  public class QueryYielder: Statement{

    public Expression Source;

    public Expression Target;

    public Expression State;

    public Block Body;

    public QueryYielder(): base(NodeType.QueryYielder){

    }

  }

  public class QueryGeneratedType: Statement{

    public TypeNode Type;

    public QueryGeneratedType(TypeNode type): base(NodeType.QueryGeneratedType){

      this.Type = type;

    }

  }

  public class QueryGroupBy: QueryExpression{

    public Expression Source;

    public ContextScope GroupContext;

    public ExpressionList GroupList;

    public ExpressionList AggregateList;

    public Expression Having;

    public ContextScope HavingContext;

    public QueryGroupBy(): base(NodeType.QueryGroupBy){

      this.GroupList = new ExpressionList();

      this.AggregateList = new ExpressionList();

    }

  }  

  public class QueryInsert: QueryExpression{

    public Expression Location;

    public QueryInsertPosition Position;

    public ExpressionList InsertList;

    public ExpressionList HintList;

    public ContextScope Context;

    public bool IsBracket;

    public QueryInsert(): base(NodeType.QueryInsert){

      this.InsertList = new ExpressionList();

      this.HintList = new ExpressionList();

    }

  }    

  public enum QueryInsertPosition{

    After,

    At,

    Before,

    First,

    In,

    Last

  }  

  public class QueryIntersection: QueryExpression{

    public Expression LeftSource;

    public Expression RightSource;

    public QueryIntersection(): base(NodeType.QueryIntersection){

    }

  }

  public class QueryScope: BlockScope{

    public QueryScope(Scope/*!*/ parentScope)

      : base(parentScope, null) {

    }

  }

  public class QueryIterator: QueryAlias{

    public TypeNode ElementType;

    public TypeNode TypeExpression;

    public ExpressionList HintList;

    public QueryIterator(): base(){

      this.NodeType = NodeType.QueryIterator;      

      this.HintList = new ExpressionList();

    }

  }   

  public class QueryJoin: QueryExpression{

    public Expression LeftOperand;

    public Expression RightOperand;

    public QueryJoinType JoinType;

    public Expression JoinExpression;

    public ContextScope JoinContext;

    public QueryJoin(): base(NodeType.QueryJoin){

    }

  }  

  public enum QueryJoinType{

    Inner,

    LeftOuter,

    RightOuter,

    FullOuter

  }

  public class QueryLimit: QueryExpression{

    public Expression Source;

    public Expression Expression;

    public bool IsPercent;

    public bool IsWithTies;

    public QueryLimit(): base(NodeType.QueryLimit){

    }

  }  

  public class QueryOrderBy: QueryExpression{

    public Expression Source;

    public ContextScope Context;

    public ExpressionList OrderList;

    public QueryOrderBy(): base(NodeType.QueryOrderBy){

      this.OrderList = new ExpressionList();

    }

  }

  public enum QueryOrderType{

    Ascending,

    Descending,

    Document

  }  

  public class QueryOrderItem: QueryExpression{

    public Expression Expression;

    public QueryOrderType OrderType = QueryOrderType.Ascending;

    public QueryOrderItem(): base(NodeType.QueryOrderItem){

    }

  }  

  public class QueryPosition: QueryExpression{

    public ContextScope Context;

    public QueryPosition(ContextScope context): base(NodeType.QueryPosition){

      this.Context = context;

      this.Type = CoreSystemTypes.Int32;

    }

    public static readonly Identifier Id = Identifier.For("position");

  } 

  public class QueryProject: QueryExpression{

    public Expression Source;

    public ContextScope Context;

    public ExpressionList ProjectionList;

    public TypeNode ProjectedType;

    public MemberList Members;

    public QueryProject(): base(NodeType.QueryProject){

      this.ProjectionList = new ExpressionList();

    }

  }   

  public class QueryQuantifiedExpression: QueryExpression{

    public QueryQuantifier Left;

    public QueryQuantifier Right;

    public Expression Expression;

    public QueryQuantifiedExpression(): base(NodeType.QueryQuantifiedExpression){

    }

  }

  public class QueryQuantifier: QueryExpression{

    public Expression Expression;

    public Expression Target;

    public QueryQuantifier(NodeType nt): base(nt){

    }

  }

  public class QuerySingleton: QueryExpression{

    public Expression Source;

    public QuerySingleton(): base(NodeType.QuerySingleton){

    }

  }

  public class QuerySelect: QueryExpression{

    public Expression Source;

    public QueryCursorDirection Direction;

    public QueryCursorAccess Access;

    public QuerySelect(Expression source): base(NodeType.QuerySelect){

      if (source != null){

        this.Source = source;

        this.Type = source.Type;

      }

    }

  } 

  public enum QueryCursorDirection{

    ForwardOnly,

    Scrollable

  }  

  public enum QueryCursorAccess{

    ReadOnly,

    Updatable

  }  



  public abstract class QueryStatement: Statement{

    protected QueryStatement(NodeType nt): base(nt){

    }

  }  

  public class QueryTypeFilter: QueryExpression{

    public Expression Source;

    public TypeNode Constraint;

    public QueryTypeFilter(): base(NodeType.QueryTypeFilter){     

    }

  }   

  public class QueryUnion: QueryExpression{

    public Expression LeftSource;

    public Expression RightSource;

    public QueryUnion() : base(NodeType.QueryUnion){

    }

  }  

  public class QueryUpdate: QueryExpression{

    public Expression Source;

    public ExpressionList UpdateList;

    public ContextScope Context;

    public QueryUpdate() : base(NodeType.QueryUpdate){

      this.UpdateList = new ExpressionList();

    }

  }

  public class QueryTransact: Statement{

    public Expression Source;

    public Expression Isolation;

    public Block Body;

    public Block CommitBody;

    public Block RollbackBody;

    public Expression Transaction;

    public QueryTransact(): base(NodeType.QueryTransact){

    }

  }

  public class QueryCommit: Statement{

    public QueryCommit(): base(NodeType.QueryCommit){

    }

  }

  public class QueryRollback: Statement{

    public QueryRollback(): base(NodeType.QueryRollback){

    }

  }

#endif

#if !MinimalReader

  /// <summary>

  /// An object that knows how to produce a particular scope's view of a type.

  /// </summary>

  public class TypeViewer {

    /// <summary>

    /// Return a scope's view of the argument type, where the scope's view is represented

    /// by a type viewer.

    /// [The identity function, except for dialects (e.g. Extensible Sing#) that allow

    /// extensions and differing views of types].

    /// Defined as a static method to allow the type viewer to be null,

    /// meaning an identity-function view.

    /// </summary>

    public static TypeNode/*!*/ GetTypeView(TypeViewer typeViewer, TypeNode/*!*/ type) {

      return typeViewer == null ? type.EffectiveTypeNode : typeViewer.GetTypeView(type);

    }



    /// <summary>

    /// Return the typeViewer's view of the argument type.  Overridden by subclasses

    /// that support non-identity-function type viewers, e.g. Extensible Sing#.

    /// </summary>

    protected virtual TypeNode/*!*/ GetTypeView(TypeNode/*!*/ type) {

      return type.EffectiveTypeNode;

    }

  }

#endif

#if WHIDBEY

  static

#endif

  class PlatformHelpers {

    internal static bool TryParseInt32(String s, out Int32 result) {

#if WHIDBEY

      return Int32.TryParse(s, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out result);

#else

      result = 0;

      bool succeeded = false;

      try {

        result = Int32.Parse(s, NumberFormatInfo.InvariantInfo);

        succeeded = true;

      }catch(ArgumentException){

      }catch(FormatException){

      }catch(OverflowException){}

      return succeeded;

#endif

    }

    internal static int StringCompareOrdinalIgnoreCase(string strA, int indexA, string strB, int indexB, int length) {

#if WHIDBEY

      return string.Compare(strA, indexA, strB, indexB, length, StringComparison.OrdinalIgnoreCase);

#else

      return string.Compare(strA, indexA, strB, indexB, length, true, CultureInfo.InvariantCulture); 

#endif

    }

    internal static int StringCompareOrdinalIgnoreCase(string strA, string strB) {

#if WHIDBEY

      return string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase);

#else

      return string.Compare(strA, strB, true, CultureInfo.InvariantCulture); 

#endif

    }  

  }

#if FxCop

  public class CatchNode : Statement{

    private Block block;

    private TypeNode type;

    private Expression variable;

    private Filter filter;

    internal int handlerEnd;

    internal CatchNode()

      : base(NodeType.Catch){

    }

    internal CatchNode(Block block, Expression variable, TypeNode type)

      : this(block, variable, type, null){

    }

    internal CatchNode(Block block, Expression variable, TypeNode type, Filter filter)

      : base(NodeType.Catch){

      this.block = block;

      this.variable = variable;

      this.type = type;

      this.filter = filter;

    }

    public Block Block{

      get{return this.block;}

      internal set{this.block = value;}

    }

    public Filter Filter{

      get{return this.filter;}

      internal set{this.filter = value;}

    }

    public TypeNode Type{

      get{return this.type;}

      internal set{this.type = value;}

    }

    public Expression Variable{

      get{return this.variable;}

      internal set{this.variable = value;}

    }

  }

  public class FinallyNode : Statement{

    private Block block;

    internal int handlerEnd;

    internal FinallyNode()

      : base(NodeType.Finally){

    }

    internal FinallyNode(Block block)

      : base(NodeType.Finally){

      this.block = block;

    }

    public Block Block{

      get{return this.block;}

      internal set{this.block = value;}

    }

  }

  public class TryNode : Statement {

    private CatchNodeCollection catchers = new CatchNodeCollection();

    private FaultHandler faultHandler;

    private FinallyNode finallyClause;

    private Block block;

    internal TryNode()

      : base(NodeType.Try) {

    }

    internal TryNode(Block block, CatchNodeCollection catchers, FaultHandler faultHandler, FinallyNode @finally)

      : base(NodeType.Try) {

      this.catchers = catchers;

      this.faultHandler = faultHandler;

      this.finallyClause = @finally;

      this.block = block;

    }

    internal int tryEnd;

    internal int handlersEnd;

    public CatchNodeCollection Catchers {

      get { return this.catchers; }

      internal set { this.catchers = value; }

    }

    public FaultHandler FaultHandler {

      get { return this.faultHandler; }

      internal set { this.faultHandler = value; }

    }

    public FinallyNode Finally {

      get { return this.finallyClause; }

      internal set { this.finallyClause = value; }

    }

    public Block Block {

      [DebuggerStepThrough] get { return this.block; }

      [DebuggerStepThrough] internal set { this.block = value; }

    }

  }

    public abstract class FormatOptions

    {

        internal Options m_options;



        protected FormatOptions() { }



        internal void SetOptions(Options options, bool enable)

        {

            if (enable)

            {

                this.m_options |= options;

                return;

            }

            this.m_options &= ~options;

        }



        internal bool IsSet(Options options)

        {

            return (this.m_options & options) == options;

        }



        [Flags]

        internal enum Options

        {

            None = 0x0,

            InsertSpacesBetweenParameters = 0x1,

            InsertSpacesBetweenTypeParameters = 0x2,

            InsertSpacesBetweenMethodTypeParameters = 0x4,

            ShowGenericTypeArity = 0x8,

            ShowGenericMethodTypeParameterNames = 0x10,

            ShowGenericTypeParameterNames = 0x20,

            ShowTypeModifiers = 0x40,

            ShowParameterNames = 0x80

        }

    }

    internal class MemberFormat : FormatOptions

    {

        TypeFormat m_declaringTypeFormat;

        TypeFormat m_returnTypeFormat;

        ParameterFormat m_parameterFormat;

    

        public MemberFormat()

        {

            this.m_declaringTypeFormat = new TypeFormat();

            this.m_returnTypeFormat = new TypeFormat();

            this.m_parameterFormat = new ParameterFormat();

        }

    

        public TypeFormat Type

        {

            get { return this.m_declaringTypeFormat; }

        }

    

        public TypeFormat ReturnType

        {

            get { return this.m_returnTypeFormat; }

        }

    

        public ParameterFormat Parameters

        {

            get { return this.m_parameterFormat; }

        }

    

        public bool ShowGenericMethodTypeParameterNames

        {

            get { return IsSet(Options.ShowGenericMethodTypeParameterNames); }

            set { SetOptions(Options.ShowGenericMethodTypeParameterNames, value); }

        }

    

        public bool InsertSpacesBetweenMethodTypeParameters

        {

            get { return IsSet(Options.InsertSpacesBetweenMethodTypeParameters); }

            set { SetOptions(Options.InsertSpacesBetweenMethodTypeParameters, value); }

        }

    }

    internal class ParameterFormat : TypeFormat

    {

        public ParameterFormat() { }

    

        public bool InsertSpacesBetweenParameters

        {

            get { return IsSet(Options.InsertSpacesBetweenParameters); }

            set { SetOptions(Options.InsertSpacesBetweenParameters, value); }

        }

    

        public bool ShowParameterNames

        {

            get { return IsSet(Options.ShowParameterNames); }

            set { SetOptions(Options.ShowParameterNames, value); }

        }

    }

    internal class TypeFormat : FormatOptions

    {

        private TypeNameFormat m_typeName;

        public TypeFormat() { }



        public TypeFormat Clone()

        {

            TypeFormat clone = new TypeFormat();

            clone.m_typeName = this.m_typeName;

            clone.m_options = this.m_options;

            return clone;

        }



        public bool InsertSpacesBetweenTypeParameters

        {

            get { return IsSet(Options.InsertSpacesBetweenTypeParameters); }

            set { SetOptions(Options.InsertSpacesBetweenTypeParameters, value); }

        }



        public bool ShowGenericTypeArity

        {

            get { return IsSet(Options.ShowGenericTypeArity); }

            set { SetOptions(Options.ShowGenericTypeArity, value); }

        }



        public bool ShowGenericTypeParameterNames

        {

            get { return IsSet(Options.ShowGenericTypeParameterNames); }

            set { SetOptions(Options.ShowGenericTypeParameterNames, value); }

        }



        public bool ShowTypeModifiers

        {

            get { return IsSet(Options.ShowTypeModifiers); }

            set { SetOptions(Options.ShowTypeModifiers, value); }

        }



        public TypeNameFormat TypeName

        {

            get { return this.m_typeName; }

            set { this.m_typeName = value; }

        }

    }

    internal enum TypeNameFormat

    {

        None = 0,

        InnermostNested,    

        Short,

        FullyQualified

    }

#endif

}