private static void AssertIsMatch(string sql)
{
ImmutableArray <TextSpan> textSpans;
var query = sql.ParseSpans(out textSpans);
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
foreach (var span in textSpans)
{
var symbolSpan = semanticModel.FindSymbol(span.End).Value;
Assert.NotNull(symbolSpan.Symbol);
Assert.Equal(span, symbolSpan.Span);
var usageSymbolSpans = semanticModel.FindUsages(symbolSpan.Symbol).ToImmutableArray();
var usageSpans = usageSymbolSpans.Select(s => s.Span).ToImmutableArray();
foreach (var usageSymbolSpan in usageSymbolSpans)
{
Assert.Equal(usageSymbolSpan.Symbol, symbolSpan.Symbol);
}
foreach (var usageSpan in usageSpans)
{
Assert.Contains(usageSpan, textSpans);
}
foreach (var textSpan in textSpans)
{
Assert.Contains(textSpan, usageSpans);
}
}
}
private static void AssertBindsToCommonTypes <T>(string queryCombinator)
where T : QuerySyntax
{
var query = $@"
SELECT e.EmployeeID * 2.0,
e.LastName,
e.FirstName,
e.ReportsTo
FROM Employees e
{queryCombinator}
SELECT e.EmployeeID,
e.LastName,
e.FirstName,
e.ReportsTo * 2.0
FROM Employees e
";
var compilation = CompilationFactory.CreateQuery(query);
var combinedQuery = compilation.SyntaxTree.Root.DescendantNodes().OfType <T>().Single();
var semanticModel = compilation.GetSemanticModel();
var columns = semanticModel.GetOutputColumns(combinedQuery).ToImmutableArray();
Assert.Equal(4, columns.Length);
Assert.Equal(typeof(double), columns[0].Type);
Assert.Equal(typeof(string), columns[1].Type);
Assert.Equal(typeof(string), columns[2].Type);
Assert.Equal(typeof(double), columns[3].Type);
}
private static void AssertIsMatch(string queryWithJoinMarker)
{
var normalized = queryWithJoinMarker.NormalizeCode();
TextSpan span;
var queryWithJoin = normalized.ParseSingleSpan(out span);
var condition = queryWithJoin.Substring(span);
var query = queryWithJoin.Remove(span.Start, span.Length);
var position = span.Start;
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
var provider = new JoinCompletionProvider();
var providers = new[] { provider };
var completionModel = semanticModel.GetCompletionModel(position, providers);
var item = completionModel.Items.Single(i => i.InsertionText == condition);
Assert.Equal(Glyph.Relation, item.Glyph);
Assert.Equal(condition, item.Description);
Assert.Equal(condition, item.DisplayText);
Assert.Equal(condition, item.InsertionText);
Assert.Equal(null, item.Symbol);
}
protected void AssertIsMatch(string queryWithMarkers)
{
ImmutableArray <TextSpan> spans;
var query = queryWithMarkers.ParseSpans(out spans);
var applicableSpan = spans[0];
var parameterSpans = spans.Skip(1).ToImmutableArray();
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
var provider = CreateProvider();
var providers = new[] { provider };
for (var i = 0; i < parameterSpans.Length; i++)
{
var parameterSpan = parameterSpans[i];
var start = parameterSpan.Start;
var middle = parameterSpan.Start + parameterSpan.Length / 2;
var end = parameterSpan.Start;
AssertIsMatch(semanticModel, start, providers, applicableSpan, i);
AssertIsMatch(semanticModel, middle, providers, applicableSpan, i);
AssertIsMatch(semanticModel, end, providers, applicableSpan, i);
}
}
private BraceMatchingResult Match(string query, int position)
{
var compilation = CompilationFactory.CreateQuery(query);
var syntaxTree = compilation.SyntaxTree;
var matcher = CreateMatcher();
return(syntaxTree.MatchBraces(position, new[] { matcher }));
}
public void Null_ImplicitConversionsFail_WhenAmbiguous()
{
var compilation = CompilationFactory.CreateQuery("SELECT ROUND(NULL)");
var syntaxTree = compilation.SyntaxTree;
var semanticModel = compilation.GetSemanticModel();
var diagnostics = syntaxTree.GetDiagnostics().Concat(semanticModel.GetDiagnostics()).ToImmutableArray();
Assert.Equal(1, diagnostics.Length);
Assert.Equal(DiagnosticId.AmbiguousInvocation, diagnostics[0].DiagnosticId);
}
protected ImmutableArray <CodeIssue> GetIssues(string query)
{
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
var provider = CreateProvider();
var providers = new[] { provider };
return(semanticModel.GetIssues(providers).ToImmutableArray());
}
private static CompletionModel GetCompletionModel(string query)
{
int position;
var actualQuery = query.ParseSinglePosition(out position);
var compilation = CompilationFactory.CreateQuery(actualQuery);
var semanticModel = compilation.GetSemanticModel();
return(CreateCompletionModel(semanticModel, position));
}
protected static CompletionModel GetCompletionModel(string query)
{
int position;
var compilation = CompilationFactory.CreateQuery(query, out position);
var semanticModel = compilation.GetSemanticModel();
var provider = new SymbolCompletionProvider();
var providers = new[] { provider };
return(semanticModel.GetCompletionModel(position, providers));
}
protected override ImmutableArray <ICodeAction> GetActions(string query)
{
int position;
var compilation = CompilationFactory.CreateQuery(query, out position);
var semanticModel = compilation.GetSemanticModel();
var provider = CreateProvider();
var providers = new[] { provider };
return(semanticModel.GetRefactorings(position, providers).ToImmutableArray());
}
protected void AssertIsNoMatch(string query)
{
var compilation = CompilationFactory.CreateQuery(query);
var root = compilation.SyntaxTree.Root;
var outliner = CreateOutliner();
var outliners = ImmutableArray.Create(outliner);
var actualRegions = root.FindRegions(root.FullSpan, outliners);
Assert.Empty(actualRegions);
}
protected void AssertIsMatch(string queryWithMarkers, string expectedText)
{
TextSpan expectedSpan;
var query = queryWithMarkers.ParseSingleSpan(out expectedSpan);
var compilation = CompilationFactory.CreateQuery(query);
var root = compilation.SyntaxTree.Root;
var outliner = CreateOutliner();
var outliners = ImmutableArray.Create(outliner);
AssertIsMatch(root, outliners, expectedSpan, expectedText);
}
public void Null_SelectNullExpression_IsTyped()
{
var text = "SELECT 1.0 + NULL";
var compilation = CompilationFactory.CreateQuery(text);
var syntaxTree = compilation.SyntaxTree;
var semanticModel = compilation.GetSemanticModel();
var query = (SelectQuerySyntax)syntaxTree.Root.Root;
var columns = semanticModel.GetOutputColumns(query).ToImmutableArray();
Assert.Equal(1, columns.Length);
Assert.Equal(typeof(double), columns[0].Type);
Assert.Equal(string.Empty, columns[0].Name);
}
private static CompletionModel GetCompletionModel(string queryWithJoinMarker)
{
var normalized = queryWithJoinMarker.NormalizeCode();
int position;
var compilation = CompilationFactory.CreateQuery(normalized, out position);
var semanticModel = compilation.GetSemanticModel();
var provider = new TypeCompletionProvider();
var providers = new[] { provider };
return(semanticModel.GetCompletionModel(position, providers));
}
private static CompletionModel GetCompletionModelWithFirstChar(string query, string keyword)
{
int position;
var actualQuery = query.ParseSinglePosition(out position);
var modifiedQuery = actualQuery.Insert(position, keyword.Substring(0, 1));
position++;
var compilation = CompilationFactory.CreateQuery(modifiedQuery);
var semanticModel = compilation.GetSemanticModel();
return(CreateCompletionModel(semanticModel, position));
}
private static CompletionModel GetCompletionModel(string queryWithPosition)
{
var normalized = queryWithPosition.NormalizeCode();
int position;
var query = normalized.ParseSinglePosition(out position);
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
var provider = new AliasCompletionProvider();
var providers = new[] { provider };
var completionModel = semanticModel.GetCompletionModel(position, providers);
return(completionModel);
}
protected void AssertIsMatch(string queryWithMarkers)
{
ImmutableArray <TextSpan> expectedSpans;
var query = queryWithMarkers.ParseSpans(out expectedSpans);
var compilation = CompilationFactory.CreateQuery(query);
var semanticModel = compilation.GetSemanticModel();
var highlighter = CreateHighlighter();
var highlighters = ImmutableArray.Create(highlighter);
Assert.True(expectedSpans.Length > 0);
foreach (var span in expectedSpans)
{
AssertIsMatch(semanticModel, span, highlighters, expectedSpans);
}
}
private static void AssertHasErrors(string query)
{
ImmutableArray <TextSpan> spans;
var compilation = CompilationFactory.CreateQuery(query, out spans);
var semanticModel = compilation.GetSemanticModel();
var syntaxTree = semanticModel.SyntaxTree;
var diagnostics = syntaxTree.GetDiagnostics().Concat(semanticModel.GetDiagnostics()).ToImmutableArray();
Assert.Equal(spans.Length, diagnostics.Length);
for (var i = 0; i < spans.Length; i++)
{
var span = spans[i];
var diagnostic = diagnostics[i];
Assert.Equal(span, diagnostic.Span);
Assert.Equal(DiagnosticId.DuplicateTableRefInFrom, diagnostic.DiagnosticId);
}
}
private void GetModels(string query, Func <DataContext, DataContext> dataContextModifer, out SemanticModel semanticModel, out QuickInfoModel startModel, out QuickInfoModel middleModel, out QuickInfoModel endModel)
{
TextSpan span;
var compilation = CompilationFactory.CreateQuery(query, out span);
if (dataContextModifer != null)
{
compilation = compilation.WithDataContext(dataContextModifer(compilation.DataContext));
}
semanticModel = compilation.GetSemanticModel();
var start = span.Start;
var middle = span.Start + span.Length / 2;
var end = span.End;
var provider = CreateProvider();
var providers = new[] { provider };
startModel = semanticModel.GetQuickInfoModel(start, providers);
middleModel = semanticModel.GetQuickInfoModel(middle, providers);
endModel = semanticModel.GetQuickInfoModel(end, providers);
}
public void SelectionExtensions_Grows()
{
var query = @"
SELECT e.First|Name
FROM Employees e
";
int position;
var compilation = CompilationFactory.CreateQuery(query, out position);
var syntaxTree = compilation.SyntaxTree;
var text = syntaxTree.Text;
var start = new TextSpan(position, 0);
var firstTime = syntaxTree.ExtendSelection(start);
Assert.Equal("FirstName", text.GetText(firstTime));
var secondTime = syntaxTree.ExtendSelection(firstTime);
Assert.Equal("e.FirstName", text.GetText(secondTime));
var thirdTime = syntaxTree.ExtendSelection(secondTime);
Assert.Equal("SELECT e.FirstName", text.GetText(thirdTime));
var fourthTime = syntaxTree.ExtendSelection(thirdTime);
Assert.Equal(text.GetText().Trim(), text.GetText(fourthTime));
var fifthTime = syntaxTree.ExtendSelection(fourthTime);
Assert.Equal(text.GetText().TrimStart(), text.GetText(fifthTime));
var sixthTime = syntaxTree.ExtendSelection(fifthTime);
Assert.Equal(fifthTime, sixthTime);
}
public void SemanticClassification_Classifies()
{
var query = @"
WITH Emps AS (
SELECT e.*
FROM Employees e
)
SELECT COUNT(*),
SUM(d.EmployeeId)
FROM (
SELECT *,
FirstName + ' ' + LastName AS FullName
FROM Emps
) d
WHERE d.ReportsTo = @Manager
AND LEN(LastName) = LastName.Length
AND LastName.Substring(0, ReportsTo) = '2'
";
var pieces = new[]
{
Tuple.Create("Emps", SemanticClassification.CommonTableExpression),
Tuple.Create("e", SemanticClassification.SchemaTable),
Tuple.Create("Employees", SemanticClassification.SchemaTable),
Tuple.Create("e", SemanticClassification.SchemaTable),
Tuple.Create("COUNT", SemanticClassification.Aggregate),
Tuple.Create("SUM", SemanticClassification.Aggregate),
Tuple.Create("d", SemanticClassification.DerivedTable),
Tuple.Create("EmployeeId", SemanticClassification.Column),
Tuple.Create("FirstName", SemanticClassification.Column),
Tuple.Create("LastName", SemanticClassification.Column),
Tuple.Create("FullName", SemanticClassification.Column),
Tuple.Create("Emps", SemanticClassification.CommonTableExpression),
Tuple.Create("d", SemanticClassification.DerivedTable),
Tuple.Create("d", SemanticClassification.DerivedTable),
Tuple.Create("ReportsTo", SemanticClassification.Column),
Tuple.Create("@Manager", SemanticClassification.Variable),
Tuple.Create("LEN", SemanticClassification.Function),
Tuple.Create("LastName", SemanticClassification.Column),
Tuple.Create("LastName", SemanticClassification.Column),
Tuple.Create("Length", SemanticClassification.Property),
Tuple.Create("LastName", SemanticClassification.Column),
Tuple.Create("Substring", SemanticClassification.Method),
Tuple.Create("ReportsTo", SemanticClassification.Column),
};
var compilation = CompilationFactory.CreateQuery(query);
var dataContext = compilation.DataContext.AddVariables(new VariableSymbol("Manager", typeof(int)));
compilation = compilation.WithDataContext(dataContext);
var syntaxTree = compilation.SyntaxTree;
var semanticModel = compilation.GetSemanticModel();
var classificationSpans = syntaxTree.Root.ClassifySemantics(semanticModel).ToImmutableArray();
Assert.Equal(pieces.Length, classificationSpans.Length);
for (var i = 0; i < pieces.Length; i++)
{
var piecce = pieces[i];
var pieceText = piecce.Item1;
var classification = piecce.Item2;
var classificationText = query.Substring(classificationSpans[i].Span);
Assert.Equal(pieceText, classificationText);
Assert.Equal(classification, classificationSpans[i].Classification);
}
}
