Don't use obsolete API.

JohanLarsson · JohanLarsson · commit b0b3c8e3ce72 · 2019-12-05T09:18:04.000+01:00
diff --git a/IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs b/IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs
@@ -153,7 +153,7 @@ private static bool IsLazyEnumerable(InvocationExpressionSyntax invocation, INam
 
         private static bool IsLazyEnumerable(InvocationExpressionSyntax invocation, Recursion recursion)
         {
-            if (recursion.Target(invocation) is { Symbol: IMethodSymbol method, TargetNode: { } declaration } &&
+            if (recursion.Target(invocation) is { Symbol: IMethodSymbol method, Declaration: { } declaration } &&
                 method.ReturnType.IsAssignableTo(KnownSymbol.IEnumerable, recursion.SemanticModel.Compilation))
             {
                 if (YieldStatementWalker.Any(declaration))
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Assigns.cs b/IDisposableAnalyzers/Helpers/Disposable.Assigns.cs
@@ -36,9 +36,9 @@ private static bool Assigns<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TN
               where TSymbol : class, ISymbol
               where TNode : SyntaxNode
         {
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     if (Assigns(usage, recursion, out fieldOrProperty))
diff --git a/IDisposableAnalyzers/Helpers/Disposable.DisposedByReturnValue.cs b/IDisposableAnalyzers/Helpers/Disposable.DisposedByReturnValue.cs
@@ -148,15 +148,15 @@ private static bool DisposedByReturnValue<TSource, TSymbol, TNode>(Target<TSourc
                     return Disposable.IsAssignableFrom(returnType, recursion.SemanticModel.Compilation);
                 case IMethodSymbol { IsExtensionMethod: true, ReducedFrom: { } reducedFrom }
                      when reducedFrom.Parameters.TryFirst(out var parameter):
-                    return DisposedByReturnValue(Target.Create(target.Source, parameter, target.TargetNode), recursion);
+                    return DisposedByReturnValue(Target.Create(target.Source, parameter, target.Declaration), recursion);
                 case IFieldSymbol _:
                 case IPropertySymbol _:
                     return false;
             }
 
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     if (Assigns(usage, recursion, out var fieldOrProperty) &&
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Disposes.cs b/IDisposableAnalyzers/Helpers/Disposable.Disposes.cs
@@ -120,9 +120,9 @@ private static bool Disposes<TSource, TSymbol, TNode>(Target<TSource, TSymbol, T
             where TSymbol : class, ISymbol
             where TNode : SyntaxNode
         {
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     if (Disposes(usage, recursion))
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Identity.cs b/IDisposableAnalyzers/Helpers/Disposable.Identity.cs
@@ -69,15 +69,15 @@ private static bool IsIdentity<TSource, TSymbol, TNode>(Target<TSource, TSymbol,
             {
                 case IMethodSymbol { IsExtensionMethod: true, ReducedFrom: { } reducedFrom }
                      when reducedFrom.Parameters.TryFirst(out var parameter):
-                    return IsIdentity(Target.Create(target.Source, parameter, target.TargetNode), recursion);
+                    return IsIdentity(Target.Create(target.Source, parameter, target.Declaration), recursion);
                 case IFieldSymbol _:
                 case IPropertySymbol _:
                     return false;
             }
 
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     switch (usage.Parent.Kind())
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Ignores.cs b/IDisposableAnalyzers/Helpers/Disposable.Ignores.cs
@@ -75,7 +75,7 @@ private static bool Ignores(Target<ArgumentSyntax, IParameterSymbol, BaseMethodD
         {
             if (target.Source is { Parent: ArgumentListSyntax { Parent: ExpressionSyntax parentExpression } })
             {
-                if (target.TargetNode is null)
+                if (target.Declaration is null)
                 {
                     if (!Ignores(parentExpression, recursion))
                     {
@@ -86,7 +86,7 @@ private static bool Ignores(Target<ArgumentSyntax, IParameterSymbol, BaseMethodD
                     return true;
                 }
 
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 if (walker.Usages.Count == 0)
                 {
                     return true;
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Returns.cs b/IDisposableAnalyzers/Helpers/Disposable.Returns.cs
@@ -28,9 +28,9 @@ private static bool Returns<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TN
             where TSymbol : ISymbol
             where TNode : SyntaxNode
         {
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     if (Returns(usage, recursion))
diff --git a/IDisposableAnalyzers/Helpers/Disposable.Stores.cs b/IDisposableAnalyzers/Helpers/Disposable.Stores.cs
@@ -31,9 +31,9 @@ private static bool Stores<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TNo
             where TSymbol : ISymbol
             where TNode : SyntaxNode
         {
-            if (target.TargetNode is { })
+            if (target.Declaration is { })
             {
-                using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                 foreach (var usage in walker.Usages)
                 {
                     if (Stores(usage, recursion, out container))
@@ -78,7 +78,7 @@ when recursion.Target(argument) is { } target:
                     return StoresOrAssigns(tupleExpression, out container);
                 case { Parent: ArgumentSyntax { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } argument }
                     when recursion.Target(argument) is { Symbol: { } parameter } target:
-                    if (target.TargetNode is null &&
+                    if (target.Declaration is null &&
                         parameter.ContainingType.AllInterfaces.TryFirst(x => x == KnownSymbol.IEnumerable, out _) &&
                         invocation.Expression is MemberAccessExpressionSyntax memberAccess)
                     {
@@ -154,9 +154,9 @@ private static bool AccessibleInReturnValue(Target<ArgumentSyntax, IParameterSym
                         return false;
                     }
 
-                    if (target.TargetNode is { })
+                    if (target.Declaration is { })
                     {
-                        using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                        using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                         foreach (var usage in walker.Usages)
                         {
                             if (usage.Parent is ArgumentSyntax containingArgument &&
@@ -178,9 +178,9 @@ private static bool AccessibleInReturnValue(Target<ArgumentSyntax, IParameterSym
                         return true;
                     }
 
-                    if (target.TargetNode is { })
+                    if (target.Declaration is { })
                     {
-                        using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);
+                        using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);
                         foreach (var usage in walker.Usages)
                         {
                             if (Stores(usage, recursion, out var container) &&
diff --git a/IDisposableAnalyzers/Helpers/Walkers/FinalizerContextWalker.cs b/IDisposableAnalyzers/Helpers/Walkers/FinalizerContextWalker.cs
@@ -156,7 +156,7 @@ public override void VisitIdentifierName(IdentifierNameSyntax node)
 
             internal static TargetWalker Borrow(Target<SyntaxNode, ISymbol, SyntaxNode> target, Recursion recursion)
             {
-                return BorrowAndVisit(target.TargetNode!, SearchScope.Recursive, recursion, () => new TargetWalker());
+                return BorrowAndVisit(target.Declaration!, SearchScope.Recursive, recursion, () => new TargetWalker());
             }
 
             protected override void Clear()

Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ private static bool IsLazyEnumerable(InvocationExpressionSyntax invocation, INam`
`153`	`153`
`154`	`154`	`private static bool IsLazyEnumerable(InvocationExpressionSyntax invocation, Recursion recursion)`
`155`	`155`	`{`
`156`		`- if (recursion.Target(invocation) is { Symbol: IMethodSymbol method, TargetNode: { } declaration } &&`
	`156`	`+ if (recursion.Target(invocation) is { Symbol: IMethodSymbol method, Declaration: { } declaration } &&`
`157`	`157`	`method.ReturnType.IsAssignableTo(KnownSymbol.IEnumerable, recursion.SemanticModel.Compilation))`
`158`	`158`	`{`
`159`	`159`	`if (YieldStatementWalker.Any(declaration))`
Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,9 @@ private static bool Assigns<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TN`
`36`	`36`	`where TSymbol : class, ISymbol`
`37`	`37`	`where TNode : SyntaxNode`
`38`	`38`	`{`
`39`		`- if (target.TargetNode is { })`
	`39`	`+ if (target.Declaration is { })`
`40`	`40`	`{`
`41`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`41`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`42`	`42`	`foreach (var usage in walker.Usages)`
`43`	`43`	`{`
`44`	`44`	`if (Assigns(usage, recursion, out fieldOrProperty))`
Original file line number	Diff line number	Diff line change
`@@ -148,15 +148,15 @@ private static bool DisposedByReturnValue<TSource, TSymbol, TNode>(Target<TSourc`
`148`	`148`	`return Disposable.IsAssignableFrom(returnType, recursion.SemanticModel.Compilation);`
`149`	`149`	`case IMethodSymbol { IsExtensionMethod: true, ReducedFrom: { } reducedFrom }`
`150`	`150`	`when reducedFrom.Parameters.TryFirst(out var parameter):`
`151`		`- return DisposedByReturnValue(Target.Create(target.Source, parameter, target.TargetNode), recursion);`
	`151`	`+ return DisposedByReturnValue(Target.Create(target.Source, parameter, target.Declaration), recursion);`
`152`	`152`	`case IFieldSymbol _:`
`153`	`153`	`case IPropertySymbol _:`
`154`	`154`	`return false;`
`155`	`155`	`}`
`156`	`156`
`157`		`- if (target.TargetNode is { })`
	`157`	`+ if (target.Declaration is { })`
`158`	`158`	`{`
`159`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`159`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`160`	`160`	`foreach (var usage in walker.Usages)`
`161`	`161`	`{`
`162`	`162`	`if (Assigns(usage, recursion, out var fieldOrProperty) &&`
Original file line number	Diff line number	Diff line change
`@@ -120,9 +120,9 @@ private static bool Disposes<TSource, TSymbol, TNode>(Target<TSource, TSymbol, T`
`120`	`120`	`where TSymbol : class, ISymbol`
`121`	`121`	`where TNode : SyntaxNode`
`122`	`122`	`{`
`123`		`- if (target.TargetNode is { })`
	`123`	`+ if (target.Declaration is { })`
`124`	`124`	`{`
`125`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`125`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`126`	`126`	`foreach (var usage in walker.Usages)`
`127`	`127`	`{`
`128`	`128`	`if (Disposes(usage, recursion))`
Original file line number	Diff line number	Diff line change
`@@ -69,15 +69,15 @@ private static bool IsIdentity<TSource, TSymbol, TNode>(Target<TSource, TSymbol,`
`69`	`69`	`{`
`70`	`70`	`case IMethodSymbol { IsExtensionMethod: true, ReducedFrom: { } reducedFrom }`
`71`	`71`	`when reducedFrom.Parameters.TryFirst(out var parameter):`
`72`		`- return IsIdentity(Target.Create(target.Source, parameter, target.TargetNode), recursion);`
	`72`	`+ return IsIdentity(Target.Create(target.Source, parameter, target.Declaration), recursion);`
`73`	`73`	`case IFieldSymbol _:`
`74`	`74`	`case IPropertySymbol _:`
`75`	`75`	`return false;`
`76`	`76`	`}`
`77`	`77`
`78`		`- if (target.TargetNode is { })`
	`78`	`+ if (target.Declaration is { })`
`79`	`79`	`{`
`80`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`80`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`81`	`81`	`foreach (var usage in walker.Usages)`
`82`	`82`	`{`
`83`	`83`	`switch (usage.Parent.Kind())`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ private static bool Ignores(Target<ArgumentSyntax, IParameterSymbol, BaseMethodD`
`75`	`75`	`{`
`76`	`76`	`if (target.Source is { Parent: ArgumentListSyntax { Parent: ExpressionSyntax parentExpression } })`
`77`	`77`	`{`
`78`		`- if (target.TargetNode is null)`
	`78`	`+ if (target.Declaration is null)`
`79`	`79`	`{`
`80`	`80`	`if (!Ignores(parentExpression, recursion))`
`81`	`81`	`{`
`@@ -86,7 +86,7 @@ private static bool Ignores(Target<ArgumentSyntax, IParameterSymbol, BaseMethodD`
`86`	`86`	`return true;`
`87`	`87`	`}`
`88`	`88`
`89`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`89`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`90`	`90`	`if (walker.Usages.Count == 0)`
`91`	`91`	`{`
`92`	`92`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ private static bool Returns<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TN`
`28`	`28`	`where TSymbol : ISymbol`
`29`	`29`	`where TNode : SyntaxNode`
`30`	`30`	`{`
`31`		`- if (target.TargetNode is { })`
	`31`	`+ if (target.Declaration is { })`
`32`	`32`	`{`
`33`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`33`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`34`	`34`	`foreach (var usage in walker.Usages)`
`35`	`35`	`{`
`36`	`36`	`if (Returns(usage, recursion))`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,9 @@ private static bool Stores<TSource, TSymbol, TNode>(Target<TSource, TSymbol, TNo`
`31`	`31`	`where TSymbol : ISymbol`
`32`	`32`	`where TNode : SyntaxNode`
`33`	`33`	`{`
`34`		`- if (target.TargetNode is { })`
	`34`	`+ if (target.Declaration is { })`
`35`	`35`	`{`
`36`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`36`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`37`	`37`	`foreach (var usage in walker.Usages)`
`38`	`38`	`{`
`39`	`39`	`if (Stores(usage, recursion, out container))`
`@@ -78,7 +78,7 @@ when recursion.Target(argument) is { } target:`
`78`	`78`	`return StoresOrAssigns(tupleExpression, out container);`
`79`	`79`	`case { Parent: ArgumentSyntax { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } argument }`
`80`	`80`	`when recursion.Target(argument) is { Symbol: { } parameter } target:`
`81`		`- if (target.TargetNode is null &&`
	`81`	`+ if (target.Declaration is null &&`
`82`	`82`	`parameter.ContainingType.AllInterfaces.TryFirst(x => x == KnownSymbol.IEnumerable, out _) &&`
`83`	`83`	`invocation.Expression is MemberAccessExpressionSyntax memberAccess)`
`84`	`84`	`{`
`@@ -154,9 +154,9 @@ private static bool AccessibleInReturnValue(Target<ArgumentSyntax, IParameterSym`
`154`	`154`	`return false;`
`155`	`155`	`}`
`156`	`156`
`157`		`- if (target.TargetNode is { })`
	`157`	`+ if (target.Declaration is { })`
`158`	`158`	`{`
`159`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`159`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`160`	`160`	`foreach (var usage in walker.Usages)`
`161`	`161`	`{`
`162`	`162`	`if (usage.Parent is ArgumentSyntax containingArgument &&`
`@@ -178,9 +178,9 @@ private static bool AccessibleInReturnValue(Target<ArgumentSyntax, IParameterSym`
`178`	`178`	`return true;`
`179`	`179`	`}`
`180`	`180`
`181`		`- if (target.TargetNode is { })`
	`181`	`+ if (target.Declaration is { })`
`182`	`182`	`{`
`183`		`- using var walker = UsagesWalker.Borrow(target.Symbol, target.TargetNode, recursion.SemanticModel, recursion.CancellationToken);`
	`183`	`+ using var walker = UsagesWalker.Borrow(target.Symbol, target.Declaration, recursion.SemanticModel, recursion.CancellationToken);`
`184`	`184`	`foreach (var usage in walker.Usages)`
`185`	`185`	`{`
`186`	`186`	`if (Stores(usage, recursion, out var container) &&`
Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ public override void VisitIdentifierName(IdentifierNameSyntax node)`
`156`	`156`
`157`	`157`	`internal static TargetWalker Borrow(Target<SyntaxNode, ISymbol, SyntaxNode> target, Recursion recursion)`
`158`	`158`	`{`
`159`		`- return BorrowAndVisit(target.TargetNode!, SearchScope.Recursive, recursion, () => new TargetWalker());`
	`159`	`+ return BorrowAndVisit(target.Declaration!, SearchScope.Recursive, recursion, () => new TargetWalker());`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`protected override void Clear()`