private static void AppendFunctionSymbolInfo(this ICollection<SymbolMarkupToken> markup, FunctionSymbol symbol)
 {
     markup.AppendType(symbol.ValueType);
     markup.AppendSpace();
     markup.AppendName(SymbolMarkupKind.FunctionName, symbol.Name);
     markup.AppendParameters(symbol.Parameters);
 }
 private static void AppendMethodSymbolInfo(this ICollection<SymbolMarkupToken> markup, MethodSymbol symbol)
 {
     markup.AppendType(symbol.AssociatedType);
     markup.AppendSpace();
     markup.AppendName(SymbolMarkupKind.MethodName, symbol.Name);
     markup.AppendParameters(symbol.Parameters);
 }
 private static void AppendType(this ICollection<SymbolMarkupToken> markup, TypeSymbol symbol)
 {
     markup.AppendName(SymbolMarkupKind.TypeName, symbol.FullName);
 }
        private static void AppendFunctionSymbolInfo(this ICollection<SymbolMarkupToken> markup, FunctionSymbol symbol)
        {
            markup.AppendType(symbol.ReturnType, false);
            markup.AppendSpace();

            if (symbol.Parent is TypeSymbol)
            {
                markup.AppendTypeName((TypeSymbol) symbol.Parent);
                markup.AppendPunctuation(".");
            }

            if (symbol.IsNumericConstructor)
                markup.AppendKeyword(symbol.Name);
            else
                markup.AppendName(SymbolMarkupKind.FunctionName, symbol.Name);

            markup.AppendParameters(symbol.Parameters);
        }
 private static void AppendParameterName(this ICollection<SymbolMarkupToken> markup, string text)
 {
     markup.AppendName(SymbolMarkupKind.ParameterName, text);
 }
        private static void AppendNamespace(this ICollection<SymbolMarkupToken> markup, NamespaceSymbol symbol)
        {
            markup.AppendKeyword("namespace");
            markup.AppendSpace();

            if (symbol.Parent != null)
                markup.AppendParentScope(symbol.Parent);

            markup.AppendName(SymbolMarkupKind.NamespaceName, symbol.Name);
        }
        private static void AppendParentScope(this ICollection<SymbolMarkupToken> markup, Symbol symbol)
        {
            if (symbol.Parent != null)
                AppendParentScope(markup, symbol.Parent);

            switch (symbol.Kind)
            {
                case SymbolKind.Namespace:
                    markup.AppendName(SymbolMarkupKind.NamespaceName, symbol.Name);
                    markup.AppendPunctuation("::");
                    break;
                case SymbolKind.Class:
                    markup.AppendName(SymbolMarkupKind.ClassName, symbol.Name);
                    markup.AppendPunctuation("::");
                    break;
                default:
                    return;
            }
        }
        private static void AppendTechnique(this ICollection<SymbolMarkupToken> markup, TechniqueSymbol symbol)
        {
            markup.AppendKeyword("technique");
            markup.AppendSpace();

            markup.AppendName(SymbolMarkupKind.TechniqueName, symbol.Name);
        }
        private static void AppendTypeAlias(this ICollection<SymbolMarkupToken> markup, TypeAliasSymbol symbol)
        {
            markup.AppendKeyword("typedef");
            markup.AppendSpace();

            markup.AppendType(symbol.ValueType, true);
            markup.AppendSpace();

            markup.AppendName(SymbolMarkupKind.GlobalVariableName, symbol.Name);
        }
        private static void AppendConstantBuffer(this ICollection<SymbolMarkupToken> markup, ConstantBufferSymbol symbol)
        {
            markup.AppendPlainText("(constant buffer)");
            markup.AppendSpace();

            markup.AppendName(SymbolMarkupKind.ConstantBufferVariableName, symbol.Name);
        }
 private static void AppendAttribute(this ICollection<SymbolMarkupToken> markup, AttributeSymbol symbol)
 {
     markup.AppendName(SymbolMarkupKind.FunctionName, symbol.Name);
     markup.AppendParameters(symbol.Parameters);
 }
        private static void AppendSemantic(this ICollection<SymbolMarkupToken> markup, SemanticSymbol symbol)
        {
            markup.AppendPlainText("(semantic)");
            markup.AppendSpace();

            markup.AppendName(SymbolMarkupKind.SemanticName, symbol.Name);
        }
 private static void AppendTypeName(this ICollection<SymbolMarkupToken> markup, TypeSymbol symbol)
 {
     switch (symbol.Kind)
     {
         case SymbolKind.Class:
             markup.AppendName(SymbolMarkupKind.ClassName, symbol.Name);
             break;
         case SymbolKind.Interface:
             markup.AppendName(SymbolMarkupKind.InterfaceName, symbol.Name);
             break;
         case SymbolKind.Struct:
             markup.AppendName(SymbolMarkupKind.StructName, symbol.Name);
             break;
         case SymbolKind.IntrinsicMatrixType:
         case SymbolKind.IntrinsicObjectType:
         case SymbolKind.IntrinsicScalarType:
         case SymbolKind.IntrinsicVectorType:
             // TODO: Need something better for templated predefined objects.
             markup.AppendName(SymbolMarkupKind.Keyword, symbol.Name);
             break;
         case SymbolKind.Array:
             // TODO: Could separate out square brackets as punctuation.
             markup.AppendName(SymbolMarkupKind.IntrinsicTypeName, symbol.Name);
             break;
     }
 }
 private static void AppendPlainText(this ICollection<SymbolMarkupToken> markup, string text)
 {
     markup.AppendName(SymbolMarkupKind.PlainText, text);
 }
        private static void AppendVariableSymbolInfo(this ICollection<SymbolMarkupToken> markup, VariableSymbol symbol)
        {
            VariableType variableType;
            if (symbol.Parent == null)
                variableType = VariableType.Global;
            else if (symbol.Parent.Kind == SymbolKind.ConstantBuffer)
                variableType = VariableType.ConstantBuffer;
            else
                variableType = VariableType.Local;

            switch (variableType)
            {
                case VariableType.Local:
                    markup.AppendPlainText("(local variable)");
                    break;
                case VariableType.ConstantBuffer:
                    markup.AppendPlainText("(constant buffer variable)");
                    break;
                case VariableType.Global:
                    markup.AppendPlainText("(global variable)");
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            markup.AppendSpace();
            markup.AppendType(symbol.ValueType, true);
            markup.AppendSpace();

            switch (variableType)
            {
                case VariableType.Local:
                    markup.AppendName(SymbolMarkupKind.LocalVariableName, symbol.Name);
                    break;
                case VariableType.ConstantBuffer:
                    markup.AppendName(SymbolMarkupKind.ConstantBufferVariableName, symbol.Name);
                    break;
                case VariableType.Global:
                    markup.AppendName(SymbolMarkupKind.GlobalVariableName, symbol.Name);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
 private static void AppendFieldSymbolInfo(this ICollection<SymbolMarkupToken> markup, FieldSymbol symbol)
 {
     markup.AppendPlainText("(field)");
     markup.AppendSpace();
     markup.AppendType(symbol.ValueType, true);
     markup.AppendSpace();
     markup.AppendType((TypeSymbol) symbol.Parent, false);
     markup.AppendPunctuation(".");
     markup.AppendName(SymbolMarkupKind.FieldName, symbol.Name);
 }