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 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 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 <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 <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 <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)); }
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 <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)); }
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 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, 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 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 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 IContentProvider GetContentProvider(Symbol symbol) { return(GetContentProvider(symbol.GetGlyph(), SymbolMarkup.ForSymbol(symbol))); }
public static string GetExpressionTypeString(TypeSymbol type) { return(SymbolMarkup.ForSymbol(type).ToString()); }
public sealed override string ToString() { return(SymbolMarkup.ForSymbol(this).ToString()); }
internal static SignatureItem ToSignatureItem(this Symbol symbol) { return(SymbolMarkup.ForSymbol(symbol).ToSignatureItem(IsCommaToken)); }