public static QuickInfoModel ForSymbol(SemanticModel semanticModel, TextSpan span, Symbol symbol) { var glyph = symbol.GetGlyph(); var symbolMarkup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, symbol.Documentation)); }
public static QuickInfoModel ForMacroReference(SemanticModel semanticModel, TextSpan span, MacroReference macroReference) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro reference) {macroReference.DefineDirective.ToString(true)}") }); return(new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty)); }
public void TestIntrinsicFunctionOverloading(string function, string type1, string type2, string expectedMatchTypes) { var expressionCode = $"{function}(({type1}) 0, ({type2}) 0)"; var syntaxTree = SyntaxFactory.ParseExpression(expressionCode); var syntaxTreeSource = syntaxTree.Root.ToFullString(); Assert.AreEqual(expressionCode, syntaxTreeSource, $"Source should have been {expressionCode} but is {syntaxTreeSource}."); var expression = (ExpressionSyntax)syntaxTree.Root; var compilation = new HlslTools.Compilation.Compilation(syntaxTree); var semanticModel = compilation.GetSemanticModel(); var combinedDiagnostics = syntaxTree.GetDiagnostics().Concat(semanticModel.GetDiagnostics()).ToList(); foreach (var d in combinedDiagnostics) { Debug.WriteLine(d); } var invokedFunctionSymbol = (FunctionSymbol)semanticModel.GetSymbol(expression); var diagnostic = combinedDiagnostics.SingleOrDefault(x => x.Severity == Diagnostics.DiagnosticSeverity.Error); var result = diagnostic == null ? $"{SymbolMarkup.ForSymbol(invokedFunctionSymbol.Parameters[0].ValueType)}, {SymbolMarkup.ForSymbol(invokedFunctionSymbol.Parameters[1].ValueType)}" : ExpressionTestUtility.GetErrorString(diagnostic.DiagnosticId); Assert.AreEqual(expectedMatchTypes, result, $"Expression should have matched the function overload '{expectedMatchTypes}' but it actually matched '{result}'."); }
private static void AppendMarkup(this StringBuilder sb, SymbolMarkup symbolMarkup, INQueryClassificationTypes classificationTypes, IHighlightingStyleRegistry highlightingStyleRegistry) { foreach (var node in symbolMarkup.Tokens) { sb.AppendNode(node, classificationTypes, highlightingStyleRegistry); } }
public QuickInfoModel(SemanticModel semanticModel, TextSpan span, Glyph glyph, SymbolMarkup markup) { SemanticModel = semanticModel; Span = span; Glyph = glyph; Markup = markup; }
public IContentProvider GetContentProvider(Glyph glyph, SymbolMarkup symbolMarkup) { var classificationTypes = ClassificationTypes; var registry = AmbientHighlightingStyleRegistry.Instance; return(HtmlContentProviderWithGlyph.Create(glyph, symbolMarkup, classificationTypes, registry)); }
public static QuickInfoModel ForMacroDefinition(SemanticModel semanticModel, TextSpan span, DefineDirectiveTriviaSyntax macroDefinition) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro definition) {macroDefinition}") }); return(new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty)); }
public static string GetHtml(Glyph glyph, SymbolMarkup symbolMarkup, INQueryClassificationTypes classificationTypes, IHighlightingStyleRegistry highlightingStyleRegistry) { var sb = new StringBuilder(); sb.AppendGlyph(glyph); sb.AppendMarkup(symbolMarkup, classificationTypes, highlightingStyleRegistry); return(sb.ToString()); }
private QuickInfoModel(SemanticModel semanticModel, TextSpan span, Glyph glyph, SymbolMarkup markup, string documentation) { SemanticModel = semanticModel; Span = span; Glyph = glyph; Markup = markup; Documentation = documentation; }
private static CompletionItem CreateSymbolCompletion(Symbol symbol) { var displayText = symbol.Name; var insertionText = symbol.Name; var description = SymbolMarkup.ForSymbol(symbol).ToString(); var glyph = symbol.GetGlyph(); return(new CompletionItem(displayText, insertionText, description, glyph, symbol)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <CoalesceExpressionSyntax>().Single(); var span = syntax.CoalesceKeyword.Span; var markup = SymbolMarkup.ForCoalesceSymbol(); return(new QuickInfoModel(semanticModel, span, Glyph.Function, markup)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <CountAllExpressionSyntax>().Single(); var span = syntax.Name.Span; var symbol = GetCountAggregate(semanticModel.Compilation.DataContext); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.Aggregate, markup)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <WildcardSelectColumnSyntax>().Single(); var span = syntax.TableName.Span; var symbol = semanticModel.GetTableInstance(syntax); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.TableInstance, markup)); }
private TextBlock GetTextBlock(SymbolMarkup markup) { var textBlock = new TextBlock { TextWrapping = TextWrapping.Wrap }; textBlock.Inlines.AddRange(markup.Tokens.Select(GetInline)); return(textBlock); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <PropertyAccessExpressionSyntax>().Single(); var span = syntax.Name.Span; var symbol = semanticModel.GetSymbol(syntax); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.Property, markup)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <ExpressionSelectColumnSyntax>().Single(); var span = syntax.Alias.Identifier.Span; var symbol = semanticModel.GetDeclaredSymbol(syntax); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.Column, markup)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <DerivedTableReferenceSyntax>().Single(); var span = syntax.Name.Span; var symbol = semanticModel.GetDeclaredSymbol(syntax); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.TableInstance, markup)); }
protected override QuickInfoModel CreateExpectedModel(SemanticModel semanticModel) { var syntaxTree = semanticModel.SyntaxTree; var syntax = syntaxTree.Root.DescendantNodes().OfType <MethodInvocationExpressionSyntax>().Last(); var span = syntax.Name.Span; var symbol = semanticModel.GetSymbol(syntax); var markup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, Glyph.Method, markup)); }
private TextBlock GetTextBlock(SymbolMarkup markup) { var textBlock = new TextBlock { VerticalAlignment = VerticalAlignment.Center, FontFamily = new FontFamily(@"Consolas") }; textBlock.Inlines.AddRange(markup.Tokens.Select(GetInline)); return(textBlock); }
public static QuickInfoModel ForSymbol(SemanticModel semanticModel, TextSpan span, Symbol symbol) { if (symbol.Kind == SymbolKind.ErrorTable) { return(null); } var glyph = symbol.GetGlyph(); var symbolMarkup = SymbolMarkup.ForSymbol(symbol); return(new QuickInfoModel(semanticModel, span, glyph, symbolMarkup)); }
private static void AssertIsMatch(string query, Type type, string propertyName) { var completionModel = GetCompletionModel(query); var semanticModel = completionModel.SemanticModel; var property = semanticModel.LookupProperties(type).Single(p => p.Name == propertyName); var propertyItem = completionModel.Items.Single(i => i.InsertionText == property.Name); var propertyMarkup = SymbolMarkup.ForSymbol(property); Assert.Equal(Glyph.Property, propertyItem.Glyph); Assert.Equal(property.Name, propertyItem.DisplayText); Assert.Equal(propertyMarkup.ToString(), propertyItem.Description); Assert.Equal(property, propertyItem.Symbol); }
private static SignatureItem ToSignatureItem <TSymbol>(this TSymbol symbol, Func <SymbolMarkupToken, bool> separatorPredicate) where TSymbol : InvocableSymbol { var markup = SymbolMarkup.ForSymbol(symbol); var sb = new StringBuilder(); var parameterStart = 0; var nextNonWhitespaceStartsParameter = false; var parameterSpans = new List <TextSpan>(); var parameterNamesAndDocs = new List <Tuple <string, string> >(); foreach (var node in markup.Tokens) { var isParameterName = node.Kind == SymbolMarkupKind.ParameterName; var isWhitespace = node.Kind == SymbolMarkupKind.Whitespace; var isLeftParenthesis = node.Kind == SymbolMarkupKind.Punctuation && node.Text == "("; var isRightParenthesis = node.Kind == SymbolMarkupKind.Punctuation && node.Text == ")"; var isSeparator = separatorPredicate(node); if (isParameterName) { parameterNamesAndDocs.Add(Tuple.Create(node.Text, symbol.Parameters[parameterNamesAndDocs.Count].Documentation)); } if (isLeftParenthesis) { nextNonWhitespaceStartsParameter = true; } else if (isSeparator || isRightParenthesis) { var end = sb.Length; var span = TextSpan.FromBounds(null, parameterStart, end); parameterSpans.Add(span); nextNonWhitespaceStartsParameter = true; } else if (!isWhitespace && nextNonWhitespaceStartsParameter) { parameterStart = sb.Length; nextNonWhitespaceStartsParameter = false; } sb.Append(node.Text); } var parameters = parameterSpans .Zip(parameterNamesAndDocs, (s, n) => new ParameterItem(n.Item1, n.Item2, s)) .ToImmutableArray(); return(new SignatureItem(symbol, sb.ToString(), symbol.Documentation, parameters)); }
private static void AssertIsMatch(string query, string tableName) { var completionModel = GetCompletionModel(query); var dataContext = completionModel.SemanticModel.Compilation.DataContext; var table = dataContext.Tables.Single(t => t.Name == tableName); var tableItem = completionModel.Items.Single(i => i.InsertionText == table.Name); var tableMarkup = SymbolMarkup.ForSymbol(table); Assert.Equal(Glyph.Table, tableItem.Glyph); Assert.Equal(table.Name, tableItem.DisplayText); Assert.Equal(tableMarkup.ToString(), tableItem.Description); Assert.Equal(table, tableItem.Symbol); }
private static void AssertIsMatch(string query, string functionName) { var completionModel = GetCompletionModel(query); var dataContext = completionModel.SemanticModel.Compilation.DataContext; var function = dataContext.Functions.Single(t => t.Name == functionName); var functionItem = completionModel.Items.Single(i => i.InsertionText == function.Name); var functionMarkup = SymbolMarkup.ForSymbol(function); Assert.Equal(Glyph.Function, functionItem.Glyph); Assert.Equal(function.Name, functionItem.DisplayText); Assert.Equal(functionMarkup.ToString(), functionItem.Description); Assert.Equal(function, functionItem.Symbol); }
private static void GetCompletionData(string query, string tableInstanceName, string columnName, out TableColumnInstanceSymbol column, out CompletionItem columnItem, out SymbolMarkup columnMarkup) { var completionModel = GetCompletionModel(query); var semanticModel = completionModel.SemanticModel; var syntaxTree = semanticModel.SyntaxTree; var tableReference = syntaxTree.Root.DescendantNodesAndSelf() .OfType <NamedTableReferenceSyntax>() .Select(semanticModel.GetDeclaredSymbol) .Single(s => s != null && s.Name == tableInstanceName); column = tableReference.ColumnInstances.Single(c => c.Name == columnName); columnItem = completionModel.Items.Single(i => i.InsertionText == columnName); columnMarkup = SymbolMarkup.ForSymbol(column); }
public void TestFunctionOverloadResolution2Args(string type1, string type2, string expectedMatchTypes) { var code = $@" int foo(int x, float y) {{ return 1; }} int foo(float x, float y) {{ return 2; }} int foo(double x, float y) {{ return 3; }} int foo(float x, int y) {{ return 4; }} int foo(float x, double y) {{ return 5; }} int foo(double x, int y) {{ return 6; }} int foo(int2 x, float y) {{ return 7; }} int foo(float2 x, float y) {{ return 8; }} int foo(double2 x, float y) {{ return 9; }} int foo(float3x3 x, float y) {{ return 10; }} void main() {{ foo({ExpressionTestUtility.GetValue(type1)}, {ExpressionTestUtility.GetValue(type2)}); }}"; var syntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From(code)); var syntaxTreeSource = syntaxTree.Root.ToFullString(); Assert.AreEqual(code, syntaxTreeSource, $"Source should have been {code} but is {syntaxTreeSource}."); var expression = (FunctionInvocationExpressionSyntax)syntaxTree.Root.ChildNodes .OfType <FunctionDefinitionSyntax>() .Where(x => x.Name.GetName() == "main") .Select(x => ((ExpressionStatementSyntax)x.Body.Statements[0]).Expression) .First(); var compilation = new HlslTools.Compilation.Compilation(syntaxTree); var semanticModel = compilation.GetSemanticModel(); var combinedDiagnostics = syntaxTree.GetDiagnostics().Concat(semanticModel.GetDiagnostics()).ToList(); foreach (var d in combinedDiagnostics) { Debug.WriteLine(d); } var invokedFunctionSymbol = (FunctionSymbol)semanticModel.GetSymbol(expression); var diagnostic = combinedDiagnostics.SingleOrDefault(x => x.Severity == Diagnostics.DiagnosticSeverity.Error); var result = diagnostic == null ? $"{SymbolMarkup.ForSymbol(invokedFunctionSymbol.Parameters[0].ValueType)}, {SymbolMarkup.ForSymbol(invokedFunctionSymbol.Parameters[1].ValueType)}" : ExpressionTestUtility.GetErrorString(diagnostic.DiagnosticId); Assert.AreEqual(expectedMatchTypes, result, $"Expression should have matched the function overload '{expectedMatchTypes}' but it actually matched '{result}'."); }
private static SignatureItem ToSignatureItem(this SymbolMarkup markup, Func <SymbolMarkupToken, bool> separatorPredicate) { var sb = new StringBuilder(); var parameterStart = 0; var nextNonWhitespaceStartsParameter = false; var parameterSpans = new List <TextSpan>(); var parameterNames = new List <string>(); foreach (var node in markup.Tokens) { var isParameterName = node.Kind == SymbolMarkupKind.ParameterName; var isWhitespace = node.Kind == SymbolMarkupKind.Whitespace; var isLeftParenthesis = node.Kind == SymbolMarkupKind.Punctuation && node.Text == @"("; var isRightParenthesis = node.Kind == SymbolMarkupKind.Punctuation && node.Text == @")"; var isSeparator = separatorPredicate(node); if (isParameterName) { parameterNames.Add(node.Text); } if (isLeftParenthesis) { nextNonWhitespaceStartsParameter = true; } else if (isSeparator || isRightParenthesis) { var end = sb.Length; var span = TextSpan.FromBounds(parameterStart, end); parameterSpans.Add(span); nextNonWhitespaceStartsParameter = true; } else if (!isWhitespace && nextNonWhitespaceStartsParameter) { parameterStart = sb.Length; nextNonWhitespaceStartsParameter = false; } sb.Append(node.Text); } var parameters = parameterSpans.Zip(parameterNames, (s, n) => new ParameterItem(n, s)).ToImmutableArray(); var content = sb.ToString(); return(new SignatureItem(content, parameters)); }
private static void AssertIsMatch(string query, Type type, string methodName) { var completionModel = GetCompletionModel(query); var semanticModel = completionModel.SemanticModel; var method = semanticModel.LookupMethods(type) .Where(m => m.Name == methodName) .OrderBy(m => m.Parameters.Length) .First(); var methodItem = completionModel.Items.Single(i => i.InsertionText == method.Name); var methodMarkup = SymbolMarkup.ForSymbol(method); var overloadCount = semanticModel.LookupMethods(type) .Count(m => m.Name == methodName) - 1; var expectedDescription = overloadCount == 0 ? methodMarkup.ToString() : $"{methodMarkup} (+ {overloadCount} overload(s))"; Assert.Equal(Glyph.Method, methodItem.Glyph); Assert.Equal(method.Name, methodItem.DisplayText); Assert.Equal(expectedDescription, methodItem.Description); }
public static QuickInfoModel ForMacroDefinition(SemanticModel semanticModel, TextSpan span, DefineDirectiveTriviaSyntax macroDefinition) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro definition) {macroDefinition}") }); return new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty); }
public static QuickInfoModel ForMacroReference(SemanticModel semanticModel, TextSpan span, MacroReference macroReference) { var glyph = Glyph.Macro; var symbolMarkup = new SymbolMarkup(new[] { new SymbolMarkupToken(SymbolMarkupKind.PlainText, $"(macro reference) {macroReference.DefineDirective.ToString(true)}") }); return new QuickInfoModel(semanticModel, span, glyph, symbolMarkup, string.Empty); }
private TextBlock GetTextBlock(SymbolMarkup markup) { var textBlock = new TextBlock { TextWrapping = TextWrapping.Wrap }; textBlock.Inlines.AddRange(markup.Tokens.Select(GetInline)); return textBlock; }
protected override QuickInfoModel CreateModel(SemanticModel semanticModel, int position, CoalesceExpressionSyntax node) { var keywordSpan = node.CoalesceKeyword.Span; return(!keywordSpan.ContainsOrTouches(position) ? null : new QuickInfoModel(semanticModel, keywordSpan, Glyph.Function, SymbolMarkup.ForCoalesceSymbol())); }
public static HtmlContentProvider Create(Glyph glyph, SymbolMarkup symbolMarkup, INQueryClassificationTypes classificationTypes, IHighlightingStyleRegistry highlightingStyleRegistry) { var htmlSnippet = HtmlMarkupEmitter.GetHtml(glyph, symbolMarkup, classificationTypes, highlightingStyleRegistry); return(new HtmlContentProviderWithGlyph(htmlSnippet)); }