Update to lostmsu's fork

filmor · filmor · commit c4ac18adeb65 · 2021-11-14T10:34:24.000+01:00
diff --git a/src/noncopyable_analyzer/NonCopyableAnalyzer.cs b/src/noncopyable_analyzer/NonCopyableAnalyzer.cs
@@ -57,13 +57,13 @@ public override void Initialize(AnalysisContext context)
                     CheckCopyability(oc, op.Value, ArgumentRule);
                 }, OperationKind.Argument);
 
-                // csc.RegisterOperationAction(oc =>
-                // {
-                //     var op = (IReturnOperation)oc.Operation;
-                //     if (op.ReturnedValue == null) return;
-                //     CheckCopyability(oc, op.ReturnedValue, ReturnRule);
-                // }, OperationKind.Return,
-                // OperationKind.YieldReturn);
+                csc.RegisterOperationAction(oc =>
+                {
+                    var op = (IReturnOperation)oc.Operation;
+                    if (op.ReturnedValue == null) return;
+                    CheckCopyability(oc, op.ReturnedValue, ReturnRule);
+                }, OperationKind.Return,
+                OperationKind.YieldReturn);
 
                 csc.RegisterOperationAction(oc =>
                 {
@@ -83,10 +83,10 @@ public override void Initialize(AnalysisContext context)
                         op == ((IForEachLoopOperation)op.Parent).Collection &&
                         op.Conversion.IsIdentity)
                     {
-                        return;
+                        return; 
                     }
 
-                    oc.ReportDiagnostic(Diagnostic.Create(ConversionRule, v.Syntax.GetLocation(), t.Name));
+                    oc.ReportDiagnostic(Error(v.Syntax, ConversionRule, t.Name));
                 }, OperationKind.Conversion);
 
                 csc.RegisterOperationAction(oc =>
@@ -101,24 +101,12 @@ public override void Initialize(AnalysisContext context)
                     }
                 }, OperationKind.ArrayInitializer);
 
-                csc.RegisterOperationAction(oc =>
-                {
-                    var op = (ICollectionElementInitializerOperation)oc.Operation;
-
-                    if (!HasNonCopyableParameter(op.AddMethod)) return;
-
-                    foreach (var a in op.Arguments)
-                    {
-                        CheckCopyability(oc, a, InitializerRule);
-                    }
-                }, OperationKind.CollectionElementInitializer);
-
                 csc.RegisterOperationAction(oc =>
                 {
                     var op = (IDeclarationPatternOperation)oc.Operation;
                     var t = ((ILocalSymbol)op.DeclaredSymbol).Type;
                     if (!t.IsNonCopyable()) return;
-                    oc.ReportDiagnostic(Diagnostic.Create(PatternRule, op.Syntax.GetLocation(), t.Name));
+                    oc.ReportDiagnostic(Error(op.Syntax, PatternRule, t.Name));
                 }, OperationKind.DeclarationPattern);
 
                 csc.RegisterOperationAction(oc =>
@@ -152,13 +140,24 @@ public override void Initialize(AnalysisContext context)
 
                 }, OperationKind.Invocation);
 
+                csc.RegisterOperationAction(oc => {
+                    var op = (IDynamicInvocationOperation)oc.Operation;
+
+                    foreach(var arg in op.Arguments) {
+                        if (!arg.Type.IsNonCopyable()) continue;
+
+                        oc.ReportDiagnostic(Error(arg.Syntax, GenericConstraintRule));
+                    }
+
+                }, OperationKind.DynamicInvocation);
+
                 csc.RegisterOperationAction(oc =>
                 {
                     // delagate creation
                     var op = (IMemberReferenceOperation)oc.Operation;
                     if (op.Instance == null) return;
                     if (!op.Instance.Type.IsNonCopyable()) return;
-                    oc.ReportDiagnostic(Diagnostic.Create(DelegateRule, op.Instance.Syntax.GetLocation(), op.Instance.Type.Name));
+                    oc.ReportDiagnostic(Error(op.Instance.Syntax, DelegateRule, op.Instance.Type.Name));
                 }, OperationKind.MethodReference);
 
                 csc.RegisterSymbolAction(sac =>
@@ -168,7 +167,7 @@ public override void Initialize(AnalysisContext context)
                     if (!f.Type.IsNonCopyable()) return;
                     if (f.ContainingType.IsReferenceType) return;
                     if (f.ContainingType.IsNonCopyable()) return;
-                    sac.ReportDiagnostic(Diagnostic.Create(FieldDeclarationRule, f.DeclaringSyntaxReferences[0].GetSyntax().GetLocation(), f.Type.Name));
+                    sac.ReportDiagnostic(Error(f.DeclaringSyntaxReferences[0].GetSyntax(), FieldDeclarationRule, f.Type.Name));
                 }, SymbolKind.Field);
             });
 
@@ -192,7 +191,7 @@ private static void CheckGenericConstraints(in OperationAnalysisContext oc, IInv
                     var a = arguments[i];
 
                     if (a.IsNonCopyable() && !p.IsNonCopyable())
-                        oc.ReportDiagnostic(Diagnostic.Create(rule, op.Syntax.GetLocation(), a.Name));
+                        oc.ReportDiagnostic(Error(op.Syntax, rule, a.Name));
                 }
             }
         }
@@ -206,10 +205,15 @@ private static void CheckInstanceReadonly(in OperationAnalysisContext oc, IOpera
 
             if (IsInstanceReadonly(instance))
             {
-                oc.ReportDiagnostic(Diagnostic.Create(rule, instance.Syntax.GetLocation(), t.Name));
+                oc.ReportDiagnostic(Error(instance.Syntax, rule, t.Name));
             }
         }
 
+        private static Diagnostic Error(SyntaxNode at, DiagnosticDescriptor rule, string name = null)
+            => name is null
+                ? Diagnostic.Create(rule, at.GetLocation())
+                : Diagnostic.Create(rule, at.GetLocation(), name);
+
         private static bool IsInstanceReadonly(IOperation instance)
         {
             bool isReadOnly = false;
@@ -246,7 +250,7 @@ private static void CheckCopyability(in OperationAnalysisContext oc, IOperation
             var t = v.Type;
             if (!t.IsNonCopyable()) return;
             if (v.CanCopy()) return;
-            oc.ReportDiagnostic(Diagnostic.Create(rule, v.Syntax.GetLocation(), t.Name));
+            oc.ReportDiagnostic(Error(v.Syntax, rule, t.Name));
         }
     }
 }
diff --git a/src/noncopyable_analyzer/TypeExtensions.cs b/src/noncopyable_analyzer/TypeExtensions.cs
@@ -78,13 +78,24 @@ public static bool CanCopy(this IOperation op)
                 if (parent == SyntaxKind.RefExpression) return true;
             }
 
+            if (k == OperationKind.Conditional)
+            {
+                var cond = (IConditionalOperation)op;
+                return cond.WhenFalse.CanCopy() && cond.WhenFalse.CanCopy();
+            }
+
             return k == OperationKind.ObjectCreation
                 || k == OperationKind.DefaultValue
                 || k == OperationKind.Literal
-                || k == OperationKind.Invocation;
+                || k == OperationKind.Invocation
+                // workaround for https://github.com/dotnet/roslyn/issues/49751
+                || !IsValid(k) && op.Syntax is InvocationExpressionSyntax;
 
             //todo: should return value be OK?
             //todo: move semantics
         }
+
+        static bool IsValid(OperationKind kind)
+            => kind != OperationKind.None && kind != OperationKind.Invalid;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -78,13 +78,24 @@ public static bool CanCopy(this IOperation op)`
`78`	`78`	`if (parent == SyntaxKind.RefExpression) return true;`
`79`	`79`	`}`
`80`	`80`
	`81`	`+ if (k == OperationKind.Conditional)`
	`82`	`+ {`
	`83`	`+ var cond = (IConditionalOperation)op;`
	`84`	`+ return cond.WhenFalse.CanCopy() && cond.WhenFalse.CanCopy();`
	`85`	`+ }`
	`86`	`+`
`81`	`87`	`return k == OperationKind.ObjectCreation`
`82`	`88`	`\|\| k == OperationKind.DefaultValue`
`83`	`89`	`\|\| k == OperationKind.Literal`
`84`		`- \|\| k == OperationKind.Invocation;`
	`90`	`+ \|\| k == OperationKind.Invocation`
	`91`	`+ // workaround for https://github.com/dotnet/roslyn/issues/49751`
	`92`	`+ \|\| !IsValid(k) && op.Syntax is InvocationExpressionSyntax;`
`85`	`93`
`86`	`94`	`//todo: should return value be OK?`
`87`	`95`	`//todo: move semantics`
`88`	`96`	`}`
	`97`	`+`
	`98`	`+ static bool IsValid(OperationKind kind)`
	`99`	`+ => kind != OperationKind.None && kind != OperationKind.Invalid;`
`89`	`100`	`}`
`90`	`101`	`}`