public static void FieldAssignedInLambdaCtor()
{
var code = @"
namespace N
{
using System;
public class C
{
private Disposable disposable;
public C()
{
Console.CancelKeyPress += (o, e) =>
{
this.disposable = new Disposable();
};
}
}
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("disposable = new Disposable()").Left;
Assert.AreEqual(Result.Yes, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public static void LocalSeparateDeclarationAndAssignment()
{
var code = @"
namespace N
{
using System;
internal class C
{
internal C()
{
IDisposable disposable;
disposable = new Disposable();
}
}
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("disposable = new Disposable()").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public static void LocalBeforeEarlyReturn()
{
var code = @"
namespace N
{
using System.IO;
public class C
{
private static bool M(string fileName)
{
Stream stream;
if (File.Exists(fileName))
{
stream = File.OpenRead(fileName);
stream = default(Stream);
return true;
}
stream = null;
return false;
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("stream = default(Stream)").Left;
Assert.AreEqual(Result.Yes, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public void ParameterAfterEarlyReturn()
{
var testCode = @"
namespace RoslynSandbox
{
using System.IO;
public class Foo
{
private static bool TryGetStream(string fileName, out Stream stream)
{
if (File.Exists(fileName))
{
stream = File.OpenRead(fileName);
return true;
}
stream = null;
return false;
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("stream = null").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public void LocalAssignmentInLambda()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
public class Foo
{
public Foo()
{
IDisposable disposable;
Console.CancelKeyPress += (o, e) =>
{
disposable = new Disposable();
};
}
}
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("disposable = new Disposable()").Left;
Assert.AreEqual(Result.Yes, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public void FieldAssignedInCtor()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
internal class Foo
{
private Disposable disposable;
internal Foo()
{
this.disposable = new Disposable();
}
}
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("this.disposable = new Disposable()").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public static void OutParameterInExpressionBody()
{
var code = @"
namespace N
{
using System;
using System.IO;
public class C
{
public void M(out IDisposable disposable) => disposable = File.OpenRead(string.Empty);
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("disposable = File.OpenRead(string.Empty)").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public static void Repro()
{
var code = @"
namespace N
{
public class C
{
private C1 c1;
private C1 c2;
public C1 P1
{
get
{
return this.c1;
}
set
{
if (Equals(value, this.c1))
{
return;
}
if (value != null && this.c2 != null)
{
this.P2 = null;
}
if (this.c1 != null)
{
this.c1.Selected = false;
}
this.c1 = value;
if (this.c1 != null)
{
this.c1.Selected = true;
}
}
}
public C1 P2
{
get
{
return this.c2;
}
set
{
if (Equals(value, this.c2))
{
return;
}
if (value != null && this.c1 != null)
{
this.P1 = null;
}
if (this.c2 != null)
{
this.c2.Selected = false;
}
this.c2 = value;
if (this.c2 != null)
{
this.c2.Selected = true;
}
}
}
}
public class C1
{
public bool Selected { get; set; }
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("this.P1 = null;").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
public void Repro()
{
var testCode = @"
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 syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("this.Bar1 = null;").Left;
Assert.AreEqual(Result.No, Disposable.IsAlreadyAssignedWithCreated(value, semanticModel, CancellationToken.None, out _));
}
