ZXANbKMGly2iQQCQAJKS6XaYZQTT1NRw2YsopagBqEBwWCI9CCVptaiI5plU1RjuuZkFqXq/SBJD09TMJrAGmIqi5CAAoi1dBozFBGnLUYrUZqwiRefyhSKxWoA7LGXMQ3MwxGo+tY/HE8nyM105miNnczEsUqXCqR2q2W5dg6i1q4gB+GOGOEIpGio5iszkv2bkij5yKs5AA=). However, it doesn't seem to produce a diagnostic. If you are able to produce a SharpLab which does produce the undesired diagnostic, that would be really helpful.
<issue_comment>username_0: @username_3 If you add `CancellationToken cancellationToken = default` as a parameter to the method you call in the loop it should produce the diagnostic. You can see it in this [SharpLab](https://sharplab.io/#v2:EYLgtghglgdgNAExAagD4GIYFcA2OLA4CmABETAcQLABQtAAgEwCMDADCfcwCwDc7nZgDoAMrACO/GvQ5chAFQAWAJyIQEsAOZSZggKxTaFMEQDOABwgBjUgDlc+YFBxQALgE95Z17QDetEkDORkEAdgCg/xogmMEANk4ADk4EgFloGAAKLjYAbQBdEghlTVMASgjYkiiqqvoATk4OADdikgRgAGEAexhXIgAPVxIAXhIYIgB3Ei9TVwARLt7+ocyyw2jamNblEn650fGpkjE5gB5Z1wA+Neqj6cvbgF8Nre22iBhew/3XIQBlIjEKyuTIQUZXSpvGITSZQ6GBGoIrYQIT2PCUIj/VzKLTwhFPfFVda0ImxABm3V2mR2JCghzYvDpJDOJGYTKgyGQFU20KRyMCDXaSz6gz+/wgzSInUUn00ZgAgqZ3DArGspMjCbzYlqYlqofQAMzBGbeRY9UVDEggEgASSVKqs8ygFm6pkxUP5sSNJAAahAcFgiPQEs7XaYiA7VWsyV6tq4VN1prCSLZuq5bWBzMQTKKEABRAY2cyuKC9dVk/XamI+5pQZSuLABlIkCVSmVyxXK6OdT42DGl3ryboAa3IJCsfaB+EHMGHY5ghwQRHJEFwrh5WzjtQTyiT91T6cz2aIuf6BaLRBLZayJOrQV1D9J2p9TFNc09ZNfzDYAH5Uw4mLYriMCaHc8quEyEaQSQj6BFqWpAA==).
<issue_comment>username_4: It seems the issue comes about when a property of an object is a nullable reference type, but is subsequently able to be inferred to be non-nullable (via an explicit check for null or via nullability attributes of calling method). The inferred type of the field in anonymous object is then determined to be non-nullable, which causes the mismatch.
<issue_comment>username_3: I'll need to look at this more closely to be sure I understand the issue, and particularly determine what we changed that made this start to become a problem, but at a glance I am wondering if this is another scenario where "nullable-covariant" conversions should be allowed. That is, if we simply allowed the anonymous type `new { string Name }` to convert to the anonymous type `new { string? Name }`, would the problem go away? cc @jcouv.
<issue_comment>username_4: @username_3 My understanding is that the anonymous types that differ only by property nullability are not created as separate types, but rather the exact same type generated by compiler. The following tests pass:

```
        [Fact]
        public void test1()
        {
            var x = new {Test1 = (string?) null};
            var y = new {Test1 = "xyz"};

            x.GetType().Should().BeSameAs(y.GetType());
        }

        [Fact]
        public void test2()
        {
            var x = new[] {new {Test1 = (string?) null}};
            var y = new[] {new {Test1 = "xyz"}};

            x.GetType().Should().BeSameAs(y.GetType());
        }
```
<issue_comment>username_3: I noticed that the presence of the warning depends on whether 'default' is passed for the CancellationToken parameter. If you pass a non-'default' CancellationToken, there is no warning. [SharpLab](https://sharplab.io/#v2:EYLgtghglgdgNAExAagD4GIYFcA2OLA4CmABETAcQLABQtAAgEwCMDADCfcwCwDc7nZgDoAMrACO/GvQ5chAFQAWAJyIQEsAOZSZggKxTaFMEQDOABwgBjUgDlc+YFBxQALgE95Z17QDetEkDORkEAdgCg/xogmMEANk4ADk4EgFloGAAKLjYAbQBdEghlTVM4EgBhCBgbPAhXKAB7GHlGgGtyEitXAEoI2JIogYH6AE5ODgA3YpIEYArm1yIAD1cSAF4SGCIAdxIvU1cAEXnFlddMnsNo4Zjp5RIlw42t3ZIxQ4AeA9cAPkvBq89j8AQBfa63O4zarNF5PVxCADKRGI3UyEA2v36kJi2x22JxgSGhNuECE9jqhCIiNcyi0BMJoIZAyutGZsQAZo0Hpl7iQoC82Lx+SRPiRmMKoMhkH0bjjiSTAmNZqcYEtVkiIJMiBVFNVNGYAIKmdw1TLdVlyyFMq0xG12tlW+gAZmC+28JwWavOJBAJAAksbTVYjlALI1TJQiNiFbEXSQAGoQHBYIj0BKh8OmIhBs2y26x26uFSNPZ4ki2Rquf1gczEEzehAAUWWNnMDWalyktxt7PjkygylcWGTKRIiK1Or1MANplzVkyVRqKPwHZa7U6VmqtVXTXXHRg+eGheGxeUpaBFarNbrRAbS2braI7b3XfZ9qCvadrqY7sOMb7H9mDYAB+CsHCjGk6RnQEDVcYVs3gkgP0CG0bSAA)

@cston I wondered if this is potentially related to the recent nullable lambda state optimizations. Is there a remote chance that the state of the `default` argument is being assigned to the slot for the `Test.NullableString` and causing this warning?In modern terms, this is “the attribution problem.” And, for the past two decades, marketers (and many analysts) have believed that the increasing reliance on digital marketing would finally solve that problem: since digital allows the tracking of individual users across multiple interactions and all the way to their conversion then, surely, that should provide sufficient data to quantify the value of each of those interactions.
Unfortunately, underpinning this expectation is a fairly profound confusion of the difference between “assignment of value” and “measurement of value.” Google’s recent announcements regarding “data-driven attribution” muddy the waters further, unfortunately, in that they imply measurement when, in reality, they are still largely doing assignment…but with complexity inside a black box.
Is this simply semantics?
While it may feel like “assignment of value” is pretty much the same thing as “measurement of value,” they are profoundly different things.
Measurement of value is actually quantifying the incremental impact of a channel, campaign, or touchpoint. In theory, this would be the “true value,” but absolute truth is unknowable, so, rather, it’s an “estimate of the true incremental value” delivered.
