private static void AppendName(this ICollection<SymbolMarkupToken> markup, SymbolMarkupKind kind, string name)
 {
     var displayName = !string.IsNullOrEmpty(name)
         ? name
         : "?";
     markup.Append(kind, displayName);
 }
Exemple #2
0
 private static void AppendName(this ICollection<SymbolMarkupToken> markup, SymbolMarkupKind kind, string name)
 {
     var displayName = !string.IsNullOrEmpty(name)
         ? name
         : "?";
     markup.Append(kind, displayName);
 }
        private static void AppendName(this ICollection <SymbolMarkupToken> markup, SymbolMarkupKind kind, string name)
        {
            var displayName = string.IsNullOrEmpty(name)
                                  ? @"?"
                                  : SyntaxFacts.GetValidIdentifier(name);

            markup.Append(kind, displayName);
        }
        private static IClassificationType GetClassificationType(SymbolMarkupKind kind, INQueryClassificationTypes classificationTypes)
        {
            switch (kind)
            {
            case SymbolMarkupKind.Whitespace:
                return(classificationTypes.WhiteSpace);

            case SymbolMarkupKind.Punctuation:
                return(classificationTypes.Punctuation);

            case SymbolMarkupKind.Keyword:
                return(classificationTypes.Keyword);

            case SymbolMarkupKind.TableName:
                return(classificationTypes.SchemaTable);

            case SymbolMarkupKind.CommonTableExpressionName:
                return(classificationTypes.CommonTableExpression);

            case SymbolMarkupKind.ColumnName:
                return(classificationTypes.Column);

            case SymbolMarkupKind.VariableName:
                return(classificationTypes.Variable);

            case SymbolMarkupKind.ParameterName:
                return(classificationTypes.Identifier);

            case SymbolMarkupKind.FunctionName:
                return(classificationTypes.Function);

            case SymbolMarkupKind.AggregateName:
                return(classificationTypes.Aggregate);

            case SymbolMarkupKind.MethodName:
                return(classificationTypes.Method);

            case SymbolMarkupKind.PropertyName:
                return(classificationTypes.Property);

            case SymbolMarkupKind.TypeName:
                return(classificationTypes.Identifier);

            default:
                throw ExceptionBuilder.UnexpectedValue(kind);
            }
        }
        public static string GetTag(SymbolMarkupKind kind)
        {
            switch (kind)
            {
            case SymbolMarkupKind.Whitespace:
                return(TextTags.Space);

            case SymbolMarkupKind.Punctuation:
                return(TextTags.Punctuation);

            case SymbolMarkupKind.Keyword:
                return(TextTags.Keyword);

            case SymbolMarkupKind.FieldName:
                return(TextTags.Field);

            case SymbolMarkupKind.LocalVariableName:
                return(TextTags.Local);

            case SymbolMarkupKind.ConstantBufferVariableName:
                return(TextTags.ConstantBufferField);

            case SymbolMarkupKind.GlobalVariableName:
                return(TextTags.Global);

            case SymbolMarkupKind.ParameterName:
                return(TextTags.Parameter);

            case SymbolMarkupKind.FunctionName:
                return(TextTags.Function);

            case SymbolMarkupKind.MethodName:
                return(TextTags.Method);

            case SymbolMarkupKind.ClassName:
                return(TextTags.Class);

            case SymbolMarkupKind.StructName:
                return(TextTags.Struct);

            case SymbolMarkupKind.InterfaceName:
                return(TextTags.Interface);

            case SymbolMarkupKind.ConstantBufferName:
                return(TextTags.ConstantBuffer);

            case SymbolMarkupKind.IntrinsicTypeName:
                return(TextTags.Keyword);

            case SymbolMarkupKind.NamespaceName:
                return(TextTags.Namespace);

            case SymbolMarkupKind.SemanticName:
                return(TextTags.Semantic);

            case SymbolMarkupKind.TechniqueName:
                return(TextTags.Technique);

            case SymbolMarkupKind.PlainText:
                return(TextTags.Text);

            default:
                return(string.Empty);
            }
        }
Exemple #6
0
 internal SymbolMarkupToken(SymbolMarkupKind kind, string text)
 {
     Kind = kind;
     Text = text;
 }
 private static void Append(this ICollection<SymbolMarkupToken> markup, SymbolMarkupKind kind, string text)
 {
     markup.Add(new SymbolMarkupToken(kind, text));
 }
 public SymbolMarkupToken(SymbolMarkupKind kind, string text)
 {
     _kind = kind;
     _text = text;
 }
Exemple #9
0
 private static void Append(this ICollection<SymbolMarkupToken> markup, SymbolMarkupKind kind, string text)
 {
     markup.Add(new SymbolMarkupToken(kind, text));
 }