private static async Task <Document> GetDocument(string code, bool withAnnotations)
{
var ws = new AdhocWorkspace();
var emptyProject = ws.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Default,
"test",
"test.dll",
LanguageNames.CSharp,
metadataReferences: new[] { TestMetadata.Net451.mscorlib }));
var doc = emptyProject.AddDocument("test.cs", code);
if (withAnnotations)
{
var root = await doc.GetSyntaxRootAsync();
var model = await doc.GetSemanticModelAsync();
root = root.ReplaceNodes(root.DescendantNodesAndSelf().OfType <TypeSyntax>(),
(o, c) =>
{
var symbol = model.GetSymbolInfo(o).Symbol;
return(symbol != null
? c.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol), Simplifier.Annotation)
: c);
});
doc = doc.WithSyntaxRoot(root);
}
return(doc);
}
private void TestSymbolSerialization(Document document, string symbolName)
{
var model = document.GetSemanticModelAsync().Result;
var name = CS.SyntaxFactory.ParseName(symbolName);
var symbol = model.GetSpeculativeSymbolInfo(0, name, SpeculativeBindingOption.BindAsExpression).Symbol;
var root = (CS.Syntax.CompilationUnitSyntax)model.SyntaxTree.GetRoot();
var annotation = SymbolAnnotation.Create(symbol);
var rootWithAnnotation = root.WithAdditionalAnnotations(annotation);
Assert.Equal(true, rootWithAnnotation.ContainsAnnotations);
Assert.Equal(true, rootWithAnnotation.HasAnnotation(annotation));
var stream = new MemoryStream();
rootWithAnnotation.SerializeTo(stream);
stream.Position = 0;
var droot = CS.CSharpSyntaxNode.DeserializeFrom(stream);
Assert.Equal(true, droot.ContainsAnnotations);
Assert.Equal(true, droot.HasAnnotation(annotation));
var dannotation = droot.GetAnnotations(SymbolAnnotation.Kind).SingleOrDefault();
Assert.NotNull(dannotation);
Assert.NotSame(annotation, dannotation);
Assert.Equal(annotation, dannotation);
var id = SymbolAnnotation.GetSymbol(annotation, model.Compilation);
var did = SymbolAnnotation.GetSymbol(dannotation, model.Compilation);
Assert.Equal(true, id.Equals(did));
}
public void AddCast(
ISyntaxFacts syntaxFacts,
SemanticModel semanticModel,
SyntaxEditor editor,
TForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken)
{
var expression = syntaxFacts.GetExpressionOfForeachStatement(forEachStatement);
var loopOperation = (IForEachLoopOperation)semanticModel.GetRequiredOperation(forEachStatement, cancellationToken);
var variableDeclarator = (IVariableDeclaratorOperation)loopOperation.LoopControlVariable;
var enumerableType = semanticModel.Compilation.GetBestTypeByMetadataName(typeof(Enumerable).FullName !);
// These were already verified to be non-null in the analyzer.
Contract.ThrowIfNull(variableDeclarator.Symbol.Type);
Contract.ThrowIfNull(enumerableType);
var elementType = GetForEachElementType(semanticModel, forEachStatement);
var conversion = semanticModel.Compilation.ClassifyCommonConversion(elementType, variableDeclarator.Symbol.Type);
var rewritten = GetRewrittenCollection(editor.Generator, expression, variableDeclarator.Symbol.Type, conversion);
// Add an annotation for System.Linq.Enumerable so that we add a `using System.Linq;` if not present.
rewritten = rewritten.WithAdditionalAnnotations(
Simplifier.Annotation, Simplifier.AddImportsAnnotation, SymbolAnnotation.Create(enumerableType));
editor.ReplaceNode(expression, rewritten);
}
private TTypeSyntax AddInformationTo <TTypeSyntax>(TTypeSyntax syntax, ISymbol symbol)
where TTypeSyntax : TypeSyntax
{
syntax = syntax.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker).WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker);
syntax = syntax.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol));
return(syntax);
}