public void StaticOtherType(Scope scope, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public static class Bar { public static int Value => 1; } public class Foo { public Foo() { Equals(Bar.Value, 2); int j = 3; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindConstructorDeclaration("Foo"); using (var walker = LiteralWalker.Borrow(node, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual(expected, string.Join(", ", walker.Literals)); } }
public void BackingFieldPrivateSetSimple() { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public sealed class Foo { private int bar; public int Bar { get { return this.bar; } private set { this.bar = value; } } public void Meh() { var temp = this.bar; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause("var temp = this.bar").Value; using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", assignedValues); Assert.AreEqual(string.Empty, actual); } }
public void RecursiveGetAndSet(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public sealed class Foo { public Foo() { var temp1 = this.Bar; this.Bar = 2; var temp2 = this.Bar; } public int Bar { get { return this.Bar; } set { this.Bar = value; } } public void Meh() { var temp3 = this.Bar; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); } }
public void AsyncAwait(string code, Search search, string expected) { var testCode = @" namespace RoslynSandbox { using System; using System.Threading.Tasks; public class Disposable : IDisposable { public void Dispose() { } } internal class Foo { internal async Task Bar() { var value = // Meh(); } internal static async Task<int> RecursiveAsync() => RecursiveAsync(); internal static async Task<int> RecursiveAsync(int arg) => RecursiveAsync(arg); internal static async Task<string> CreateStringAsync() { await Task.Delay(0); return new string(' ', 1); } internal static async Task<string> ReturnAwaitTaskRunAsync() { await Task.Delay(0); return await Task.Run(() => new string(' ', 1)).ConfigureAwait(false); } internal static Task<int> CreateAsync(int arg) { switch (arg) { case 0: return Task.FromResult(1); case 1: return Task.FromResult(arg); case 2: return Task.Run(() => 2); case 3: return Task.Run(() => arg); case 4: return Task.Run(() => { return 3; }); default: return Task.Run(() => { return arg; }); } } internal static async int CreateInt() => 1; private static async Task<int> RecursiveAsync1(int value) { return await RecursiveAsync2(value); } private static async Task<int> RecursiveAsync2(int value) { return await RecursiveAsync1(value); } private static async Task<int> RecursiveAsync3(int value) { return RecursiveAsync4(value); } private static async Task<int> RecursiveAsync4(int value) { return await RecursiveAsync3(value); } } }"; testCode = testCode.AssertReplace("// Meh()", code); var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value; using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None)) { Assert.AreEqual(expected, string.Join(", ", pooled.Item)); } }
public static void Expression(string code, bool expected) { var testCode = @" namespace N { internal class Foo { internal Foo(object o) { var value = PLACEHOLDER; } } }".AssertReplace("PLACEHOLDER", code); var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; Assert.AreEqual(expected, Disposable.IsPotentiallyAssignableFrom(value, semanticModel, CancellationToken.None)); }
// [TestCase("Method()")] public static void TryGetWalked(string expression) { var code = @" namespace RoslynSandbox { class C { public readonly int field = typeof(int); public C() { var local = typeof(int); _ = local.ToString(); } public Type CalculatedProperty => typeof(int); public Type GetOnlyProperty { get; } = typeof(int); public static Type Method() => typeof(int); } }".AssertReplace("local.ToString()", $"{expression}.ToString()"); var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = ((MemberAccessExpressionSyntax)syntaxTree.FindInvocation("ToString()").Expression).Expression; var context = new SyntaxNodeAnalysisContext(null, null, semanticModel, null, null, null, CancellationToken.None); Assert.AreEqual(true, Type.TryGet(node, context, out var type, out var source)); Assert.AreEqual("int", type.ToDisplayString()); Assert.AreEqual("typeof(int)", source.ToString()); }
public void Call(string code, Search search, string expected) { var testCode = @" namespace RoslynSandbox { using System; using System.Collections.Generic; internal class Foo { internal Foo() { var temp = // Meh(); } internal static int StaticCreateIntStatementBody() { return 1; } internal static int StaticCreateIntExpressionBody() => 2; internal static int IdStatementBody(int arg) { return arg; } internal static int IdExpressionBody(int arg) => arg; internal static int OptionalIdExpressionBody(int arg = 1) => arg; internal static int CallingIdExpressionBody(int arg1) => IdExpressionBody(arg1); public static int AssigningToParameter(int arg) { if (true) { return arg; } else { if (true) { arg = 2; } else { arg = 3; } return arg; } return 4; } public static int ConditionalId(int arg) { if (true) { return arg; } return arg; } public static int ReturnLocal() { var local = 1; return local; } public static int ReturnLocalAssignedTwice(bool flag) { var local = 1; local = 2; if (flag) { return local; } local = 5; return 3; } public static int Recursive() => Recursive(); public static int Recursive(int arg) => Recursive(arg); public static bool Recursive(bool flag) { if (flag) { return Recursive(!flag); } return flag; } public Foo ThisExpressionBody() => this; private static int RecursiveWithOptional(int arg, IEnumerable<int> args = null) { if (arg == null) { return RecursiveWithOptional(arg, new[] { arg }); } return arg; } private static int Recursive1(int value) { return Recursive2(value); } private static int Recursive2(int value) { return Recursive1(value); } } }"; testCode = testCode.AssertReplace("// Meh()", code); var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value; using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", pooled.Item); Assert.AreEqual(expected, actual); } }
public static void FieldCtorArgThenIdMethod(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class C { private readonly int value; internal C(int arg) { var temp1 = this.value; this.value = Id(arg); var temp2 = this.value; } internal void M(int arg) { var temp3 = this.value; } private static T Id<T>(T genericArg) => genericArg; } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
public static void FieldInitializedlWithLiteralAndAssignedInCtor(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class C { private readonly int value = 1; private readonly int temp1; internal C() { this.temp1 = this.value; var temp1 = this.value; var temp2 = this.temp1; this.value = 2; var temp3 = this.value; var temp4 = this.temp1; } internal void M() { var temp5 = this.value; var temp6 = this.temp1; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
private async Task <ProjectStateChecksums> ComputeChecksumsAsync(CancellationToken cancellationToken) { using (Logger.LogBlock(FunctionId.ProjectState_ComputeChecksumsAsync, FilePath, cancellationToken)) { // get states by id order to have deterministic checksum var documentChecksumsTasks = DocumentIds.Select(id => DocumentStates[id].GetChecksumAsync(cancellationToken)); var additionalDocumentChecksumTasks = AdditionalDocumentIds.Select(id => AdditionalDocumentStates[id].GetChecksumAsync(cancellationToken)); var serializer = new Serializer(_solutionServices.Workspace.Services); var infoChecksum = serializer.CreateChecksum(new SerializedProjectInfo(Id, Version, Name, AssemblyName, Language, FilePath, OutputFilePath, IsSubmission), cancellationToken); var compilationOptionsChecksum = SupportsCompilation ? serializer.CreateChecksum(CompilationOptions, cancellationToken) : Checksum.Null; var parseOptionsChecksum = SupportsCompilation ? serializer.CreateChecksum(ParseOptions, cancellationToken) : Checksum.Null; var projectReferenceChecksums = new ProjectReferenceChecksumCollection(ProjectReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()); var metadataReferenceChecksums = new MetadataReferenceChecksumCollection(MetadataReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()); var analyzerReferenceChecksums = new AnalyzerReferenceChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()); var documentChecksums = await Task.WhenAll(documentChecksumsTasks).ConfigureAwait(false); var additionalChecksums = await Task.WhenAll(additionalDocumentChecksumTasks).ConfigureAwait(false); return(new ProjectStateChecksums( infoChecksum, compilationOptionsChecksum, parseOptionsChecksum, new DocumentChecksumCollection(documentChecksums), projectReferenceChecksums, metadataReferenceChecksums, analyzerReferenceChecksums, new TextDocumentChecksumCollection(additionalChecksums))); } }
public static void FieldPublicCtorFactory(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class C { public int value = 1; public C(int ctorArg) { var temp1 = this.value; this.value = ctorArg; var temp2 = this.value; } internal static C Create() { return new C(2); } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
public void TryFindWhenProperty(Scope scope) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public class C { public int P { get; } public void M() { var p = this.P.ToString(); } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindMethodDeclaration("M"); using (var walker = IdentifierNameExecutionWalker.Borrow(node, scope, semanticModel, CancellationToken.None)) { CollectionAssert.AreEqual(new[] { "var", "P", "ToString" }, walker.IdentifierNames.Select(x => x.Identifier.ValueText)); Assert.AreEqual(true, walker.TryFind("P", out var match)); Assert.AreEqual("P", match.Identifier.ValueText); Assert.AreEqual(false, walker.TryFind("missing", out _)); } }
public void DependencyPropertyRegisterReadOnly(Scope scope, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { using System.Windows; using System.Windows.Controls; public class FooControl : Control { private static readonly DependencyPropertyKey ValuePropertyKey = DependencyProperty.RegisterReadOnly( nameof(Value), typeof(int), typeof(FooControl), new PropertyMetadata(default(int))); public static readonly DependencyProperty ValueProperty = ValuePropertyKey.DependencyProperty; public int Value { get => (int) this.GetValue(ValueProperty); private set => this.SetValue(ValuePropertyKey, value); } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindExpression("ValuePropertyKey.DependencyProperty"); using (var walker = IdentifierNameExecutionWalker.Borrow(node, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual(expected, string.Join(", ", walker.IdentifierNames)); } }
public void StaticInitializers(Scope scope, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public sealed class Foo { public static readonly Foo Default = new Foo(); private static readonly string text = ""abc""; public string Text { get; set; } = text; } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindExpression("new Foo()"); using (var walker = IdentifierNameExecutionWalker.Borrow(node, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual(expected, string.Join(", ", walker.IdentifierNames)); } }
public static void TryGetAssemblyLoad(string expression) { var code = @" namespace RoslynSandbox { using System; using System.Collections.Generic; using System.Reflection; class C { public readonly int Field; public C(C foo) { var type = Assembly.Load(""mscorlib"").GetType(""System.Int32""); } public int Property { get; } public class Baz<T> { } public class Nested { } } }".AssertReplace("Assembly.Load(\"mscorlib\").GetType(\"System.Int32\")", expression); var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindExpression(expression); var context = new SyntaxNodeAnalysisContext(null, null, semanticModel, null, null, null, CancellationToken.None); Assert.AreEqual(false, Type.TryGet(node, context, out _, out _)); }
public static void InitializedInChainedWithLiteralGeneric(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class C<T> { internal C() { this.Value = 2; } internal C(string text) : this() { this.Value = 3; var temp1 = this.Value; this.Value = 4; } public int Value { get; set; } = 1; internal void M() { var temp2 = this.Value; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
public static void TryGet(string expression, string expected, string expectedSource) { var code = @" namespace RoslynSandbox { using System; using System.Collections.Generic; using System.Reflection; class C { public readonly int Field; public C(C foo, int? nullableInt) { var type = typeof(C); } public int Property { get; } public class Baz<T> { } public class Nested { } } }".AssertReplace("typeof(C)", expression); var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindExpression(expression); var context = new SyntaxNodeAnalysisContext(null, null, semanticModel, null, null, null, CancellationToken.None); Assert.AreEqual(true, Type.TryGet(node, context, out var type, out var source)); Assert.AreEqual(expected, type.ToDisplayString()); Assert.AreEqual(expectedSource, source.ToString()); }
public static void InitializedInExplicitBaseCtorWithLiteral(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class Base { protected int value = 1; public Base() { this.value = -1; } public Base(int value) { this.value = value; } } internal class C : Base { internal C() : base(2) { this.value = 3; var temp1 = this.value; this.value = 4; } internal void M() { var temp2 = this.value; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
public void AwaitSyntaxError(Search search, string expected) { var testCode = @" using System.Threading.Tasks; internal class Foo { internal static async Task Bar() { var text = await CreateAsync().ConfigureAwait(false); } internal static async Task<string> CreateAsync() { await Task.Delay(0); return await Task.SyntaxError(() => new string(' ', 1)).ConfigureAwait(false); } }"; var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>("var text = await CreateAsync()").Value; using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", pooled.Item); Assert.AreEqual(expected, actual); } }
public static void AbstractGenericInitializedInBaseCtorSimple() { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { public abstract class Base<T> { protected Base() { this.Value = default(T); } public abstract T Value { get; set; } } public class C : Base<int> { public C() { var temp = this.Value; } public override int Value { get; set; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause("var temp = this.Value;").Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual("default(T)", actual); }
public void Lambda(string code, Search search, string expected) { var testCode = @" namespace RoslynSandbox { using System; internal class Foo { internal Foo() { Func<int> temp = () => 1; } internal static int StaticCreateIntStatementBody() { return 1; } } }"; testCode = testCode.AssertReplace("Func<int> temp = () => 1", code); var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value; using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", pooled.Item); Assert.AreEqual(expected, actual); } }
public static void FieldChainedCtor(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class C { public int value = 1; internal C() { var temp1 = this.value; this.value = 2; var temp2 = this.value; } internal C(string text) : this() { var temp3 = this.value; this.value = 3; var temp4 = this.value; this.value = 4; var temp5 = this.value; } internal void M(int arg) { var temp6 = this.value; this.value = 5; var temp7 = this.value; this.value = arg; var temp8 = this.value; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
public void Property(string code, Search search, string expected) { var testCode = @" namespace RoslynSandbox { internal class Foo { private readonly int value = 1; internal Foo() { var temp = // Meh(); } public static int StaticRecursiveExpressionBody => StaticRecursiveExpressionBody; public static int StaticRecursiveStatementBody { get { return StaticRecursiveStatementBody; } } public int RecursiveExpressionBody => this.RecursiveExpressionBody; public int RecursiveStatementBody { get { return this.RecursiveStatementBody; } } public int CalculatedExpressionBody => 1; public int CalculatedStatementBody { get { return 1; } } public Foo ThisExpressionBody => this; public int CalculatedReturningFieldExpressionBody => this.value; public int CalculatedReturningFieldStatementBody { get { return this.value; } } } }"; testCode = testCode.AssertReplace("// Meh()", code); var syntaxTree = CSharpSyntaxTree.ParseText(testCode); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value; using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", pooled.Item); Assert.AreEqual(expected, actual); } }
public static void InitializedInBaseCtorWithDefaultGenericGeneric(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { internal class Base<T> { protected readonly T value; internal Base() { this.value = default(T); } internal Base(T value) { this.value = value; } } internal class C<T> : Base<T> { internal C() { var temp1 = this.value; } internal void M() { var temp2 = this.value; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); }
/// <summary> /// Creates a new <see cref="ScriptOptions"/> with the references changed. /// </summary> /// <exception cref="ArgumentNullException"><paramref name="references"/> is null or contains a null reference.</exception> private ScriptOptions WithReferences(ImmutableArray <MetadataReference> references) => MetadataReferences.Equals(references) ? this : new ScriptOptions(this) { MetadataReferences = CheckImmutableArray(references, nameof(references)) };
public static void FieldAssignedInLambdaCtor() { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace N { using System; public class C { private int value; public C() { Console.CancelKeyPress += (o, e) => { this.value = 1; }; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindAssignmentExpression("this.value = 1").Left; using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None); Assert.AreEqual("1", assignedValues.Single().ToString()); }
public void BackingFieldPublicSetInitializedAndPropertyAssignedInCtorWeirdSetter(string code, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public sealed class Foo { private int bar = 1; public Foo() { var temp1 = this.bar; var temp2 = this.Bar; this.Bar = 2; var temp3 = this.bar; var temp4 = this.Bar; } public int Bar { get { return this.bar; } set { if (true) { this.bar = value; } else { this.bar = value; } this.bar = value / 2; this.bar = 3; } } public void Meh() { var temp5 = this.bar; var temp6 = this.Bar; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var value = syntaxTree.FindEqualsValueClause(code).Value; using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", assignedValues); Assert.AreEqual(expected, actual); } }
public void TryMostSpecificWhenAmbiguous(string filterTypes, string signature1, string signature2) { var code = @" namespace RoslynSandbox { using System; public class C { public object Get() => typeof(C).GetMethod(nameof(this.M), new[] { typeof(FilterType) }); public void M(Type1 _) { } public void M(Type2 _) { } } }".AssertReplace("new[] { typeof(FilterType) }", filterTypes) .AssertReplace("M(Type1 _)", signature1) .AssertReplace("M(Type2 _)", signature2); var syntaxTree = CSharpSyntaxTree.ParseText(code); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var m1 = semanticModel.GetDeclaredSymbol(syntaxTree.FindMethodDeclaration(signature1), CancellationToken.None); var m2 = semanticModel.GetDeclaredSymbol(syntaxTree.FindMethodDeclaration(signature2), CancellationToken.None); var invocation = syntaxTree.FindInvocation("GetMethod"); var context = new SyntaxNodeAnalysisContext(null, semanticModel, null, null, null, CancellationToken.None); Assert.AreEqual(true, Types.TryCreate(invocation, (IMethodSymbol)semanticModel.GetSymbolInfo(invocation).Symbol, context, out var types)); Assert.AreEqual(false, types.TryMostSpecific(m1, m2, out _)); }
public void Recursive() { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public class Foo { private Bar bar1; private Bar bar2; public Bar Bar1 { get { return this.bar1; } set { if (Equals(value, this.bar1)) { return; } if (value != null && this.bar2 != null) { this.Bar2 = null; } if (this.bar1 != null) { this.bar1.Selected = false; } this.bar1 = value; if (this.bar1 != null) { this.bar1.Selected = true; } } } public Bar Bar2 { get { return this.bar2; } set { if (Equals(value, this.bar2)) { return; } if (value != null && this.bar1 != null) { this.Bar1 = null; } if (this.bar2 != null) { this.bar2.Selected = false; } this.bar2 = value; if (this.bar2 != null) { this.bar2.Selected = true; } } } } public class Bar { public bool Selected { get; set; } } }"); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var fieldDeclaration = syntaxTree.FindFieldDeclaration("bar1"); var field = semanticModel.GetDeclaredSymbolSafe(fieldDeclaration, CancellationToken.None); using (var assignedValues = AssignedValueWalker.Borrow(field, semanticModel, CancellationToken.None)) { var actual = string.Join(", ", assignedValues); Assert.AreEqual("null, value", actual); } }
public void Binary(string expression, Scope scope, string expected) { var syntaxTree = CSharpSyntaxTree.ParseText(@" namespace RoslynSandbox { public class Foo { public object Value1 => 1; public object Value2 => 2; public object Bar() => Value1 ?? Value2; } }".AssertReplace("Value1 ?? Value2", expression)); var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes()); var semanticModel = compilation.GetSemanticModel(syntaxTree); var node = syntaxTree.FindMethodDeclaration("Bar"); using (var walker = LiteralWalker.Borrow(node, scope, semanticModel, CancellationToken.None)) { Assert.AreEqual(expected, string.Join(", ", walker.Literals)); } }