private async Task TestAsync(string initialText, string importsAddedText, string simplifiedText, bool safe, bool useSymbolAnnotations, Func <OptionSet, OptionSet> optionsTransform = null)
{
var doc = await GetDocument(initialText, useSymbolAnnotations);
OptionSet options = await doc.GetOptionsAsync();
if (optionsTransform != null)
{
options = optionsTransform(options);
}
var imported = useSymbolAnnotations
? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, safe, options)
: await ImportAdder.AddImportsFromSyntaxesAsync(doc, safe, options);
if (importsAddedText != null)
{
var formatted = await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation, options);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(importsAddedText, actualText);
}
if (simplifiedText != null)
{
var reduced = await Simplifier.ReduceAsync(imported, options);
var formatted = await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation, options);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(simplifiedText, actualText);
}
}
private static async Task TestAsync(
string initialText,
string importsAddedText,
string simplifiedText,
bool useSymbolAnnotations,
Func <OptionSet, OptionSet> optionsTransform = null,
bool performCheck = true
)
{
var doc = await GetDocument(initialText, useSymbolAnnotations);
OptionSet options = await doc.GetOptionsAsync();
if (optionsTransform != null)
{
options = optionsTransform(options);
}
var imported = useSymbolAnnotations
? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, options)
: await ImportAdder.AddImportsFromSyntaxesAsync(doc, options);
if (importsAddedText != null)
{
var formatted = await Formatter.FormatAsync(
imported,
SyntaxAnnotation.ElasticAnnotation,
options
);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(importsAddedText, actualText);
}
if (simplifiedText != null)
{
var reduced = await Simplifier.ReduceAsync(imported, options);
var formatted = await Formatter.FormatAsync(
reduced,
SyntaxAnnotation.ElasticAnnotation,
options
);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(simplifiedText, actualText);
}
if (performCheck)
{
if (initialText == importsAddedText && importsAddedText == simplifiedText)
{
throw new Exception($"use {nameof(TestNoImportsAddedAsync)}");
}
}
}
private static async Task TestAsync(
string initialText,
string importsAddedText,
string simplifiedText,
bool useSymbolAnnotations,
bool placeSystemNamespaceFirst = true,
bool placeImportsInsideNamespaces = false,
bool performCheck = true)
{
var doc = await GetDocument(initialText, useSymbolAnnotations);
var addImportOptions = new AddImportPlacementOptions()
{
PlaceSystemNamespaceFirst = placeSystemNamespaceFirst,
UsingDirectivePlacement = new CodeStyleOption2 <AddImportPlacement>(placeImportsInsideNamespaces ? AddImportPlacement.InsideNamespace : AddImportPlacement.OutsideNamespace, NotificationOption2.None),
};
var formattingOptions = CSharpSyntaxFormattingOptions.Default;
var simplifierOptions = CSharpSimplifierOptions.Default;
var imported = useSymbolAnnotations
? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, addImportOptions, CancellationToken.None)
: await ImportAdder.AddImportsFromSyntaxesAsync(doc, addImportOptions, CancellationToken.None);
if (importsAddedText != null)
{
var formatted = await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(importsAddedText, actualText);
}
if (simplifiedText != null)
{
var reduced = await Simplifier.ReduceAsync(imported, simplifierOptions, CancellationToken.None);
var formatted = await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(simplifiedText, actualText);
}
if (performCheck)
{
if (initialText == importsAddedText && importsAddedText == simplifiedText)
{
throw new Exception($"use {nameof(TestNoImportsAddedAsync)}");
}
}
}
private static async Task TestAsync(
string initialText,
string importsAddedText,
string simplifiedText,
bool useSymbolAnnotations,
bool placeSystemNamespaceFirst = true,
bool placeImportsInsideNamespaces = false,
bool performCheck = true)
{
var doc = await GetDocument(initialText, useSymbolAnnotations);
var addImportOptions = new AddImportPlacementOptions(
PlaceSystemNamespaceFirst: placeSystemNamespaceFirst,
PlaceImportsInsideNamespaces: placeImportsInsideNamespaces,
AllowInHiddenRegions: false);
var imported = useSymbolAnnotations
? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, addImportOptions, CancellationToken.None)
: await ImportAdder.AddImportsFromSyntaxesAsync(doc, addImportOptions, CancellationToken.None);
if (importsAddedText != null)
{
var formatted = await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(importsAddedText, actualText);
}
if (simplifiedText != null)
{
var reduced = await Simplifier.ReduceAsync(imported);
var formatted = await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(simplifiedText, actualText);
}
if (performCheck)
{
if (initialText == importsAddedText && importsAddedText == simplifiedText)
{
throw new Exception($"use {nameof(TestNoImportsAddedAsync)}");
}
}
}
public async Task TestDoNotAddDuplicateImportIfNamespaceIsDefinedInSourceAndExternalAssembly(bool useSymbolAnnotations)
{
var externalCode =
@"namespace N.M { public class A : System.Attribute { } }";
var code =
@"using System;
using N.M;
class C
{
public void M1(String p1) { }
public void M2([A] String p2) { }
}";
var otherAssemblyReference = GetInMemoryAssemblyReferenceForCode(externalCode);
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 project = emptyProject
.AddMetadataReferences(new[] { otherAssemblyReference })
.WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
project = project.AddDocument("duplicate.cs", externalCode).Project;
var document = project.AddDocument("test.cs", code);
var compilation = await document.Project.GetCompilationAsync(CancellationToken.None);
var compilerDiagnostics = compilation.GetDiagnostics(CancellationToken.None);
Assert.Empty(compilerDiagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
var attribute = compilation.GetTypeByMetadataName("N.M.A");
var syntaxRoot = await document.GetSyntaxRootAsync(CancellationToken.None).ConfigureAwait(false);
SyntaxNode p1SyntaxNode = syntaxRoot.DescendantNodes().OfType <ParameterSyntax>().FirstOrDefault();
// Add N.M.A attribute to p1.
var editor = await DocumentEditor.CreateAsync(document, CancellationToken.None).ConfigureAwait(false);
var attributeSyntax = editor.Generator.Attribute(editor.Generator.TypeExpression(attribute));
editor.AddAttribute(p1SyntaxNode, attributeSyntax);
var documentWithAttribute = editor.GetChangedDocument();
var addImportOptions = new AddImportPlacementOptions();
var formattingOptions = CSharpSyntaxFormattingOptions.Default;
// Add namespace import.
var imported = useSymbolAnnotations
? await ImportAdder.AddImportsFromSymbolAnnotationAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false)
: await ImportAdder.AddImportsFromSyntaxesAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false);
var formatted = await Formatter.FormatAsync(imported, formattingOptions, CancellationToken.None);
var actualText = (await formatted.GetTextAsync()).ToString();
Assert.Equal(@"using System;
using N.M;
class C
{
public void M1([global::N.M.A] String p1) { }
public void M2([A] String p2) { }
}", actualText);
}
public async Task TestWarnsWithMatchingExtensionMethodUsedAsDelegate(bool useSymbolAnnotations)
{
var source = @"using System;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(A.C1 c1) => 42.M;
}";
await TestAsync(
source,
@"using System;
using A;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(A.C1 c1) => 42.M;
}",
@"using System;
using A;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(C1 c1) => 42.M;
}", safe : true, useSymbolAnnotations);
var doc = await GetDocument(source, useSymbolAnnotations);
OptionSet options = await doc.GetOptionsAsync();
var imported = await ImportAdder.AddImportsFromSyntaxesAsync(doc, true, options);
var root = await imported.GetSyntaxRootAsync();
var nodeWithWarning = root.GetAnnotatedNodes(WarningAnnotation.Kind).Single();
Assert.Equal("42.M", nodeWithWarning.ToFullString());
var warning = nodeWithWarning.GetAnnotations(WarningAnnotation.Kind).Single();
var expectedWarningMessage = string.Format(WorkspacesResources.Warning_adding_imports_will_bring_an_extension_method_into_scope_with_the_same_name_as_member_access, "M");
Assert.Equal(expectedWarningMessage, WarningAnnotation.GetDescription(warning));
}
public async Task TestWarnsWithMatchingExtensionMethodUsedAsDelegate(bool useSymbolAnnotations)
{
var source = @"using System;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(A.C1 c1) => 42.M;
}";
await TestAsync(
source,
@"using System;
using A;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(A.C1 c1) => 42.M;
}",
@"using System;
using A;
using B;
namespace A
{
static class AExtensions
{
public static void M(this int a){}
}
public class C1 {}
}
namespace B
{
static class BExtensions
{
public static void M(this object a){}
}
}
class C
{
Action M(C1 c1) => 42.M;
}", safe : true, useSymbolAnnotations);
var doc = await GetDocument(source, useSymbolAnnotations);
OptionSet options = await doc.GetOptionsAsync();
var imported = await ImportAdder.AddImportsFromSyntaxesAsync(doc, true, options);
var root = await imported.GetSyntaxRootAsync();
var nodeWithWarning = root.GetAnnotatedNodes(WarningAnnotation.Kind).Single();
Assert.Equal("42.M", nodeWithWarning.ToFullString());
var warning = nodeWithWarning.GetAnnotations(WarningAnnotation.Kind).Single();
Assert.Equal("Adding imports will bring an extension method into scope with the same name as 'M'", WarningAnnotation.GetDescription(warning));
}
