internal Symbol(SymbolKind kind, string name, string documentation, Symbol parent)
 {
     Kind = kind;
     Name = name;
     Documentation = documentation;
     Parent = parent;
 }

		public InlineCodeToken(TokenType type, string text = null, int index = -1, SymbolKind ownerType = default(SymbolKind), bool isExpandedParamArray = false) {
			Type   = type;
			_text  = text;
			_index = index;
			_ownerType = ownerType;
			_isExpandedParamArray = isExpandedParamArray;
		}

 /// <summary>
 /// Creates a new symbol information literal.
 ///
 /// @param name The name of the symbol.
 /// @param kind The kind of the symbol.
 /// @param range The range of the location of the symbol.
 /// @param uri The resource of the location of symbol, defaults to the current document.
 /// @param containerName The name of the symbol containg the symbol.
 /// </summary>
 public SymbolInformation(string name, SymbolKind kind, Range range, string uri, string containerName)
 {
     this.name = name;
     this.kind = kind;
     this.location = new Location(uri, range);
     this.containerName = containerName;
 }

 public Symbol(string symType, string symName,
     SymbolKind symKind, string declaringClassName)
 {
     Type = symType;
     Name = symName;
     Kind = symKind;
     DeclaringClassName = declaringClassName;
 }

        private string GetClass(SymbolKind kind)
        {
            if (kind == SymbolKind.TypeParameter)
            {
                return " t";
            }

            return "";
        }

        public Declaration(Position position, string name, SymbolKind kind, AST.Type type)
            : base(position)
        {
            _name = name;

            _kind = kind;

            _type = type;
            _type.Parent = this;
        }

 public static object GetErrorReportingName(SymbolKind kind)
 {
     switch (kind)
     {
         case SymbolKind.Namespace:
             return MessageID.IDS_SK_NAMESPACE.Localize();
         default:
             // TODO: what is the right way to get these strings?
             return kind.ToString().ToLower();
     }
 }

        public SymbolMetadata(
			string id, 
			string fullName, 
			string[] filePathsOfDeclarations, 
			SymbolKind symbolKind)
        {
            Id = id;
            FullName = fullName;
            DeclarationFilesPaths = filePathsOfDeclarations;
            SymbolKind = symbolKind;
        }

		/// <summary>
		/// Creates a type parameter reference.
		/// For common type parameter references, this method may return a shared instance.
		/// </summary>
		public static TypeParameterReference Create(SymbolKind ownerType, int index)
		{
			if (index >= 0 && index < 8 && (ownerType == SymbolKind.TypeDefinition || ownerType == SymbolKind.Method)) {
				TypeParameterReference[] arr = (ownerType == SymbolKind.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences;
				TypeParameterReference result = LazyInit.VolatileRead(ref arr[index]);
				if (result == null) {
					result = LazyInit.GetOrSet(ref arr[index], new TypeParameterReference(ownerType, index));
				}
				return result;
			} else {
				return new TypeParameterReference(ownerType, index);
			}
		}

		public DefaultMemberReference(SymbolKind symbolKind, ITypeReference typeReference, string name, int typeParameterCount = 0, IList<ITypeReference> parameterTypes = null)
		{
			if (typeReference == null)
				throw new ArgumentNullException("typeReference");
			if (name == null)
				throw new ArgumentNullException("name");
			if (typeParameterCount != 0 && symbolKind != SymbolKind.Method)
				throw new ArgumentException("Type parameter count > 0 is only supported for methods.");
			this.symbolKind = symbolKind;
			this.typeReference = typeReference;
			this.name = name;
			this.typeParameterCount = typeParameterCount;
			this.parameterTypes = parameterTypes ?? EmptyList<ITypeReference>.Instance;
		}

        internal InvocableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null)
            : base(kind, name, documentation, parent)
        {
            if (returnType == null)
                throw new ArgumentNullException(nameof(returnType));

            _parameters = new List<ParameterSymbol>();

            if (lazyParameters != null)
                foreach (var parameter in lazyParameters(this))
                    AddParameter(parameter);

            ReturnType = returnType;
        }

            private static IEnumerable<ValueTuple<ISymbol, int>> EnumerateSymbols(
                Compilation compilation, ISymbol containingSymbol,
                SymbolKind kind, string localName,
                CancellationToken cancellationToken)
            {
                int ordinal = 0;

                foreach (var declaringLocation in containingSymbol.DeclaringSyntaxReferences)
                {
                    // This operation can potentially fail. If containingSymbol came from 
                    // a SpeculativeSemanticModel, containingSymbol.ContainingAssembly.Compilation
                    // may not have been rebuilt to reflect the trees used by the 
                    // SpeculativeSemanticModel to produce containingSymbol. In that case,
                    // asking the ContainingAssembly's complation for a SemanticModel based
                    // on trees for containingSymbol with throw an ArgumentException.
                    // Unfortunately, the best way to avoid this (currently) is to see if
                    // we're asking for a model for a tree that's part of the compilation.
                    // (There's no way to get back to a SemanticModel from a symbol).

                    // TODO (rchande): It might be better to call compilation.GetSemanticModel
                    // and catch the ArgumentException. The compilation internally has a 
                    // Dictionary<SyntaxTree, ...> that it uses to check if the SyntaxTree
                    // is applicable wheras the public interface requires us to enumerate
                    // the entire IEnumerable of trees in the Compilation.
                    if (!compilation.SyntaxTrees.Contains(declaringLocation.SyntaxTree))
                    {
                        continue;
                    }

                    var node = declaringLocation.GetSyntax(cancellationToken);
                    if (node.Language == LanguageNames.VisualBasic)
                    {
                        node = node.Parent;
                    }

                    var semanticModel = compilation.GetSemanticModel(node.SyntaxTree);

                    foreach (var token in node.DescendantNodes())
                    {
                        var symbol = semanticModel.GetDeclaredSymbol(token, cancellationToken);

                        if (symbol != null &&
                            symbol.Kind == kind &&
                            SymbolKey.Equals(compilation, symbol.Name, localName))
                        {
                            yield return ValueTuple.Create(symbol, ordinal++);
                        }
                    }
                }
            }

		public DefaultTypeParameter(
			ICompilation compilation, SymbolKind ownerType,
			int index, string name = null,
			VarianceModifier variance = VarianceModifier.Invariant,
			IList<IAttribute> attributes = null,
			DomRegion region = default(DomRegion),
			bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false,
			IList<IType> constraints = null)
			: base(compilation, ownerType, index, name, variance, attributes, region)
		{
			this.hasValueTypeConstraint = hasValueTypeConstraint;
			this.hasReferenceTypeConstraint = hasReferenceTypeConstraint;
			this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint;
			this.constraints = constraints ?? EmptyList<IType>.Instance;
		}

		private string GetVimKind(SymbolKind entityType)
        {
    //        v	variable
    //f	function or method
    //m	member of a struct or class
            switch(entityType)
            {
			case(SymbolKind.Method):
                    return "f";
			case(SymbolKind.Field):
                    return "v";
			case(SymbolKind.Property):
                    return "m";
            }
            return " ";
        }

        static string GetMemberType(SymbolKind symbolKind)
        {
            switch (symbolKind)
            {
                case SymbolKind.Field:
                    return GettextCatalog.GetString("field");
                case SymbolKind.Method:
                    return GettextCatalog.GetString("method");
                case SymbolKind.Property:
                    return GettextCatalog.GetString("property");
                case SymbolKind.Event:
                    return GettextCatalog.GetString("event");
            }

            return GettextCatalog.GetString("member");
        }

 private bool AreEquivalentWorker(ISymbol x, ISymbol y, SymbolKind k, Dictionary<INamedTypeSymbol, INamedTypeSymbol> equivalentTypesWithDifferingAssemblies)
 {
     Contract.Requires(x.Kind == y.Kind && x.Kind == k);
     switch (k)
     {
         case SymbolKind.ArrayType:
             return ArrayTypesAreEquivalent((IArrayTypeSymbol)x, (IArrayTypeSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Assembly:
             return AssembliesAreEquivalent((IAssemblySymbol)x, (IAssemblySymbol)y);
         case SymbolKind.DynamicType:
             return DynamicTypesAreEquivalent((IDynamicTypeSymbol)x, (IDynamicTypeSymbol)y);
         case SymbolKind.Event:
             return EventsAreEquivalent((IEventSymbol)x, (IEventSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Field:
             return FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Label:
             return LabelsAreEquivalent((ILabelSymbol)x, (ILabelSymbol)y);
         case SymbolKind.Local:
             return LocalsAreEquivalent((ILocalSymbol)x, (ILocalSymbol)y);
         case SymbolKind.Method:
             return MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.NetModule:
             return ModulesAreEquivalent((IModuleSymbol)x, (IModuleSymbol)y);
         case SymbolKind.NamedType:
         case SymbolKind.ErrorType: // ErrorType is handled in NamedTypesAreEquivalent
             return NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Namespace:
             return NamespacesAreEquivalent((INamespaceSymbol)x, (INamespaceSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Parameter:
             return ParametersAreEquivalent((IParameterSymbol)x, (IParameterSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.PointerType:
             return PointerTypesAreEquivalent((IPointerTypeSymbol)x, (IPointerTypeSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Property:
             return PropertiesAreEquivalent((IPropertySymbol)x, (IPropertySymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.RangeVariable:
             return RangeVariablesAreEquivalent((IRangeVariableSymbol)x, (IRangeVariableSymbol)y);
         case SymbolKind.TypeParameter:
             return TypeParametersAreEquivalent((ITypeParameterSymbol)x, (ITypeParameterSymbol)y, equivalentTypesWithDifferingAssemblies);
         case SymbolKind.Preprocessing:
             return PreprocessingSymbolsAreEquivalent((IPreprocessingSymbol)x, (IPreprocessingSymbol)y);
         default:
             return false;
     }
 }

 internal static uint SymbolKindToFieldKind(SymbolKind kind) {
   uint ret = 0;
   if (kind == SymbolKind.All)
     ret = (uint ) FIELD_KIND.FIELD_KIND_ALL;
   else{
     if (0 != (kind & SymbolKind.Method))
       ret |= (uint ) (FIELD_KIND.FIELD_SYM_MEMBER|FIELD_KIND.FIELD_TYPE_METHOD);
     if (0 != (kind & SymbolKind.Property))
       ret |= (uint ) (FIELD_KIND.FIELD_SYM_MEMBER|FIELD_KIND.FIELD_TYPE_PROP);
     if (0 != (kind & SymbolKind.Field))
       ret |= (uint ) (FIELD_KIND.FIELD_KIND_ALL & ~(FIELD_KIND.FIELD_TYPE_METHOD|FIELD_KIND.FIELD_TYPE_PROP));
     if (0 != (kind & SymbolKind.This))
       ret |= (uint ) FIELD_KIND.FIELD_SYM_THIS;
     if (0 != (kind & SymbolKind.Local))
       ret |= (uint ) FIELD_KIND.FIELD_SYM_LOCAL;
     if (0 != (kind & SymbolKind.Parameter))
       ret |= (uint ) FIELD_KIND.FIELD_SYM_PARAM;
   }
   return ret;
 }

		static ITypeParameter GetTypeParameter(ref ITypeParameter[] typeParameters, SymbolKind symbolKind, int index)
		{
			ITypeParameter[] tps = typeParameters;
			while (index >= tps.Length) {
				// We don't have a normal type parameter for this index, so we need to extend our array.
				// Because the array can be used concurrently from multiple threads, we have to use
				// Interlocked.CompareExchange.
				ITypeParameter[] newTps = new ITypeParameter[index + 1];
				tps.CopyTo(newTps, 0);
				for (int i = tps.Length; i < newTps.Length; i++) {
					newTps[i] = new DummyTypeParameter(symbolKind, i);
				}
				ITypeParameter[] oldTps = Interlocked.CompareExchange(ref typeParameters, newTps, tps);
				if (oldTps == tps) {
					// exchange successful
					tps = newTps;
				} else {
					// exchange not successful
					tps = oldTps;
				}
			}
			return tps[index];
		}

        protected override Accessibility GetDefaultAccessibility(SymbolKind targetSymbolKind, CodeGenerationDestination destination)
        {
            switch (targetSymbolKind)
            {
                case SymbolKind.Field:
                case SymbolKind.Method:
                case SymbolKind.Property:
                case SymbolKind.Event:
                    return Accessibility.Private;

                case SymbolKind.NamedType:
                    switch (destination)
                    {
                        case CodeGenerationDestination.ClassType:
                        case CodeGenerationDestination.EnumType:
                        case CodeGenerationDestination.InterfaceType:
                        case CodeGenerationDestination.StructType:
                            return Accessibility.Private;
                        default:
                            return Accessibility.Internal;
                    }

                default:
                    Debug.Fail("Invalid symbol kind: " + targetSymbolKind);
                    throw Exceptions.ThrowEFail();
            }
        }

        protected LocalVariableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol valueType)
            : base(kind, name, documentation, parent, valueType)
        {

        }